disable activity for activated insertion and deletion

sqlalchemy_api_handler/bases/activate.py

@@ -5,8 +5,9 @@
 from sqlalchemy_api_handler.bases.accessor import Accessor
 from sqlalchemy_api_handler.bases.errors import ActivityError
 from sqlalchemy_api_handler.bases.save import Save
-from sqlalchemy_api_handler.utils.datum import datum_with_relationships_from, \
-                                               merged_datum_from_activities
+from sqlalchemy_api_handler.utils.datum import foreigns_in, \
+                                               merged_datum_from_activities, \
+                                               serialized_datum_from
 
 
 class Activate(Save):
@@ -57,16 +58,30 @@ def _activate_deletion(activity):
             errors.add_error('_activate_deletion',
                              f'entity with the activityIdentifier {activity.entityIdentifier} not found')
             raise errors
-        query.delete()
-        delete_activity = entity.__deleteActivity__
-        delete_activity.dateCreated = activity.dateCreated
-        Save.add(delete_activity)
-        # merge delete_activity into the activity that helped for its creation
-        activity.id = delete_activity.id
-        if delete_activity.transaction:
-            activity.transaction = Activate.get_activity().transaction.mapper.class_()
-            activity.transaction.actor  = delete_activity.transaction.actor
+        with versioning_manager.disable(Activate.get_db().session):
+            query.delete()
+            activity.old_data = serialized_datum_from(entity)
+            Save.add(activity)
 
+
+    @staticmethod
+    def _activate_insertion(activity):
+        model = Save.model_from_table_name(activity.table_name)
+        entity = model(**relationships_in(activity.patch, model))
+        entity.activityIdentifier = activity.entityIdentifier
+        entity.dateCreated = activity.dateCreated
+        with versioning_manager.disable(Activate.get_db().session):
+            Save.add(entity)
+            Activate.get_db().session.flush()
+        print(activity.changed_data, foreigns_in(activity.changed_data, entity.__class__))
+        activity.changed_data = {
+            **foreigns_in(activity.changed_data, entity.__class__),
+            entity.__class__.id.key: entity.id
+        }
+        activity.verb = 'insert'
+        Save.add(activity)
+
+    """
     @staticmethod
     def _activate_insertion(activity):
         model = Save.model_from_table_name(activity.table_name)
@@ -79,11 +94,12 @@ def _activate_insertion(activity):
         insert_activity.dateCreated = activity.dateCreated
         Save.add(insert_activity)
         # merge insert_activity into activity that helped for its creation
-        activity.id = insert_activity.id
-        activity.changed_data = {**insert_activity.changed_data}
-        if insert_activity.transaction:
-            activity.transaction = Activate.get_activity().transaction.mapper.class_()
-            activity.transaction.actor  = insert_activity.transaction.actor
+        #activity.id = insert_activity.id
+        #activity.changed_data = {**insert_activity.changed_data}
+        #if insert_activity.transaction:
+        #    activity.transaction = Activate.get_activity().transaction.mapper.class_()
+        #    activity.transaction.actor  = insert_activity.transaction.actor
+    """
 
     @staticmethod
     def _activate_updates(activities,

sqlalchemy_api_handler/mixins/has_activities_mixin.py

@@ -34,8 +34,8 @@ def _get_activity_join_by_entity_id_filter(self):
             errors.add_error('_get_activity_join_by_entity_id_filter',
                              f'tried to filter with a None id value for a {self.__class__.__name__} entity')
             raise errors
-        return ((Activity.old_data[id_key].astext.cast(BigInteger) == id_value) | \
-                (Activity.changed_data[id_key].astext.cast(BigInteger) == id_value))
+        return ((Activity.old_data[id_key].cast(BigInteger) == id_value) | \
+                (Activity.changed_data[id_key].cast(BigInteger) == id_value))
 
     def join_self_activities(self):
         Activity = Activate.get_activity()

sqlalchemy_api_handler/serialization/__init__.py

@@ -1,3 +1,2 @@
 from sqlalchemy_api_handler.serialization.as_dict import *
 from sqlalchemy_api_handler.serialization.get_result import *
-from sqlalchemy_api_handler.serialization.serialize import *

sqlalchemy_api_handler/serialization/as_dict.py

@@ -3,9 +3,8 @@
 from typing import Callable, Iterable, Set, List
 
 from sqlalchemy.orm.collections import InstrumentedList
-
 from sqlalchemy_api_handler.api_handler import ApiHandler
-from sqlalchemy_api_handler.serialization.serialize import serialize
+from sqlalchemy_api_handler.utils.serialize import create_serialize
 from sqlalchemy_api_handler.utils.asynchronous import async_map as default_async_map
 
 
@@ -17,6 +16,9 @@ def exclusive_includes_from(entity, includes):
     return exclusive_includes
 
 
+serialize = create_serialize()
+
+
 @singledispatch
 def as_dict(value,
             column=None,

sqlalchemy_api_handler/utils/datum.py

@@ -3,6 +3,7 @@
 from sqlalchemy_api_handler.utils.dehumanize import dehumanize
 from sqlalchemy_api_handler.utils.humanize import humanize
 from sqlalchemy_api_handler.utils.is_id_column import is_id_column
+from sqlalchemy_api_handler.utils.serialize import create_serialize
 
 
 def merge(source, destination):
@@ -114,13 +115,28 @@ def datum_with_relationships_from(datum, model):
     for (key, relationship) in model.__mapper__.relationships.items():
         activity_identifier_key = '{}ActivityIdentifier'.format(key)
         if activity_identifier_key in relationed_datum:
-            model = relationship.mapper.class_
-            instance = model.query.filter_by(activityIdentifier=relationed_datum[activity_identifier_key]) \
-                                  .one()
-            relationed_datum[key] = instance
+            relationed_model = relationship.mapper.class_
+            relationed_instance = relationed_model.query \
+                                       .filter_by(activityIdentifier=relationed_datum[activity_identifier_key]) \
+                                       .one()
+            relationed_datum[key] = relationed_instance
     return relationed_datum
 
 
+def foreigns_in(datum, model):
+    foreign_datum = {**datum}
+    for (key, relationship) in model.__mapper__.relationships.items():
+        activity_identifier_key = '{}ActivityIdentifier'.format(key)
+        if activity_identifier_key in foreign_datum:
+            foreign_model = relationship.mapper.class_
+            print(foreign_datum[activity_identifier_key], relationship)
+            foreign_instance = foreign_model.query \
+                                            .filter_by(activityIdentifier=foreign_datum[activity_identifier_key]) \
+                                            .one()
+            foreign_datum[relationship.foreign_keys[0]] = foreign_instance.id
+    return foreign_datum
+
+
 def old_data_from(entity, activity):
     if activity.verb == 'insert':
         return activity.changed_data
@@ -141,3 +157,13 @@ def merged_datum_from_activities(entity,
         merged_datum = { **merged_datum,
                          **datum_with_relationships_from(activity.patch, entity.__class__) }
     return merged_datum
+
+
+serialize = create_serialize(with_humanize=False)
+
+def serialized_datum_from(entity):
+    serialized_datum = {}
+    for (key, value) in vars(entity).items():
+        if key != '_sa_instance_state':
+            serialized_datum[key] = serialize(value)
+    return serialized_datum

sqlalchemy_api_handler/utils/serialize.py

@@ -0,0 +1,56 @@
+import enum
+from uuid import UUID
+from datetime import datetime
+from functools import singledispatch
+import sqlalchemy
+from psycopg2._range import DateTimeRange
+
+from sqlalchemy_api_handler.utils.date import DateTimes, format_into_ISO_8601
+from sqlalchemy_api_handler.utils.humanize import humanize
+from sqlalchemy_api_handler.utils.is_id_column import is_id_column
+
+
+def create_serialize(with_humanize=True):
+    @singledispatch
+    def serialize(value, column=None):
+        return value
+
+    @serialize.register(int)
+    def _(value, column=None):
+        if with_humanize and is_id_column(column):
+            return humanize(value)
+        return value
+
+    @serialize.register(sqlalchemy.Enum)
+    def _(value, column=None):
+        return value.name
+
+    @serialize.register(enum.Enum)
+    def _(value, column=None):
+        return value.value
+
+    @serialize.register(datetime)
+    def _(value, column=None):
+        return format_into_ISO_8601(value)
+
+    @serialize.register(DateTimeRange)
+    def _(value, column=None):
+        return {'start': value.lower, 'end': value.upper}
+
+    @serialize.register(bytes)
+    def _(value, column=None):
+        return list(value)
+
+    @serialize.register(list)
+    def _(value, column=None):
+        return list(map(serialize, value))
+
+    @serialize.register(DateTimes)
+    def _(value, column=None):
+        return [format_into_ISO_8601(v) for v in value.datetimes]
+
+    @serialize.register(UUID)
+    def _(value, column=None):
+        return str(value)
+
+    return serialize

tests/bases/activate_test.py

@@ -1,3 +1,5 @@
+# pylint: disable=W0613
+
 from datetime import datetime, timedelta
 from uuid import uuid4
 import pytest