Created endpoints for create and delete token.

app/dao/api_tokens_dao.py

@@ -1,17 +0,0 @@
-from app import db
-from app.models import ApiToken
-
-
-def save_token_model(token, update_dict={}):
-    if update_dict:
-        del update_dict['id']
-        db.session.query(ApiToken).filter_by(id=token.id).update(update_dict)
-    else:
-        db.session.add(token)
-    db.session.commit()
-
-
-def get_model_api_tokens(token=None):
-    if token:
-        return ApiToken.query.filter_by(token=token).one()
-    return ApiToken.query.filter_by().all()

app/dao/tokens_dao.py

@@ -0,0 +1,22 @@
+from app import db
+from app.models import Token
+
+
+def save_token_model(token, update_dict={}):
+    if update_dict:
+        del update_dict['id']
+        db.session.query(Token).filter_by(id=token.id).update(update_dict)
+    else:
+        db.session.add(token)
+    db.session.commit()
+
+
+def get_model_tokens(service_id=None):
+    if service_id:
+        return Token.query.filter_by(service_id=service_id).one()
+    return Token.query.filter_by().all()
+
+
+def delete_model_token(token):
+    db.session.delete(token)
+    db.session.commit()

app/models.py

@@ -61,8 +61,8 @@ class Service(db.Model):
     restricted = db.Column(db.Boolean, index=False, unique=False, nullable=False)
 
 
-class ApiToken(db.Model):
-    __tablename__ = 'api_tokens'
+class Token(db.Model):
+    __tablename__ = 'tokens'
 
     id = db.Column(db.Integer, primary_key=True)
     token = db.Column(db.String, unique=True, nullable=False)

app/schemas.py

@@ -28,15 +28,15 @@ class TemplateSchema(ma.ModelSchema):
         exclude = ("updated_at", "created_at", "service_id")
 
 
-class ApiTokenSchema(ma.ModelSchema):
+class TokenSchema(ma.ModelSchema):
     class Meta:
-        model = models.ApiToken
+        model = models.Token
 
 user_schema = UserSchema()
 users_schema = UserSchema(many=True)
 service_schema = ServiceSchema()
 services_schema = ServiceSchema(many=True)
-api_token_schema = ApiTokenSchema()
-api_tokens_schema = ApiTokenSchema(many=True)
 template_schema = TemplateSchema()
 templates_schema = TemplateSchema(many=True)
+token_schema = TokenSchema()
+tokens_schema = TokenSchema(many=True)

app/service/views/rest.py

@@ -1,13 +1,20 @@
-from flask import (jsonify, request)
+import uuid
+from datetime import datetime
+from flask import (jsonify, request, current_app)
 from sqlalchemy.exc import DataError
 from sqlalchemy.orm.exc import NoResultFound
 from app.dao.services_dao import (
     save_model_service, get_model_services, delete_model_service)
+from app.dao.tokens_dao import (save_token_model, get_model_tokens, delete_model_token)
+from app.dao.users_dao import get_model_users
 from app.dao.templates_dao import (
     save_model_template, get_model_templates)
 from app.dao import DAOException
 from .. import service
 from app import db
+from app.schemas import (services_schema, service_schema, token_schema)
+from app.models import Token
+from itsdangerous import URLSafeSerializer
 from app.schemas import (
     services_schema, service_schema, template_schema, templates_schema)
 
@@ -73,8 +80,48 @@ def get_service(service_id=None):
 
 # TODO auth to be added
 @service.route('/<int:service_id>/token', methods=['POST'])
-def create_token():
-    request.get_json()
+def create_token(service_id=None):
+    try:
+        service = get_model_services(service_id=service_id)
+    except DataError:
+        return jsonify(result="error", message="Invalid service id"), 400
+    except NoResultFound:
+        return jsonify(result="error", message="Service not found"), 404
+
+    token = _generate_token()
+    try:
+        try:
+            service_token = get_model_tokens(service_id=service_id)
+            save_token_model(service_token, update_dict={'id': service_token.id,
+                                                         'token': service_token.token,
+                                                         'expiry_date': datetime.now()})
+        except NoResultFound:
+            pass
+        save_token_model(Token(service_id=service_id, token=token))
+    except DAOException as e:
+        return jsonify(result='error', message=str(e)), 400
+    return jsonify(token=str(token)), 201
+
+
+@service.route('/<int:service_id>/token', methods=['DELETE'])
+def delete_token(service_id):
+    try:
+        token = get_model_tokens(service_id=service_id)
+        delete_model_token(token)
+        return jsonify(data=token_schema.dump(token).data), 202
+    except NoResultFound:
+        return jsonify(result="error", message="Token not found"), 404
+
+
+def _generate_token():
+    token = uuid.uuid4()
+    serializer = URLSafeSerializer(current_app.config.get('SECRET_KEY'))
+    return serializer.dumps(str(token), current_app.config.get('DANGEROUS_SALT'))
+
+
+def _get_token(token):
+    serializer = URLSafeSerializer(current_app.config.get('SECRET_KEY'))
+    return serializer.loads(token, salt=current_app.config.get('DANGEROUS_SALT'))
 
 
 # TODO auth to be added.