All tests working, second time around.

app/dao/users_dao.py

@@ -1,9 +1,15 @@
-from datetime import datetime
+import random
+from datetime import (datetime, timedelta)
 from . import DAOException
 from sqlalchemy.orm import load_only
 
 from app import db
-from app.models import User
+from app.models import (User, VerifyCode)
+from app.encryption import hashpw
+
+
+def create_secret_code():
+    return ''.join(map(str, random.sample(range(9), 5)))
 
 
 def save_model_user(usr, update_dict={}):
@@ -16,6 +22,37 @@ def save_model_user(usr, update_dict={}):
     db.session.commit()
 
 
+def create_user_code(user, code, code_type):
+    verify_code = VerifyCode(code_type=code_type,
+                             expiry_datetime=datetime.now() + timedelta(hours=1),
+                             user=user)
+    verify_code.code = code
+    db.session.add(verify_code)
+    db.session.commit()
+    return verify_code
+
+
+def get_user_code(user, code, code_type):
+    # Get the most recent codes to try and reduce the
+    # time searching for the correct code.
+    codes = VerifyCode.query.filter_by(
+        user=user, code_type=code_type).order_by(
+            VerifyCode.created_at.desc())
+    retval = None
+    for x in codes:
+        if x.check_code(code):
+            retval = x
+            break
+    return retval
+
+
+def use_user_code(id):
+    verify_code = VerifyCode.query.get(id)
+    verify_code.code_used = True
+    db.session.add(verify_code)
+    db.session.commit()
+
+
 def delete_model_user(user):
     db.session.delete(user)
     db.session.commit()

app/models.py

@@ -146,3 +146,34 @@ class Job(db.Model):
         unique=False,
         nullable=True,
         onupdate=datetime.datetime.now)
+
+
+class VerifyCode(db.Model):
+    __tablename__ = 'verify_codes'
+
+    code_types = ['email', 'sms']
+
+    id = db.Column(db.Integer, primary_key=True)
+    user_id = db.Column(db.Integer, db.ForeignKey('users.id'), index=True, nullable=False)
+    user = db.relationship('User', backref=db.backref('verify_codes', lazy='dynamic'))
+    _code = db.Column(db.String, nullable=False)
+    code_type = db.Column(db.Enum(*code_types, name='verify_code_types'), index=False, unique=False, nullable=False)
+    expiry_datetime = db.Column(db.DateTime, nullable=False)
+    code_used = db.Column(db.Boolean, default=False)
+    created_at = db.Column(
+        db.DateTime,
+        index=False,
+        unique=False,
+        nullable=False,
+        default=datetime.datetime.now)
+
+    @property
+    def code(self):
+        raise AttributeError("Code not readable")
+
+    @code.setter
+    def code(self, cde):
+        self._code = hashpw(cde)
+
+    def check_code(self, cde):
+        return check_hash(cde, self._code)

app/schemas.py

@@ -10,7 +10,9 @@ from . import models
 class UserSchema(ma.ModelSchema):
     class Meta:
         model = models.User
-        exclude = ("updated_at", "created_at", "user_to_service", "_password")
+        exclude = (
+            "updated_at", "created_at", "user_to_service",
+            "_password", "verify_codes")
 
 
 # TODO process users list, to return a list of user.id
@@ -38,6 +40,12 @@ class JobSchema(ma.ModelSchema):
         model = models.Job
 
 
+class VerifyCodeSchema(ma.ModelSchema):
+    class Meta:
+        model = models.VerifyCode
+        exclude = ('user', "_code", "expiry_datetime", "code_used", "created_at")
+
+
 user_schema = UserSchema()
 users_schema = UserSchema(many=True)
 service_schema = ServiceSchema()
@@ -48,3 +56,4 @@ api_key_schema = ApiKeySchema()
 api_keys_schema = ApiKeySchema(many=True)
 job_schema = JobSchema()
 jobs_schema = JobSchema(many=True)
+verify_code_schema = VerifyCodeSchema()

app/user/rest.py

@@ -1,15 +1,19 @@
+from datetime import datetime
 from flask import (jsonify, request)
 from sqlalchemy.exc import DataError
 from sqlalchemy.orm.exc import NoResultFound
 from app.dao.services_dao import get_model_services
 from app.dao.users_dao import (
-    get_model_users, save_model_user, delete_model_user)
+    get_model_users, save_model_user, delete_model_user,
+    create_user_code, get_user_code, use_user_code,
+    create_secret_code)
 from app.schemas import (
-    user_schema, users_schema, service_schema, services_schema)
+    user_schema, users_schema, service_schema, services_schema,
+    verify_code_schema)
 from app import db
-
-
 from flask import Blueprint
+
+
 user = Blueprint('user', __name__)
 
 
@@ -57,19 +61,81 @@ def verify_user_password(user_id):
         return jsonify(result="error", message="Invalid user id"), 400
     except NoResultFound:
         return jsonify(result="error", message="User not found"), 404
-    text_pwd = None
+    txt_pwd = None
     try:
-        text_pwd = request.get_json()['password']
+        txt_pwd = request.get_json()['password']
     except KeyError:
         return jsonify(
             result="error",
             message={'password': ['Required field missing data']}), 400
-    if user.check_password(text_pwd):
+    if user.check_password(txt_pwd):
         return jsonify(), 204
     else:
         return jsonify(result='error', message={'password': ['Incorrect password']}), 400
 
 
+@user.route('/<int:user_id>/verify/code', methods=['POST'])
+def verify_user_code(user_id):
+    try:
+        user = get_model_users(user_id=user_id)
+    except DataError:
+        return jsonify(result="error", message="Invalid user id"), 400
+    except NoResultFound:
+        return jsonify(result="error", message="User not found"), 404
+    txt_code = None
+    resp_json = request.get_json()
+    txt_type = None
+    errors = {}
+    try:
+        txt_code = resp_json['code']
+    except KeyError:
+        errors.update({'code': ['Required field missing data']})
+    try:
+        txt_type = resp_json['code_type']
+    except KeyError:
+        errors.update({'code_type': ['Required field missing data']})
+    if errors:
+        return jsonify(result="error", message=errors), 400
+    code = get_user_code(user, txt_code, txt_type)
+    if not code:
+        return jsonify(result="error", message="Code not found"), 404
+    if datetime.now() > code.expiry_datetime or code.code_used:
+        return jsonify(result="error", message="Code has expired"), 400
+    use_user_code(code.id)
+    return jsonify(), 204
+
+
+@user.route('/<int:user_id>/code/', methods=['POST'])
+def send_user_code(user_id):
+    try:
+        user = get_model_users(user_id=user_id)
+    except DataError:
+        return jsonify(result="error", message="Invalid user id"), 400
+    except NoResultFound:
+        return jsonify(result="error", message="User not found"), 404
+    text_pwd = None
+    verify_code, errors = verify_code_schema.load(request.get_json())
+    if errors:
+        return jsonify(result="error", message=errors), 400
+    code = create_user_code(
+        user, create_secret_code(), verify_code.code_type)
+    # TODO this will need to fixed up when we stop using
+    # notify_alpha_client
+    if verify_code.code_type == 'sms':
+        notify_alpha_client.send_sms(
+            mobile_number=user.mobile_number,
+            message=code.code)
+    elif verify_code.code_type == 'email':
+        notify_alpha_client.send_email(
+            user.email_address,
+            code.code,
+            'notify@digital.cabinet-office.gov.uk',
+            'Verification code')
+    else:
+        abort(500)
+    return jsonify(), 204
+
+
 @user.route('/<int:user_id>', methods=['GET'])
 @user.route('/', methods=['GET'])
 def get_user(user_id=None):