GeneralManager 0.6.1__tar.gz → 0.6.2__tar.gz

{generalmanager-0.6.1 → generalmanager-0.6.2}/GeneralManager.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GeneralManager
-Version: 0.6.1
+Version: 0.6.2
 Summary: Modular Django-based data management framework with ORM, GraphQL, fine-grained permissions, rule validation, calculations and caching.
 Author-email: Tim Kleindick <tkleindick@yahoo.de>
 License-Expression: MIT

{generalmanager-0.6.1 → generalmanager-0.6.2}/GeneralManager.egg-info/SOURCES.txt

@@ -65,6 +65,7 @@ tests/test_calculationBucket.py
 tests/test_calculationInterface.py
 tests/test_databaseBasedInterface.py
 tests/test_databaseBucket.py
+tests/test_databaseInterface.py
 tests/test_dependencyIndex.py
 tests/test_factories.py
 tests/test_factoryMethods.py

{generalmanager-0.6.1 → generalmanager-0.6.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GeneralManager
-Version: 0.6.1
+Version: 0.6.2
 Summary: Modular Django-based data management framework with ORM, GraphQL, fine-grained permissions, rule validation, calculations and caching.
 Author-email: Tim Kleindick <tkleindick@yahoo.de>
 License-Expression: MIT

{generalmanager-0.6.1 → generalmanager-0.6.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "GeneralManager"
-version = "0.6.1"
+version = "0.6.2"
 description = "Modular Django-based data management framework with ORM, GraphQL, fine-grained permissions, rule validation, calculations and caching."
 readme = "README.md"
 authors = [{ name = "Tim Kleindick", email = "tkleindick@yahoo.de" }]

{generalmanager-0.6.1 → generalmanager-0.6.2}/src/general_manager/interface/databaseInterface.py

@@ -18,36 +18,24 @@ class DatabaseInterface(DBBasedInterface):
     def create(
         cls, creator_id: int, history_comment: str | None = None, **kwargs: Any
     ) -> int:
-        from general_manager.manager.generalManager import GeneralManager
 
-        cls.__checkForInvalidKwargs(cls._model, kwargs=kwargs)
-        kwargs, many_to_many_kwargs = cls.__sortKwargs(cls._model, kwargs)
-        instance = cls._model()
-        for key, value in kwargs.items():
-            if isinstance(value, GeneralManager):
-                value = value.identification["id"]
-                key = f"{key}_id"
-            setattr(instance, key, value)
-        for key, value in many_to_many_kwargs.items():
-            getattr(instance, key).set(value)
-        return cls.__save_with_history(instance, creator_id, history_comment)
+        cls._checkForInvalidKwargs(cls._model, kwargs=kwargs)
+        kwargs, many_to_many_kwargs = cls._sortKwargs(cls._model, kwargs)
+        instance = cls.__setAttrForWrite(cls._model(), kwargs)
+        pk = cls._save_with_history(instance, creator_id, history_comment)
+        cls.__setManyToManyAttributes(instance, many_to_many_kwargs)
+        return pk
 
     def update(
         self, creator_id: int, history_comment: str | None = None, **kwargs: Any
     ) -> int:
-        from general_manager.manager.generalManager import GeneralManager
 
-        self.__checkForInvalidKwargs(self._model, kwargs=kwargs)
-        kwargs, many_to_many_kwargs = self.__sortKwargs(self._model, kwargs)
-        instance = self._model.objects.get(pk=self.pk)
-        for key, value in kwargs.items():
-            if isinstance(value, GeneralManager):
-                value = value.identification["id"]
-                key = f"{key}_id"
-            setattr(instance, key, value)
-        for key, value in many_to_many_kwargs.items():
-            getattr(instance, key).set(value)
-        return self.__save_with_history(instance, creator_id, history_comment)
+        self._checkForInvalidKwargs(self._model, kwargs=kwargs)
+        kwargs, many_to_many_kwargs = self._sortKwargs(self._model, kwargs)
+        instance = self.__setAttrForWrite(self._model.objects.get(pk=self.pk), kwargs)
+        pk = self._save_with_history(instance, creator_id, history_comment)
+        self.__setManyToManyAttributes(instance, many_to_many_kwargs)
+        return pk
 
     def deactivate(self, creator_id: int, history_comment: str | None = None) -> int:
         instance = self._model.objects.get(pk=self.pk)
@@ -56,32 +44,68 @@ class DatabaseInterface(DBBasedInterface):
             history_comment = f"{history_comment} (deactivated)"
         else:
             history_comment = "Deactivated"
-        return self.__save_with_history(instance, creator_id, history_comment)
+        return self._save_with_history(instance, creator_id, history_comment)
 
     @staticmethod
-    def __checkForInvalidKwargs(model: Type[models.Model], kwargs: dict[Any, Any]):
+    def __setManyToManyAttributes(
+        instance: GeneralManagerModel, many_to_many_kwargs: dict[str, list[Any]]
+    ) -> GeneralManagerModel:
+        """
+        Sets many-to-many attributes for the given instance based on the provided kwargs.
+
+        Args:
+            instance: The model instance to update.
+            many_to_many_kwargs: A dictionary containing many-to-many field names and their corresponding values.
+
+        Returns:
+            The updated model instance.
+        """
+        for key, value in many_to_many_kwargs.items():
+            if not value:
+                continue
+            field_name = key.split("_id_list")[0]
+            getattr(instance, field_name).set(value)
+
+        return instance
+
+    @staticmethod
+    def __setAttrForWrite(
+        instance: GeneralManagerModel,
+        kwargs: dict[str, Any],
+    ) -> GeneralManagerModel:
+        from general_manager.manager.generalManager import GeneralManager
+
+        for key, value in kwargs.items():
+            if isinstance(value, GeneralManager):
+                value = value.identification["id"]
+                key = f"{key}_id"
+            setattr(instance, key, value)
+        return instance
+
+    @staticmethod
+    def _checkForInvalidKwargs(model: Type[models.Model], kwargs: dict[str, Any]):
         attributes = vars(model)
-        fields = model._meta.get_fields()
+        field_names = {f.name for f in model._meta.get_fields()}
         for key in kwargs:
-            if key not in attributes and key not in fields:
+            temp_key = key.split("_id_list")[0]  # Remove '_id_list' suffix
+            if temp_key not in attributes and temp_key not in field_names:
                 raise ValueError(f"{key} does not exsist in {model.__name__}")
 
     @staticmethod
-    def __sortKwargs(
+    def _sortKwargs(
         model: Type[models.Model], kwargs: dict[Any, Any]
     ) -> tuple[dict[str, Any], dict[str, list[Any]]]:
-        many_to_many_fields = model._meta.many_to_many
+        many_to_many_fields = [field.name for field in model._meta.many_to_many]
         many_to_many_kwargs: dict[Any, Any] = {}
-        for key, value in kwargs.items():
+        for key, value in list(kwargs.items()):
             many_to_many_key = key.split("_id_list")[0]
             if many_to_many_key in many_to_many_fields:
-                many_to_many_kwargs[key] = value
-                kwargs.pop(key)
+                many_to_many_kwargs[key] = kwargs.pop(key)
         return kwargs, many_to_many_kwargs
 
     @classmethod
     @transaction.atomic
-    def __save_with_history(
+    def _save_with_history(
         cls, instance: GeneralManagerModel, creator_id: int, history_comment: str | None
     ) -> int:
         """

generalmanager-0.6.2/tests/test_databaseInterface.py

@@ -0,0 +1,181 @@
+# type: ignore
+from typing import Any
+from unittest.mock import patch
+from django.contrib.auth.models import User
+from django.db import models, connection
+from django.test import TransactionTestCase
+
+from general_manager.interface.databaseInterface import DatabaseInterface
+from general_manager.manager.generalManager import GeneralManager
+from general_manager.manager.input import Input
+
+
+class SafeDict(dict):
+    def items(self):
+        return list(super().items())
+
+
+class DatabaseInterfaceTestCase(TransactionTestCase):
+    @classmethod
+    def setUpClass(cls):
+        super().setUpClass()
+
+        class UserInterface(DatabaseInterface):
+            _model = User
+            _parent_class = None
+            input_fields = {"id": Input(int)}
+
+            @classmethod
+            def handleInterface(cls):
+                def pre(name, attrs, interface):
+                    return attrs, cls, cls._model
+
+                def post(new_cls, interface_cls, model):
+                    new_cls.Interface = interface_cls
+                    interface_cls._parent_class = new_cls
+
+                return pre, post
+
+        class UserManager(GeneralManager):
+            Interface = UserInterface
+
+        cls.UserManager = UserManager
+        UserInterface._parent_class = UserManager
+
+        class BookModel(models.Model):
+            title = models.CharField(max_length=50)
+            author = models.ForeignKey(User, on_delete=models.CASCADE)
+            readers = models.ManyToManyField(User, blank=True)
+            is_active = models.BooleanField(default=True)
+            changed_by = models.ForeignKey(User, on_delete=models.PROTECT)
+
+            class Meta:
+                app_label = "general_manager"
+
+        cls.BookModel = BookModel
+
+        class BookInterface(DatabaseInterface):
+            _model = BookModel
+            _parent_class = None
+            input_fields = {"id": Input(int)}
+
+            @classmethod
+            def handleInterface(cls):
+                def pre(name, attrs, interface):
+                    return attrs, cls, cls._model
+
+                def post(new_cls, interface_cls, model):
+                    new_cls.Interface = interface_cls
+                    interface_cls._parent_class = new_cls
+
+                return pre, post
+
+        cls.BookInterface = BookInterface
+
+        class BookManager(GeneralManager):
+            Interface = BookInterface
+
+        cls.BookManager = BookManager
+        BookInterface._parent_class = BookManager
+
+        with connection.schema_editor() as schema:
+            schema.create_model(BookModel)
+
+    @classmethod
+    def tearDownClass(cls):
+        with connection.schema_editor() as schema:
+            schema.delete_model(cls.BookModel)
+        super().tearDownClass()
+
+    def setUp(self):
+        self.user = User.objects.create(username="tester")
+        self.book = self.BookModel.objects.create(
+            title="Initial",
+            author=self.user,
+            changed_by=self.user,
+        )
+        self.book.readers.add(self.user)
+        self.user_manager = self.UserManager(self.user.pk)
+
+    def test_check_for_invalid_kwargs(self):
+        self.BookInterface._checkForInvalidKwargs(
+            self.BookModel, {"title": "a", "readers_id_list": []}
+        )
+        with self.assertRaises(ValueError):
+            self.BookInterface._checkForInvalidKwargs(self.BookModel, {"wrong": 1})
+
+    def test_sort_kwargs(self):
+        kwargs = SafeDict({"title": "b", "readers_id_list": [1]})
+        normal, m2m = self.BookInterface._sortKwargs(self.BookModel, kwargs)
+        self.assertEqual(normal, {"title": "b"})
+        self.assertEqual(m2m, {"readers_id_list": [1]})
+
+    def test_save_with_history(self):
+        class Dummy:
+            def __init__(self):
+                self.pk = 5
+                self.saved = False
+                self.cleaned = False
+
+            def full_clean(self):
+                self.cleaned = True
+
+            def save(self):
+                self.saved = True
+
+        inst = Dummy()
+        with patch(
+            "general_manager.interface.databaseInterface.update_change_reason"
+        ) as mock_update:
+            pk = self.BookInterface._save_with_history(inst, 7, "comment")
+        self.assertEqual(pk, 5)
+        self.assertEqual(inst.changed_by_id, 7)
+        self.assertTrue(inst.cleaned)
+        self.assertTrue(inst.saved)
+        mock_update.assert_called_once_with(inst, "comment")
+
+    def test_create_update_and_deactivate(self):
+        captured: dict[str, Any] = {}
+
+        def fake_save(instance, creator_id, comment):
+            captured["instance"] = instance
+            captured["creator"] = creator_id
+            captured["comment"] = comment
+            return getattr(instance, "pk", 99) or 99
+
+        with patch.object(
+            self.BookInterface,
+            "_save_with_history",
+            side_effect=fake_save,
+        ):
+            pk = self.BookInterface.create(
+                creator_id=self.user.pk,
+                history_comment="new",
+                title="Created",
+                author=self.user_manager,
+            )
+            self.assertEqual(pk, 99)
+            self.assertEqual(captured["instance"].title, "Created")
+            self.assertEqual(captured["comment"], "new")
+
+            mgr = self.BookManager(self.book.pk)
+            pk2 = mgr._interface.update(
+                creator_id=self.user.pk,
+                history_comment="up",
+                title="Updated",
+            )
+
+            self.assertEqual(pk2, self.book.pk)
+            self.assertEqual(captured["instance"].title, "Updated")
+            self.assertEqual(captured["comment"], "up")
+
+            pk2 = mgr._interface.update(
+                creator_id=self.user.pk,
+                readers_id_list=[self.user.pk],
+            )
+            pk3 = mgr._interface.deactivate(
+                creator_id=self.user.pk, history_comment="reason"
+            )
+            self.assertEqual(pk3, self.book.pk)
+            self.assertFalse(captured["instance"].is_active)
+            self.assertEqual(captured["comment"], "reason (deactivated)")