Added version history to api keys. This needed a bit of change

to create history to handle foreign keys better. There may yet
be a better way of doing this that I have not found yet in sqlalchemy
docs.

app/dao/api_key_dao.py

@@ -1,19 +1,30 @@
+import uuid
 from flask import current_app
 from itsdangerous import URLSafeSerializer
 
 from app import db
 from app.models import ApiKey
 
+from app.dao.dao_utils import (
+    transactional,
+    versioned
+)
 
+
+@transactional
+@versioned
 def save_model_api_key(api_key, update_dict={}):
     if update_dict:
-        if update_dict['id']:
+        if update_dict.get('id'):
             del update_dict['id']
-        db.session.query(ApiKey).filter_by(id=api_key.id).update(update_dict)
+        for key, value in update_dict.items():
+            setattr(api_key, key, update_dict[key])
+        db.session.add(api_key)
     else:
+        if not api_key.id:
+            api_key.id = uuid.uuid4()  # must be set now so version history model can use same id
         api_key.secret = _generate_secret()
         db.session.add(api_key)
-    db.session.commit()
 
 
 def get_model_api_keys(service_id, id=None):

app/dao/dao_utils.py

@@ -1,22 +1,6 @@
-import datetime
-
+import itertools
 from functools import wraps
-
-
-def create_history(obj):
-    history_mapper = obj.__history_mapper__
-    history_model = history_mapper.class_
-    history = history_model()
-    if obj.version:
-        obj.version += 1
-    else:
-        obj.version = 1
-        obj.created_at = datetime.datetime.now()
-    for prop in history_mapper.iterate_properties:
-        if obj.__mapper__.get_property(prop.key):
-            setattr(history, prop.key, getattr(obj, prop.key))
-    history.created_by_id = obj.created_by.id
-    return history
+from app.history_meta import versioned_objects, create_history
 
 
 def transactional(func):
@@ -37,12 +21,10 @@ def transactional(func):
 def versioned(func):
     @wraps(func)
     def record_version(*args, **kwargs):
-        import itertools
         from app import db
-        from app.history_meta import versioned_objects
-        from app.dao.dao_utils import create_history
         func(*args, **kwargs)
-        for obj in versioned_objects(itertools.chain(db.session.new, db.session.dirty)):
-            history = create_history(obj)
-            db.session.add(history)
+        history_objects = [create_history(obj) for obj in
+                           versioned_objects(itertools.chain(db.session.new, db.session.dirty))]
+        for h_obj in history_objects:
+            db.session.add(h_obj)
     return record_version

app/history_meta.py

@@ -14,10 +14,10 @@ Lastly when to create a version is done manually in dao_utils version decorator
 session events.
 
 """
-
-
+import datetime
 from sqlalchemy.ext.declarative import declared_attr
-from sqlalchemy.orm import mapper
+from sqlalchemy.orm import mapper, attributes, object_mapper
+from sqlalchemy.orm.properties import RelationshipProperty, ColumnProperty
 from sqlalchemy import Table, Column, ForeignKeyConstraint, Integer
 from sqlalchemy import util
 
@@ -160,8 +160,60 @@ class Versioned(object):
             return mp
         return map
 
+    @classmethod
+    def get_history_model(cls):
+        history_mapper = cls.__history_mapper__
+        return history_mapper.class_
+
 
 def versioned_objects(iter):
     for obj in iter:
         if hasattr(obj, '__history_mapper__'):
             yield obj
+
+
+def create_history(obj):
+    obj_mapper = object_mapper(obj)
+    history_mapper = obj.__history_mapper__
+    history_cls = history_mapper.class_
+    history = history_cls()
+
+    obj_state = attributes.instance_state(obj)
+    data = {}
+
+    for prop in obj_mapper.iterate_properties:
+
+        # expired object attributes and also deferred cols might not
+        # be in the dict.  force it them load no matter what by using getattr().
+        if prop.key not in obj_state.dict:
+            getattr(obj, prop.key)
+
+        # if prop is a normal col just set it on history model
+        if isinstance(prop, ColumnProperty):
+            if not data.get(prop.key):
+                data[prop.key] = getattr(obj, prop.key)
+
+        # if the prop is a relationship property and there is a
+        # corresponding prop on hist object then set the
+        # relevant "_id" prop to the id of the current object.prop.id.
+        # This is so foreign keys get set on history when
+        # the source object is new and therefore property foo_id does
+        # not yet have a value before insert
+
+        elif isinstance(prop, RelationshipProperty):
+            if hasattr(history, prop.key+'_id'):
+                data[prop.key+'_id'] = getattr(obj, prop.key).id
+
+    if not obj.version:
+        obj.version = 1
+        obj.created_at = datetime.datetime.now()
+    else:
+        obj.version += 1
+
+    data['version'] = obj.version
+    data['created_at'] = obj.created_at
+
+    for key, value in data.items():
+        setattr(history, key, value)
+
+    return history

app/models.py

@@ -96,13 +96,8 @@ class Service(db.Model, Versioned):
     created_by = db.relationship('User')
     created_by_id = db.Column(UUID(as_uuid=True), db.ForeignKey('users.id'), index=True, nullable=False)
 
-    @classmethod
-    def get_history_model(cls):
-        history_mapper = cls.__history_mapper__
-        return history_mapper.class_
 
-
-class ApiKey(db.Model):
+class ApiKey(db.Model, Versioned):
     __tablename__ = 'api_keys'
 
     id = db.Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
@@ -111,6 +106,20 @@ class ApiKey(db.Model):
     service_id = db.Column(UUID(as_uuid=True), db.ForeignKey('services.id'), index=True, nullable=False)
     service = db.relationship('Service', backref=db.backref('api_keys', lazy='dynamic'))
     expiry_date = db.Column(db.DateTime)
+    created_at = db.Column(
+        db.DateTime,
+        index=False,
+        unique=False,
+        nullable=False,
+        default=datetime.datetime.now)
+    updated_at = db.Column(
+        db.DateTime,
+        index=False,
+        unique=False,
+        nullable=True,
+        onupdate=datetime.datetime.now)
+    created_by = db.relationship('User')
+    created_by_id = db.Column(UUID(as_uuid=True), db.ForeignKey('users.id'), index=True, nullable=False)
 
     __table_args__ = (
         UniqueConstraint('service_id', 'name', name='uix_service_to_key_name'),

app/service/rest.py

@@ -97,21 +97,21 @@ def update_service(service_id):
 def renew_api_key(service_id=None):
     fetched_service = dao_fetch_service_by_id(service_id=service_id)
 
-    # create a new one
-    # TODO: what validation should be done here?
-    secret_name = request.get_json()['name']
-    key = ApiKey(service=fetched_service, name=secret_name)
-    save_model_api_key(key)
+    valid_api_key, errors = api_key_schema.load(request.get_json())
+    if errors:
+        return jsonify(result="error", message=errors), 400
+    valid_api_key.service = fetched_service
 
-    unsigned_api_key = get_unsigned_secret(key.id)
+    save_model_api_key(valid_api_key)
+
+    unsigned_api_key = get_unsigned_secret(valid_api_key.id)
     return jsonify(data=unsigned_api_key), 201
 
 
 @service.route('/<uuid:service_id>/api-key/revoke/<uuid:api_key_id>', methods=['POST'])
 def revoke_api_key(service_id, api_key_id):
     service_api_key = get_model_api_keys(service_id=service_id, id=api_key_id)
-
-    save_model_api_key(service_api_key, update_dict={'id': service_api_key.id, 'expiry_date': datetime.utcnow()})
+    save_model_api_key(service_api_key, update_dict={'expiry_date': datetime.utcnow()})
     return jsonify(), 202