Merge pull request #8 from freemindcore/feat/more-configuration

Feat/more configuration

Author: freemindcore

easy/controller/admin_auto_api.py

@@ -24,6 +24,7 @@ def create_api_controller(
         (object,),
         {
             "model": model,
+            "generate_crud": True,
             "model_fields": "__all__",
             "model_recursive": False,
             "model_join": True,

easy/controller/base.py

@@ -24,11 +24,22 @@ class CrudAPIController(metaclass=CrudApiMetaclass):
 
     Configuration:
         model:              django model
+        generate_crud:      whether to create crud api, default to True
+        model_exclude:      fields to be excluded in Schema, it will ignore model_fields
         model_fields:       fields to be included in Schema, default to "__all__"
-        model_exclude:      fields to be excluded in Schema
         model_join:         retrieve all m2m fields, default to True
         model_recursive:    recursively retrieve FK/OneToOne models, default to False
         sensitive_fields:   fields to be ignored
+
+    Example:
+        class Meta
+            model = Event
+            generate_crud = False
+            model_exclude = ["field1", "field2"]
+            model_fields = ["field1", "field2"]
+            model_join = False
+            model_recursive = True
+            sensitive_fields = ["token", "money"]
     """
 
     ...

easy/controller/meta.py

@@ -39,6 +39,7 @@ def __init__(self, service=None):  # type: ignore
                 self.model,
                 "__Meta",
                 {
+                    "generate_crud": getattr(_meta, "generate_crud", True),
                     "model_exclude": getattr(_meta, "model_exclude", None),
                     "model_fields": getattr(_meta, "model_fields", "__all__"),
                     "model_recursive": getattr(_meta, "model_recursive", False),
@@ -95,6 +96,7 @@ def __new__(mcs, name: str, bases: Tuple[Type[Any], ...], attrs: dict) -> Any:
         temp_cls: Type = super().__new__(mcs, name, (object,), attrs)
         temp_opts: ModelOptions = ModelOptions(getattr(temp_cls, "Meta", None))
         opts_model: Optional[Type[models.Model]] = temp_opts.model
+        opts_generate_crud: Optional[bool] = temp_opts.generate_crud
         opts_fields_exclude: Optional[str] = temp_opts.model_exclude
         opts_fields: Optional[str] = temp_opts.model_fields
         opts_recursive: Optional[bool] = temp_opts.model_recursive
@@ -115,8 +117,21 @@ def is_private_attrs(attr_name: str) -> Optional[Match[str]]:
         )
         base_cls_attrs: dict = {}
         base_cls_attrs.update(parent_attrs)
-
-        if opts_model:
+        if opts_generate_crud:
+            base_cls_attrs.update(
+                {
+                    "get_obj": http_get("/{id}", summary="Get a single object")(
+                        copy_func(CrudAPI.get_obj)  # type: ignore
+                    ),
+                    "del_obj": http_delete("/{id}", summary="Delete a single object")(
+                        copy_func(CrudAPI.del_obj)  # type: ignore
+                    ),
+                    "get_objs": http_get("/", summary="Get multiple objects")(
+                        copy_func(CrudAPI.get_objs)  # type: ignore
+                    ),
+                }
+            )
+        if opts_generate_crud and opts_model:
 
             class DataSchema(ModelSchema):
                 class Config:
@@ -163,31 +178,15 @@ async def patch_obj(  # type: ignore
 
             base_cls_attrs.update(
                 {
-                    "patch_obj_api": http_patch(
-                        "/{id}", summary="Patch a single object"
-                    )(
+                    "patch_obj": http_patch("/{id}", summary="Patch a single object")(
                         copy_func(CrudAPI.patch_obj)  # type: ignore
                     ),
-                    "add_obj_api": http_put("/", summary="Create")(
+                    "add_obj": http_put("/", summary="Create")(
                         copy_func(CrudAPI.add_obj)  # type: ignore
                     ),
                 }
             )
 
-        base_cls_attrs.update(
-            {
-                "get_obj_api": http_get("/{id}", summary="Get a single object")(
-                    copy_func(CrudAPI.get_obj)  # type: ignore
-                ),
-                "del_obj_api": http_delete("/{id}", summary="Delete a single object")(
-                    copy_func(CrudAPI.del_obj)  # type: ignore
-                ),
-                "get_objs_api": http_get("/", summary="Get multiple objects")(
-                    copy_func(CrudAPI.get_objs)  # type: ignore
-                ),
-            }
-        )
-
         new_cls: Type = super().__new__(
             mcs,
             name,
@@ -203,6 +202,7 @@ async def patch_obj(  # type: ignore
                 opts_model,
                 "__Meta",
                 {
+                    "generate_crud": opts_generate_crud,
                     "model_exclude": opts_fields_exclude,
                     "model_fields": opts_fields,
                     "model_recursive": opts_recursive,
@@ -218,19 +218,18 @@ async def patch_obj(  # type: ignore
 class ModelOptions:
     def __init__(self, options: object = None):
         """
-        Configuration:
-            model:              django model
-            model_fields:       fields to be included in Schema, default to "__all__"
-            model_exclude:      fields to be excluded in Schema
-            model_join:         retrieve all m2m fields, default to True
-            model_recursive:    recursively retrieve FK/OneToOne models, default to False
-            sensitive_fields:   fields to be ignored
+        Configuration reader
         """
         self.model: Optional[Type[models.Model]] = getattr(options, "model", None)
-        self.model_fields: Optional[Union[str]] = getattr(options, "model_fields", None)
+        self.generate_crud: Optional[Union[bool]] = getattr(
+            options, "generate_crud", True
+        )
         self.model_exclude: Optional[Union[str]] = getattr(
             options, "model_exclude", None
         )
+        self.model_fields: Optional[Union[str]] = getattr(
+            options, "model_fields", "__all__"
+        )
         self.model_join: Optional[Union[bool]] = getattr(options, "model_join", True)
         self.model_recursive: Optional[Union[bool]] = getattr(
             options, "model_recursive", False

easy/domain/serializers.py

@@ -41,14 +41,19 @@ def serialize_model_instance(
         """Serializes Django model instance to dictionary"""
         out = {}
         for field in obj._meta.get_fields():
-            if self.is_one_relationship(field):
-                out.update(self.serialize_foreign_key(obj, field, referrers + (obj,)))
+            if self.show_field(obj, field.name):
+                if self.is_one_relationship(field):
+                    out.update(
+                        self.serialize_foreign_key(obj, field, referrers + (obj,))
+                    )
 
-            elif self.is_many_relationship(field):
-                out.update(self.serialize_many_relationship(obj, referrers + (obj,)))
+                elif self.is_many_relationship(field):
+                    out.update(
+                        self.serialize_many_relationship(obj, referrers + (obj,))
+                    )
 
-            else:
-                out.update(self.serialize_value_field(obj, field))
+                else:
+                    out.update(self.serialize_value_field(obj, field))
         return out
 
     def serialize_queryset(
@@ -73,9 +78,8 @@ def serialize_foreign_key(
         except Exception as exc:  # pragma: no cover
             logger.error(f"serialize_foreign_key error - {obj}", exc_info=exc)
             return {field.name: None}
-        if hasattr(obj, "__Meta") and getattr(obj, "__Meta").get(
-            "model_recursive", False
-        ):
+
+        if self.get_configuration(obj, "model_recursive", default=False):
             return {
                 field.name: self.serialize_model_instance(related_instance, referrers)
             }
@@ -94,9 +98,7 @@ def serialize_many_relationship(
             for k, v in obj._prefetched_objects_cache.items():  # type: ignore
                 field_name = k if hasattr(obj, k) else k + "_set"
                 if v:
-                    if hasattr(obj, "__Meta") and getattr(obj, "__Meta").get(
-                        "model_join", True
-                    ):
+                    if self.get_configuration(obj, "model_join", default=True):
                         out[field_name] = self.serialize_queryset(v, referrers + (obj,))
                     else:
                         out[field_name] = [o.pk for o in v]
@@ -107,20 +109,59 @@ def serialize_many_relationship(
         return out
 
     @staticmethod
-    def serialize_value_field(obj: models.Model, field: Any) -> Dict[Any, Any]:
+    def get_configuration(obj: models.Model, _name: str, default: Any = None) -> Any:
+        _value = default if default else None
+        if hasattr(obj, "__Meta"):
+            _value = getattr(obj, "__Meta").get(_name, None)
+        return _value
+
+    def get_model_fields_list(self, obj: models.Model) -> Any:
+        model_fields = self.get_configuration(obj, "model_fields")
+        return model_fields
+
+    def get_model_exclude_list(self, obj: models.Model) -> Any:
+        return self.get_configuration(obj, "model_exclude")
+
+    def get_sensitive_list(self, obj: models.Model) -> Any:
+        return self.get_configuration(obj, "sensitive_fields")
+
+    def get_final_excluded_list(self, obj: models.Model) -> Any:
+        total_excluded_list = []
+        sensitive_list: List = ["password", "token"]
+        excluded_list = []
+
+        sensitive_fields = self.get_sensitive_list(obj)
+        if sensitive_fields:
+            sensitive_list.extend(sensitive_fields)
+        sensitive_list = list(set(sensitive_list))
+
+        excluded_fields = self.get_model_exclude_list(obj)
+        if excluded_fields:
+            excluded_list.extend(excluded_fields)
+        excluded_list = list(set(excluded_list))
+
+        total_excluded_list.extend(sensitive_list)
+        total_excluded_list.extend(excluded_list)
+        return list(set(total_excluded_list))
+
+    def show_field(self, obj: models.Model, field_name: str) -> bool:
+        model_exclude_list = self.get_model_exclude_list(obj)
+        if model_exclude_list:
+            if field_name in self.get_final_excluded_list(obj):
+                return False
+        else:
+            if field_name in self.get_final_excluded_list(obj):
+                return False
+            model_fields_list = self.get_model_fields_list(obj)
+            if model_fields_list != "__all__":
+                if field_name not in model_fields_list:
+                    return False
+        return True
+
+    def serialize_value_field(self, obj: models.Model, field: Any) -> Dict[Any, Any]:
         """
         Serializes regular 'jsonable' field (Char, Int, etc.) of Django model instance
         """
-        sensitive_list: List = [
-            "password",
-        ]
-        if hasattr(obj, "__Meta"):
-            sensitive_fields = getattr(obj, "__Meta").get("sensitive_fields", None)
-            if sensitive_fields:
-                sensitive_list.extend(sensitive_fields)
-            sensitive_list = list(set(sensitive_list))
-        if field.name in sensitive_list:
-            return {}
         return {field.name: getattr(obj, field.name)}
 
     def serialize_data(self, data: Any) -> Any:

tests/demo_app/controllers.py

@@ -29,7 +29,6 @@ def __init__(self, service: EventService):
 
     class Meta:
         model = Event
-        model_fields = "__all__"
         model_join = True
 
 
@@ -90,6 +89,10 @@ class AutoGenCrudSomeFieldsAPIController(CrudAPIController):
 
     class Meta:
         model = Client
+        model_fields = [
+            "key",
+            "name",
+        ]
 
 
 @api_controller("unittest")

tests/demo_app/test_async_auto_crud_apis.py

@@ -90,9 +90,6 @@ async def test_crud_default_get_all(self, transactional_db, easy_api_client):
 
         response = await client.get(
             "/",
-            query=dict(
-                maximum=100,
-            ),
         )
         assert response.status_code == 200
 
@@ -179,18 +176,26 @@ async def test_crud_default_create_some_fields(
     ):
         client = easy_api_client(AutoGenCrudSomeFieldsAPIController)
 
+        category = await sync_to_async(Category.objects.create)(
+            title="Category for Unit Testings"
+        )
+
         client_type = await sync_to_async(Client.objects.create)(
             name="Client for Unit Testings",
             key="Type",
-            category=None,
+            category=category,
             password="DUMMY_PASSWORD",
         )
 
         response = await client.get(
             f"/{client_type.id}",
         )
+
         assert response.status_code == 200
         assert response.json()["data"]["key"] == "Type"
+        with pytest.raises(KeyError):
+            print(response.json()["data"]["password"])
+            print(response.json()["data"]["category"])
 
     async def test_crud_default_patch(self, transactional_db, easy_api_client):
         client = easy_api_client(AutoGenCrudAPIController)
@@ -244,7 +249,9 @@ async def test_crud_default_patch(self, transactional_db, easy_api_client):
         )
         assert response.status_code == 200
         data = response.json().get("data")
+        from pprint import pprint
 
+        pprint(vars(response))
         assert len(data["owner"]) == 2
         assert len(data["lead_owner"]) == 0
         assert data["owner"][0]["name"] == "Client E for Unit Testings"