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

Feat/more configuration

Author: freemindcore

.bumpversion.cfg

@@ -1,5 +1,5 @@
 [bumpversion]
-current_version = 0.1.26
+current_version = 0.1.29
 commit = True
 tag = True
 parse = (?P<major>\d+)\.(?P<feat>\d+)\.(?P<patch>\d+)

easy/__init__.py

@@ -1,6 +1,6 @@
 """Django Easy API - Easy and Fast Django REST framework based on Django-ninja-extra"""
 
-__version__ = "0.1.26"
+__version__ = "0.1.29"
 
 from easy.main import EasyAPI
 

easy/controller/admin_auto_api.py

@@ -6,6 +6,13 @@
 from ninja_extra.permissions import BasePermission
 
 from easy.controller.base import CrudAPIController
+from easy.controller.meta_conf import (
+    GENERATE_CRUD_ATTR_DEFAULT,
+    MODEL_FIELDS_ATTR_DEFAULT,
+    MODEL_JOIN_ATTR_DEFAULT,
+    MODEL_RECURSIVE_ATTR_DEFAULT,
+    SENSITIVE_FIELDS_ATTR_DEFAULT,
+)
 from easy.permissions import AdminSitePermission, BaseApiPermission
 
 logger = logging.getLogger(__name__)
@@ -24,11 +31,11 @@ def create_api_controller(
         (object,),
         {
             "model": model,
-            "generate_crud": True,
-            "model_fields": "__all__",
-            "model_recursive": False,
-            "model_join": True,
-            "sensitive_fields": ["password"],
+            "generate_crud": GENERATE_CRUD_ATTR_DEFAULT,
+            "model_fields": MODEL_FIELDS_ATTR_DEFAULT,
+            "model_recursive": MODEL_RECURSIVE_ATTR_DEFAULT,
+            "model_join": MODEL_JOIN_ATTR_DEFAULT,
+            "sensitive_fields": SENSITIVE_FIELDS_ATTR_DEFAULT,
         },
     )
 

easy/controller/meta.py

@@ -4,14 +4,14 @@
 import uuid
 from abc import ABCMeta
 from collections import ChainMap
-from typing import Any, List, Match, Optional, Tuple, Type, Union
+from typing import Any, Match, Optional, Tuple, Type
 
-from django.db import models
 from django.http import HttpRequest
 from ninja import ModelSchema
 from ninja_extra import ControllerBase, http_delete, http_get, http_patch, http_put
 from ninja_extra.pagination import paginate
 
+from easy.controller.meta_conf import MODEL_FIELDS_ATTR_DEFAULT, ModelOptions
 from easy.domain.orm import CrudModel
 from easy.response import BaseApiResponse
 from easy.services import BaseService
@@ -20,91 +20,25 @@
 logger = logging.getLogger(__name__)
 
 
-class APIControllerBase(ControllerBase):
-    """Reserved for customization"""
-
-    ...
-
-
 class CrudAPI(CrudModel):
     # Never add type note to service, it will cause injection error
     def __init__(self, service=None):  # type: ignore
         # Critical to set __Meta
         self.service = service
         if self.service:
             self.model = self.service.model
-        _meta = getattr(self, "Meta", None)
-        if self.model and _meta:
-            setattr(
-                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),
-                    "model_join": getattr(_meta, "model_join", True),
-                    "sensitive_fields": getattr(
-                        _meta, "model_sensitive_fields", ["password", "token"]
-                    ),
-                },
-            )
+
+        _model_opts: ModelOptions = ModelOptions.get_model_options(self.__class__)
+        if self.model and _model_opts:
+            ModelOptions.set_model_meta(self.model, _model_opts)
+
         if not service:
             self.service = BaseService(model=self.model)
         super().__init__(model=self.model)
 
-    # Define Controller APIs for auto generation
-    async def get_obj(self, request: HttpRequest, id: int) -> Any:
-        """
-        GET /{id}
-        Retrieve a single Object
-        """
-        try:
-            qs = await self.service.get_obj(id)
-        except Exception as e:  # pragma: no cover
-            logger.error(f"Get Error - {e}", exc_info=True)
-            return BaseApiResponse(str(e), message="Get Failed", errno=500)
-        if qs:
-            return qs
-        else:
-            return BaseApiResponse(message="Not Found", errno=404)
-
-    async def del_obj(self, request: HttpRequest, id: int) -> Any:
-        """
-        DELETE /{id}
-        Delete a single Object
-        """
-        if await self.service.del_obj(id):
-            return BaseApiResponse("Deleted.", errno=204)
-        else:
-            return BaseApiResponse("Not Found.", errno=404)
-
-    @paginate
-    async def get_objs(self, request: HttpRequest, filters: str = None) -> Any:
-        """
-        GET /?maximum={int}&filters={filters_dict}
-        Retrieve multiple Object (optional: maximum # and filters)
-        """
-        if filters:
-            return await self.service.get_objs(**json.loads(filters))
-        return await self.service.get_objs()
-
 
 class CrudApiMetaclass(ABCMeta):
     def __new__(mcs, name: str, bases: Tuple[Type[Any], ...], attrs: dict) -> Any:
-        # Get configs from Meta
-        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
-        opts_join: Optional[bool] = temp_opts.model_join
-        opts_sensitive_fields: Optional[
-            Union[str, List[str]]
-        ] = temp_opts.sensitive_fields
-
         def is_private_attrs(attr_name: str) -> Optional[Match[str]]:
             return re.match(r"^__[^\d\W]\w*\Z__$", attr_name, re.UNICODE)
 
@@ -117,32 +51,76 @@ def is_private_attrs(attr_name: str) -> Optional[Match[str]]:
         )
         base_cls_attrs: dict = {}
         base_cls_attrs.update(parent_attrs)
-        if opts_generate_crud:
+
+        # Get configs from Meta
+        _temp_cls: Type = super().__new__(mcs, name, (object,), base_cls_attrs)
+        model_opts: ModelOptions = ModelOptions.get_model_options(_temp_cls)
+
+        # Define Controller APIs for auto generation
+        async def get_obj(self, request: HttpRequest, id: int) -> Any:  # type: ignore
+            """
+            GET /{id}
+            Retrieve a single Object
+            """
+            try:
+                qs = await self.service.get_obj(id)
+            except Exception as e:  # pragma: no cover
+                logger.error(f"Get Error - {e}", exc_info=True)
+                return BaseApiResponse(str(e), message="Get Failed", errno=500)
+            if qs:
+                return qs
+            else:
+                return BaseApiResponse(message="Not Found", errno=404)
+
+        async def del_obj(self, request: HttpRequest, id: int) -> Any:  # type: ignore
+            """
+            DELETE /{id}
+            Delete a single Object
+            """
+            if await self.service.del_obj(id):
+                return BaseApiResponse("Deleted.", errno=204)
+            else:
+                return BaseApiResponse("Not Found.", errno=404)
+
+        @paginate
+        async def get_objs(self, request: HttpRequest, filters: str = None) -> Any:  # type: ignore
+            """
+            GET /?maximum={int}&filters={filters_dict}
+            Retrieve multiple Object (optional: maximum # and filters)
+            """
+            if filters:
+                return await self.service.get_objs(**json.loads(filters))
+            return await self.service.get_objs()
+
+        if model_opts.generate_crud and model_opts.model:
             base_cls_attrs.update(
                 {
                     "get_obj": http_get("/{id}", summary="Get a single object")(
-                        copy_func(CrudAPI.get_obj)  # type: ignore
+                        copy_func(get_obj)  # type: ignore
                     ),
                     "del_obj": http_delete("/{id}", summary="Delete a single object")(
-                        copy_func(CrudAPI.del_obj)  # type: ignore
+                        copy_func(del_obj)  # type: ignore
                     ),
                     "get_objs": http_get("/", summary="Get multiple objects")(
-                        copy_func(CrudAPI.get_objs)  # type: ignore
+                        copy_func(get_objs)  # type: ignore
                     ),
                 }
             )
-        if opts_generate_crud and opts_model:
 
             class DataSchema(ModelSchema):
                 class Config:
-                    model = opts_model
-                    if opts_fields_exclude:
-                        model_exclude = opts_fields_exclude
+                    model = model_opts.model
+                    if model_opts.model_exclude:
+                        model_exclude = model_opts.model_exclude
                     else:
-                        if opts_fields == "__all__":
-                            model_fields = "__all__"
+                        if model_opts.model_fields == MODEL_FIELDS_ATTR_DEFAULT:
+                            model_fields = MODEL_FIELDS_ATTR_DEFAULT
                         else:
-                            model_fields = opts_fields if opts_fields else "__all__"
+                            model_fields = (
+                                model_opts.model_fields  # type: ignore
+                                if model_opts.model_fields
+                                else MODEL_FIELDS_ATTR_DEFAULT
+                            )
 
             async def add_obj(  # type: ignore
                 self, request: HttpRequest, data: DataSchema
@@ -170,19 +148,16 @@ async def patch_obj(  # type: ignore
                     return BaseApiResponse("Update Failed", errno=400)
 
             DataSchema.__name__ = (
-                f"{opts_model.__name__}__AutoSchema({str(uuid.uuid4())[:4]})"
+                f"{model_opts.model.__name__}__AutoSchema({str(uuid.uuid4())[:4]})"
             )
 
-            setattr(CrudAPI, "patch_obj", patch_obj)
-            setattr(CrudAPI, "add_obj", add_obj)
-
             base_cls_attrs.update(
                 {
                     "patch_obj": http_patch("/{id}", summary="Patch a single object")(
-                        copy_func(CrudAPI.patch_obj)  # type: ignore
+                        copy_func(patch_obj)  # type: ignore
                     ),
                     "add_obj": http_put("/", summary="Create")(
-                        copy_func(CrudAPI.add_obj)  # type: ignore
+                        copy_func(add_obj)  # type: ignore
                     ),
                 }
             )
@@ -191,49 +166,14 @@ async def patch_obj(  # type: ignore
             mcs,
             name,
             (
-                APIControllerBase,
+                ControllerBase,
                 CrudAPI,
             ),
             base_cls_attrs,
         )
 
-        if opts_model:
-            setattr(
-                opts_model,
-                "__Meta",
-                {
-                    "generate_crud": opts_generate_crud,
-                    "model_exclude": opts_fields_exclude,
-                    "model_fields": opts_fields,
-                    "model_recursive": opts_recursive,
-                    "model_join": opts_join,
-                    "sensitive_fields": opts_sensitive_fields,
-                },
-            )
-            setattr(new_cls, "model", opts_model)
+        if model_opts.model:
+            ModelOptions.set_model_meta(model_opts.model, model_opts)
+            setattr(new_cls, "model", model_opts.model)
 
         return new_cls
-
-
-class ModelOptions:
-    def __init__(self, options: object = None):
-        """
-        Configuration reader
-        """
-        self.model: Optional[Type[models.Model]] = getattr(options, "model", 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
-        )
-        self.sensitive_fields: Optional[Union[str, List[str]]] = getattr(
-            options, "sensitive_fields", ["token", "password"]
-        )