Moved the _generate_token methods to the tokens_dao.

app/dao/tokens_dao.py

@@ -1,17 +1,25 @@
+from flask import current_app
+from itsdangerous import URLSafeSerializer
+
 from app import db
 from app.models import Token
 
 
-def save_token_model(token, update_dict={}):
+def save_model_token(token, update_dict={}):
     if update_dict:
         del update_dict['id']
         db.session.query(Token).filter_by(id=token.id).update(update_dict)
     else:
+        token.token = _generate_token()
         db.session.add(token)
     db.session.commit()
 
 
 def get_model_tokens(service_id=None, raise_=True):
+    """
+    :param raise_: when True query tokens using one() which will raise NoResultFound exception
+                   when False query tokens usong first() which will return None and not raise an exception.
+    """
     if service_id:
         # If expiry date is None the token is active
         if raise_:
@@ -19,3 +27,25 @@ def get_model_tokens(service_id=None, raise_=True):
         else:
             return Token.query.filter_by(service_id=service_id, expiry_date=None).first()
     return Token.query.filter_by().all()
+
+
+def get_unsigned_token(service_id):
+    """
+    There should only be one valid token for each service.
+    This method can only be exposed to the Authentication of the api calls.
+    """
+    token = Token.query.filter_by(service_id=service_id, expiry_date=None).one()
+    return _get_token(token.token)
+
+
+def _generate_token(token=None):
+    import uuid
+    if not 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'))

app/schemas.py

@@ -31,6 +31,8 @@ class TemplateSchema(ma.ModelSchema):
 class TokenSchema(ma.ModelSchema):
     class Meta:
         model = models.Token
+        exclude = ["service"]
+
 
 user_schema = UserSchema()
 users_schema = UserSchema(many=True)

app/service/views/rest.py

@@ -1,22 +1,20 @@
-import uuid
 from datetime import datetime
-from flask import (jsonify, request, current_app)
+
+from flask import (jsonify, request)
 from sqlalchemy.exc import DataError
 from sqlalchemy.orm.exc import NoResultFound
+
+from app import db
+from app.dao import DAOException
 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)
-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)
+    save_model_template, get_model_templates, delete_model_template)
+from app.dao.tokens_dao import (save_model_token, get_model_tokens, get_unsigned_token)
 from app.models import Token
-from itsdangerous import URLSafeSerializer
 from app.schemas import (
-    services_schema, service_schema, template_schema, templates_schema)
+    services_schema, service_schema, template_schema)
+from .. import service
 
 
 # TODO auth to be added.
@@ -30,11 +28,10 @@ def create_service():
     # db.session.commit
     try:
         save_model_service(service)
-        token = str(uuid.uuid4())
-        save_token_model(Token(service_id=service.id, token=_generate_token(token)))
+        save_model_token(Token(service_id=service.id))
     except DAOException as e:
         return jsonify(result="error", message=str(e)), 400
-    return jsonify(data=service_schema.dump(service).data, token=token), 201
+    return jsonify(data=service_schema.dump(service).data, token=get_unsigned_token(service.id)), 201
 
 
 # TODO auth to be added
@@ -84,30 +81,29 @@ def get_service(service_id=None):
 @service.route('/<int:service_id>/token/renew', methods=['POST'])
 def renew_token(service_id=None):
     try:
-        service = get_model_services(service_id=service_id)
+        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:
         service_token = get_model_tokens(service_id=service_id, raise_=False)
         if service_token:
             # expire existing token
-            save_token_model(service_token, update_dict={'id': service_token.id, 'expiry_date': datetime.now()})
+            save_model_token(service_token, update_dict={'id': service_token.id, 'expiry_date': datetime.now()})
         # create a new one
-        save_token_model(Token(service_id=service_id, token=token))
+        save_model_token(Token(service_id=service_id))
     except DAOException as e:
         return jsonify(result='error', message=str(e)), 400
-    unsigned_token = str(_get_token(token))
+    unsigned_token = get_unsigned_token(service_id)
     return jsonify(data=unsigned_token), 201
 
 
 @service.route('/<int:service_id>/token/revoke', methods=['POST'])
 def revoke_token(service_id):
     try:
-        service = get_model_services(service_id=service_id)
+        get_model_services(service_id=service_id)
     except DataError:
         return jsonify(result="error", message="Invalid service id"), 400
     except NoResultFound:
@@ -115,20 +111,8 @@ def revoke_token(service_id):
 
     service_token = get_model_tokens(service_id=service_id, raise_=False)
     if service_token:
-        save_token_model(service_token, update_dict={'id': service_token.id, 'expiry_date': datetime.now()})
-    return jsonify(data=token_schema.dump(service_token)), 202
-
-
-def _generate_token(token=None):
-    if not 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'))
+        save_model_token(service_token, update_dict={'id': service_token.id, 'expiry_date': datetime.now()})
+    return jsonify(), 202
 
 
 # TODO auth to be added.