Merge branch 'master' into proxy-to-alpha

app/authentication/auth.py

@@ -2,7 +2,7 @@ from flask import request, jsonify, _request_ctx_stack
 from client.authentication import decode_jwt_token, get_token_issuer
 from client.errors import TokenDecodeError, TokenRequestError, TokenExpiredError, TokenPayloadError
 
-from app.dao.tokens_dao import get_unsigned_token
+from app.dao.api_key_dao import get_unsigned_secret
 
 
 def authentication_response(message, code):
@@ -48,5 +48,5 @@ def requires_auth():
 def fetch_client(client):
     return {
         "client": client,
-        "secret": get_unsigned_token(client)
+        "secret": get_unsigned_secret(client)
     }

app/dao/api_key_dao.py

@@ -0,0 +1,52 @@
+from flask import current_app
+from itsdangerous import URLSafeSerializer
+
+from app import db
+from app.models import ApiKey
+
+
+def save_model_api_key(api_key, update_dict={}):
+    if update_dict:
+        if update_dict['id']:
+            del update_dict['id']
+        db.session.query(ApiKey).filter_by(id=api_key.id).update(update_dict)
+    else:
+        api_key.secret = _generate_secret()
+        db.session.add(api_key)
+    db.session.commit()
+
+
+def get_model_api_keys(service_id=None, raise_=True):
+    """
+    :param raise_: when True query api_keys using one() which will raise NoResultFound exception
+                   when False query api_keys usong first() which will return None and not raise an exception.
+    """
+    if service_id:
+        # If expiry date is None the api_key is active
+        if raise_:
+            return ApiKey.query.filter_by(service_id=service_id, expiry_date=None).one()
+        else:
+            return ApiKey.query.filter_by(service_id=service_id, expiry_date=None).first()
+    return ApiKey.query.filter_by().all()
+
+
+def get_unsigned_secret(service_id):
+    """
+    There should only be one valid api_keys for each service.
+    This method can only be exposed to the Authentication of the api calls.
+    """
+    api_key = ApiKey.query.filter_by(service_id=service_id, expiry_date=None).one()
+    return _get_secret(api_key.secret)
+
+
+def _generate_secret(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_secret(signed_secret):
+    serializer = URLSafeSerializer(current_app.config.get('SECRET_KEY'))
+    return serializer.loads(signed_secret, salt=current_app.config.get('DANGEROUS_SALT'))

app/dao/tokens_dao.py

@@ -1,51 +0,0 @@
-from flask import current_app
-from itsdangerous import URLSafeSerializer
-
-from app import db
-from app.models import Token
-
-
-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_:
-            return Token.query.filter_by(service_id=service_id, expiry_date=None).one()
-        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/dao/users_dao.py

@@ -8,7 +8,8 @@ from app.models import User
 
 def save_model_user(usr, update_dict={}):
     if update_dict:
-        del update_dict['id']
+        if update_dict.get('id'):
+            del update_dict['id']
         db.session.query(User).filter_by(id=usr.id).update(update_dict)
     else:
         db.session.add(usr)

app/encryption.py

@@ -0,0 +1,10 @@
+from flask.ext.bcrypt import generate_password_hash, check_password_hash
+
+
+def hashpw(password):
+    return generate_password_hash(password.encode('UTF-8'), 10)
+
+
+def check_hash(password, hashed_password):
+    # If salt is invalid throws a 500 should add try/catch here
+    return check_password_hash(hashed_password, password)

app/models.py

@@ -2,6 +2,10 @@ from . import db
 import datetime
 
 from sqlalchemy.dialects.postgresql import UUID
+from app.encryption import (
+    hashpw,
+    check_hash
+)
 
 
 def filter_null_value_fields(obj):
@@ -14,6 +18,7 @@ class User(db.Model):
     __tablename__ = 'users'
 
     id = db.Column(db.Integer, primary_key=True)
+    name = db.Column(db.String, nullable=False, index=True, unique=False)
     email_address = db.Column(db.String(255), nullable=False, index=True, unique=True)
     created_at = db.Column(
         db.DateTime,
@@ -27,6 +32,23 @@ class User(db.Model):
         unique=False,
         nullable=True,
         onupdate=datetime.datetime.now)
+    _password = db.Column(db.String, index=False, unique=False, nullable=False)
+    mobile_number = db.Column(db.String, index=False, unique=False, nullable=False)
+    password_changed_at = db.Column(db.DateTime, index=False, unique=False, nullable=True)
+    logged_in_at = db.Column(db.DateTime, nullable=True)
+    failed_login_count = db.Column(db.Integer, nullable=False, default=0)
+    state = db.Column(db.String, nullable=False, default='pending')
+
+    @property
+    def password(self):
+        raise AttributeError("Password not readable")
+
+    @password.setter
+    def password(self, password):
+        self._password = hashpw(password)
+
+    def check_password(self, password):
+        return check_hash(password, self._password)
 
 
 user_to_service = db.Table(
@@ -63,13 +85,14 @@ class Service(db.Model):
     restricted = db.Column(db.Boolean, index=False, unique=False, nullable=False)
 
 
-class Token(db.Model):
-    __tablename__ = 'tokens'
+class ApiKey(db.Model):
+    __tablename__ = 'api_key'
 
     id = db.Column(db.Integer, primary_key=True)
-    token = db.Column(db.String(255), unique=True, nullable=False)
+    name = db.Column(db.String(255), nullable=False)
+    secret = db.Column(db.String(255), unique=True, nullable=False)
     service_id = db.Column(db.Integer, db.ForeignKey('services.id'), index=True, nullable=False)
-    service = db.relationship('Service', backref=db.backref('tokens', lazy='dynamic'))
+    service = db.relationship('Service', backref=db.backref('api_keys', lazy='dynamic'))
     expiry_date = db.Column(db.DateTime)
 
 

app/schemas.py

@@ -1,6 +1,5 @@
 from . import ma
 from . import models
-from marshmallow import post_load
 
 # TODO I think marshmallow provides a better integration and error handling.
 # Would be better to replace functionality in dao with the marshmallow supported
@@ -11,7 +10,7 @@ from marshmallow import post_load
 class UserSchema(ma.ModelSchema):
     class Meta:
         model = models.User
-        exclude = ("updated_at", "created_at", "user_to_service")
+        exclude = ("updated_at", "created_at", "user_to_service", "_password")
 
 
 # TODO process users list, to return a list of user.id
@@ -19,7 +18,7 @@ class UserSchema(ma.ModelSchema):
 class ServiceSchema(ma.ModelSchema):
     class Meta:
         model = models.Service
-        exclude = ("updated_at", "created_at", "tokens", "templates", "jobs")
+        exclude = ("updated_at", "created_at", "api_keys", "templates", "jobs")
 
 
 class TemplateSchema(ma.ModelSchema):
@@ -28,10 +27,10 @@ class TemplateSchema(ma.ModelSchema):
         exclude = ("updated_at", "created_at", "service_id", "jobs")
 
 
-class TokenSchema(ma.ModelSchema):
+class ApiKeySchema(ma.ModelSchema):
     class Meta:
-        model = models.Token
-        exclude = ["service"]
+        model = models.ApiKey
+        exclude = ("service", "secret", "expiry_date")
 
 
 class JobSchema(ma.ModelSchema):
@@ -45,7 +44,7 @@ service_schema = ServiceSchema()
 services_schema = ServiceSchema(many=True)
 template_schema = TemplateSchema()
 templates_schema = TemplateSchema(many=True)
-token_schema = TokenSchema()
-tokens_schema = TokenSchema(many=True)
+api_key_schema = ApiKeySchema()
+api_keys_schema = ApiKeySchema(many=True)
 job_schema = JobSchema()
 jobs_schema = JobSchema(many=True)

app/service/rest.py

@@ -1,6 +1,6 @@
 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
 
@@ -10,8 +10,8 @@ from app.dao.services_dao import (
     save_model_service, get_model_services, delete_model_service)
 from app.dao.templates_dao import (
     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 app.dao.api_key_dao import (save_model_api_key, get_model_api_keys, get_unsigned_secret)
+from app.models import ApiKey
 from app.schemas import (
     services_schema, service_schema, template_schema)
 
@@ -29,13 +29,11 @@ def create_service():
     # db.session.commit
     try:
         save_model_service(service)
-        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=get_unsigned_token(service.id)), 201
+    return jsonify(data=service_schema.dump(service).data), 201
 
 
-# TODO auth to be added
 @service.route('/<int:service_id>', methods=['PUT', 'DELETE'])
 def update_service(service_id):
     try:
@@ -64,7 +62,6 @@ def update_service(service_id):
     return jsonify(data=service_schema.dump(service).data), status_code
 
 
-# TODO auth to be added.
 @service.route('/<int:service_id>', methods=['GET'])
 @service.route('/', methods=['GET'])
 def get_service(service_id=None):
@@ -78,31 +75,32 @@ def get_service(service_id=None):
     return jsonify(data=data)
 
 
-# TODO auth to be added
-@service.route('/<int:service_id>/token/renew', methods=['POST'])
-def renew_token(service_id=None):
+@service.route('/<int:service_id>/api-key/renew', methods=['POST'])
+def renew_api_key(service_id=None):
     try:
-        get_model_services(service_id=service_id)
+        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
 
     try:
-        service_token = get_model_tokens(service_id=service_id, raise_=False)
-        if service_token:
-            # expire existing token
-            save_model_token(service_token, update_dict={'id': service_token.id, 'expiry_date': datetime.now()})
+        service_api_key = get_model_api_keys(service_id=service_id, raise_=False)
+        if service_api_key:
+            # expire existing api_key
+            save_model_api_key(service_api_key, update_dict={'id': service_api_key.id, 'expiry_date': datetime.now()})
         # create a new one
-        save_model_token(Token(service_id=service_id))
+        # TODO: what validation should be done here?
+        secret_name = request.get_json()['name']
+        save_model_api_key(ApiKey(service=service, name=secret_name))
     except DAOException as e:
         return jsonify(result='error', message=str(e)), 400
-    unsigned_token = get_unsigned_token(service_id)
-    return jsonify(data=unsigned_token), 201
+    unsigned_api_key = get_unsigned_secret(service_id)
+    return jsonify(data=unsigned_api_key), 201
 
 
-@service.route('/<int:service_id>/token/revoke', methods=['POST'])
-def revoke_token(service_id):
+@service.route('/<int:service_id>/api-key/revoke', methods=['POST'])
+def revoke_api_key(service_id):
     try:
         get_model_services(service_id=service_id)
     except DataError:
@@ -110,13 +108,12 @@ def revoke_token(service_id):
     except NoResultFound:
         return jsonify(result="error", message="Service not found"), 404
 
-    service_token = get_model_tokens(service_id=service_id, raise_=False)
-    if service_token:
-        save_model_token(service_token, update_dict={'id': service_token.id, 'expiry_date': datetime.now()})
+    service_api_key = get_model_api_keys(service_id=service_id, raise_=False)
+    if service_api_key:
+        save_model_api_key(service_api_key, update_dict={'id': service_api_key.id, 'expiry_date': datetime.now()})
     return jsonify(), 202
 
 
-# TODO auth to be added.
 @service.route('/<int:service_id>/template/', methods=['POST'])
 def create_template(service_id):
     try:
@@ -135,7 +132,6 @@ def create_template(service_id):
     return jsonify(data=template_schema.dump(template).data), 201
 
 
-# TODO auth to be added
 @service.route('/<int:service_id>/template/<int:template_id>', methods=['PUT', 'DELETE'])
 def update_template(service_id, template_id):
     try:

app/user/rest.py

@@ -17,8 +17,14 @@ user = Blueprint('user', __name__)
 @user.route('', methods=['POST'])
 def create_user():
     user, errors = user_schema.load(request.get_json())
+    req_json = request.get_json()
+    if not req_json.get('password'):
+        errors = {'password': ['Missing data for required field.']}
+        return jsonify(result="error", message=errors), 400
     if errors:
         return jsonify(result="error", message=errors), 400
+
+    user.password = req_json.get('password')
     save_model_user(user)
     return jsonify(data=user_schema.dump(user).data), 201
 
@@ -36,16 +42,11 @@ def update_user(user_id):
         status_code = 202
         delete_model_user(user)
     else:
+        # TODO removed some validation checking by using load
+        # which will need to be done in another way
         status_code = 200
-        # TODO there has got to be a better way to do the next three lines
-        update_user, errors = user_schema.load(request.get_json())
-        if errors:
-            return jsonify(result="error", message=errors), 400
-        update_dict, errors = user_schema.dump(update_user)
-        # TODO FIX ME
-        # Remove update_service model which is added to db.session
         db.session.rollback()
-        save_model_user(user, update_dict=update_dict)
+        save_model_user(user, update_dict=request.get_json())
     return jsonify(data=user_schema.dump(user).data), status_code