django-ninja-aio-crud 0.2.2__tar.gz → 0.3.0__tar.gz

{django_ninja_aio_crud-0.2.2 → django_ninja_aio_crud-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: django-ninja-aio-crud
-Version: 0.2.2
+Version: 0.3.0
 Summary: Django Ninja AIO CRUD - Rest Framework 
 Author: Giuseppe Casillo
 Requires-Python: >=3.10

{django_ninja_aio_crud-0.2.2 → django_ninja_aio_crud-0.3.0}/ninja_aio/__init__.py

@@ -1,6 +1,6 @@
 """ Django Ninja AIO CRUD - Rest Framework """
 
-__version__ = "0.2.2"
+__version__ = "0.3.0"
 
 from .api import NinjaAIO
 

{django_ninja_aio_crud-0.2.2 → django_ninja_aio_crud-0.3.0}/ninja_aio/models.py

@@ -1,5 +1,5 @@
 import base64
-from typing import Any, Literal
+from typing import Any
 
 from ninja.schema import Schema
 from ninja.orm import create_schema
@@ -14,12 +14,147 @@ from django.db.models.fields.related_descriptors import (
 )
 
 from .exceptions import SerializeError
+from .types import S_TYPES, REL_TYPES, ModelSerializerMeta
 
-S_TYPES = Literal["create", "update"]
-REL_TYPES = Literal["many", "one"]
 
+class ModelUtil:
+    def __init__(self, model: type["ModelSerializer"] | models.Model):
+        self.model = model
 
-class ModelSerializer(models.Model):
+    @property
+    def serializable_fields(self):
+        if isinstance(self.model, ModelSerializerMeta):
+            return self.model.ReadSerializer.fields
+        return [field.name for field in self.model._meta.get_fields()]
+
+    def verbose_name_path_resolver(self) -> str:
+        return "-".join(self.model._meta.verbose_name_plural.split(" "))
+
+    async def get_object(self, request: HttpRequest, pk: int | str):
+        q = {self.model._meta.pk.attname: pk}
+        obj_qs = self.model.objects.select_related()
+        if isinstance(self.model, ModelSerializerMeta):
+            obj_qs = await self.model.queryset_request(request)
+        try:
+            obj = await obj_qs.prefetch_related(*self.get_reverse_relations()).aget(**q)
+        except ObjectDoesNotExist:
+            raise SerializeError({self.model._meta.model_name: "not found"}, 404)
+        return obj
+
+    def get_reverse_relations(self):
+        reverse_rels = []
+        for f in self.serializable_fields:
+            field_obj = getattr(self.model, f)
+            if isinstance(field_obj, ManyToManyDescriptor):
+                reverse_rels.append(f)
+                continue
+            if isinstance(field_obj, ReverseManyToOneDescriptor):
+                reverse_rels.append(field_obj.field._related_name)
+                continue
+            if isinstance(field_obj, ReverseOneToOneDescriptor):
+                reverse_rels.append(field_obj.related.name)
+        return reverse_rels
+
+    async def parse_input_data(self, request: HttpRequest, data: Schema):
+        payload = data.model_dump()
+        customs = {}
+        if isinstance(self.model, ModelSerializerMeta):
+            customs = {k: v for k, v in payload.items() if self.model.is_custom(k)}
+        for k, v in payload.items():
+            if isinstance(self.model, ModelSerializerMeta) and self.model.is_custom(k):
+                continue
+            field_obj = getattr(self.model, k).field
+            if isinstance(field_obj, models.BinaryField):
+                try:
+                    payload |= {k: base64.b64decode(v)}
+                except Exception as exc:
+                    raise SerializeError({k: ". ".join(exc.args)}, 400)
+            if isinstance(field_obj, models.ForeignKey):
+                rel_util = ModelUtil(field_obj.related_model)
+                rel: ModelSerializer = await rel_util.get_object(request, v)
+                payload |= {k: rel}
+        new_payload = {k: v for k, v in payload.items() if k not in customs}
+        return new_payload, customs
+
+    async def parse_output_data(self, request: HttpRequest, data: Schema):
+        olds_k: list[dict] = []
+        payload = data.model_dump()
+        for k, v in payload.items():
+            try:
+                field_obj = getattr(self.model, k).field
+            except AttributeError:
+                field_obj = getattr(self.model, k).related
+            if isinstance(v, dict) and (
+                isinstance(field_obj, models.ForeignKey)
+                or isinstance(field_obj, models.OneToOneField)
+            ):
+                rel_util = ModelUtil(field_obj.related_model)
+                rel: ModelSerializer = await rel_util.get_object(
+                    request, list(v.values())[0]
+                )
+                if isinstance(field_obj, models.ForeignKey):
+                    for rel_k, rel_v in v.items():
+                        field_rel_obj = getattr(rel, rel_k)
+                        if isinstance(field_rel_obj, models.ForeignKey):
+                            olds_k.append({rel_k: rel_v})
+                    for obj in olds_k:
+                        for old_k, old_v in obj.items():
+                            v.pop(old_k)
+                            v |= {f"{old_k}_id": old_v}
+                    olds_k = []
+                payload |= {k: rel}
+        return payload
+
+    async def create_s(self, request: HttpRequest, data: Schema, obj_schema: Schema):
+        try:
+            payload, customs = await self.parse_input_data(request, data)
+            pk = (await self.model.objects.acreate(**payload)).pk
+            obj = await self.get_object(request, pk)
+        except SerializeError as e:
+            return e.status_code, e.error
+        if isinstance(self.model, ModelSerializerMeta):
+            await obj.custom_actions(customs)
+            await obj.post_create()
+        return 201, await self.read_s(request, obj, obj_schema)
+
+    async def read_s(
+        self,
+        request: HttpRequest,
+        obj: type["ModelSerializer"],
+        obj_schema: Schema,
+    ):
+        if obj_schema is None:
+            raise SerializeError({"obj_schema": "must be provided"}, 400)
+        return await self.parse_output_data(request, obj_schema.from_orm(obj))
+
+    async def update_s(
+        self, request: HttpRequest, data: Schema, pk: int | str, obj_schema: Schema
+    ):
+        try:
+            obj = await self.get_object(request, pk)
+        except SerializeError as e:
+            return e.status_code, e.error
+
+        payload, customs = await self.parse_input_data(request, data)
+        for k, v in payload.items():
+            if v is not None:
+                setattr(obj, k, v)
+        if isinstance(self.model, ModelSerializerMeta):
+            await obj.custom_actions(customs)
+        await obj.asave()
+        updated_object = await self.get_object(request, pk)
+        return await self.read_s(request, updated_object, obj_schema)
+
+    async def delete_s(self, request: HttpRequest, pk: int | str):
+        try:
+            obj = await self.get_object(request, pk)
+        except SerializeError as e:
+            return e.status_code, e.error
+        await obj.adelete()
+        return HttpResponse(status=204)
+
+
+class ModelSerializer(models.Model, metaclass=ModelSerializerMeta):
     class Meta:
         abstract = True
 
@@ -85,21 +220,6 @@ class ModelSerializer(models.Model):
         """
         pass
 
-    @classmethod
-    def get_reverse_relations(cls):
-        reverse_rels = []
-        for f in cls.ReadSerializer.fields:
-            field_obj = getattr(cls, f)
-            if isinstance(field_obj, ManyToManyDescriptor):
-                reverse_rels.append(f)
-                continue
-            if isinstance(field_obj, ReverseManyToOneDescriptor):
-                reverse_rels.append(field_obj.field._related_name)
-                continue
-            if isinstance(field_obj, ReverseOneToOneDescriptor):
-                reverse_rels.append(field_obj.related.name)
-        return reverse_rels
-
     @classmethod
     def get_reverse_relation_schema(
         cls, obj: type["ModelSerializer"], rel_type: type[REL_TYPES], field: str

django_ninja_aio_crud-0.3.0/ninja_aio/types.py

@@ -0,0 +1,15 @@
+from typing import Literal
+
+from django.db.models import Model
+
+S_TYPES = Literal["create", "update"]
+REL_TYPES = Literal["many", "one"]
+
+
+class ModelSerializerType(type):
+    def __repr__(self):
+        return self.__name__
+
+
+class ModelSerializerMeta(ModelSerializerType, type(Model)):
+    pass

{django_ninja_aio_crud-0.2.2 → django_ninja_aio_crud-0.3.0}/ninja_aio/views.py

@@ -1,13 +1,15 @@
 from typing import List
 
-from ninja import NinjaAPI, Router
+from ninja import NinjaAPI, Router, Schema
 from ninja.constants import NOT_SET
 from ninja.pagination import paginate, AsyncPaginationBase, PageNumberPagination
 from django.http import HttpRequest
+from django.db.models import Model
 
-from .models import ModelSerializer
+from .models import ModelSerializer, ModelUtil
 from .schemas import GenericMessageSchema
 from .exceptions import SerializeError
+from .types import ModelSerializerMeta
 
 ERROR_CODES = frozenset({400, 401, 404, 428})
 
@@ -65,28 +67,39 @@ class APIView:
 
 
 class APIViewSet:
-    model: ModelSerializer
+    model: ModelSerializer | Model
     api: NinjaAPI
+    schema_in: Schema | None = None
+    schema_out: Schema | None = None
+    schema_update: Schema | None = None
     auths: list | None = NOT_SET
     pagination_class: type[AsyncPaginationBase] = PageNumberPagination
 
     def __init__(self) -> None:
         self.router = Router(tags=[self.model._meta.model_name.capitalize()])
-        self.schema_in = self.model.generate_create_s()
-        self.schema_out = self.model.generate_read_s()
-        self.schema_update = self.model.generate_update_s()
         self.path = "/"
         self.path_retrieve = f"{self.model._meta.pk.attname}/"
         self.error_codes = ERROR_CODES
+        self.model_util = ModelUtil(self.model)
+        self.schema_out, self.schema_update, self.schema_in = self.get_schemas()
+
+    def get_schemas(self):
+        if isinstance(self.model, ModelSerializerMeta):
+            return (
+                self.model.generate_read_s(),
+                self.model.generate_update_s(),
+                self.model.generate_create_s(),
+            )
+        return self.schema_out, self.schema_update, self.schema_in
 
     def create_view(self):
         @self.router.post(
             self.path,
             auth=self.auths,
-            response={200: self.schema_out, self.error_codes: GenericMessageSchema},
+            response={201: self.schema_out, self.error_codes: GenericMessageSchema},
         )
         async def create(request: HttpRequest, data: self.schema_in):
-            return await self.model.create_s(request, data)
+            return await self.model_util.create_s(request, data, self.schema_out)
 
         create.__name__ = f"create_{self.model._meta.model_name}"
 
@@ -101,11 +114,17 @@ class APIViewSet:
         )
         @paginate(self.pagination_class)
         async def list(request: HttpRequest):
-            qs = await self.model.queryset_request(request)
-            rels = self.model.get_reverse_relations()
+            qs = self.model.objects.select_related()
+            if isinstance(self.model, ModelSerializerMeta):
+                qs = await self.model.queryset_request(request)
+            rels = self.model_util.get_reverse_relations()
+            print(rels)
             if len(rels) > 0:
                 qs = qs.prefetch_related(*rels)
-            objs = [await self.model.read_s(request, obj) async for obj in qs.all()]
+            objs = [
+                await self.model_util.read_s(request, obj, self.schema_out)
+                async for obj in qs.all()
+            ]
             return objs
 
         list.__name__ = f"list_{self.model._meta.verbose_name_plural}"
@@ -118,10 +137,10 @@ class APIViewSet:
         )
         async def retrieve(request: HttpRequest, pk: int | str):
             try:
-                obj = await self.model.get_object(request, pk)
+                obj = await self.model_util.get_object(request, pk)
             except SerializeError as e:
                 return e.status_code, e.error
-            return await self.model.read_s(request, obj)
+            return await self.model_util.read_s(request, obj, self.schema_out)
 
         retrieve.__name__ = f"retrieve_{self.model._meta.model_name}"
 
@@ -132,7 +151,7 @@ class APIViewSet:
             response={200: self.schema_out, self.error_codes: GenericMessageSchema},
         )
         async def update(request: HttpRequest, data: self.schema_update, pk: int | str):
-            return await self.model.update_s(request, data, pk)
+            return await self.model_util.update_s(request, data, pk, self.schema_out)
 
         update.__name__ = f"update_{self.model._meta.model_name}"
 
@@ -143,7 +162,7 @@ class APIViewSet:
             response={204: None, self.error_codes: GenericMessageSchema},
         )
         async def delete(request: HttpRequest, pk: int | str):
-            return await self.model.delete_s(request, pk)
+            return await self.model_util.delete_s(request, pk)
 
         delete.__name__ = f"delete_{self.model._meta.model_name}"
 
@@ -192,6 +211,6 @@ class APIViewSet:
 
     def add_views_to_route(self):
         return self.api.add_router(
-            f"{self.model.verbose_name_path_resolver()}/",
+            f"{self.model_util.verbose_name_path_resolver()}/",
             self.add_views(),
         )