django-ninja-aio-crud 0.9.1__tar.gz → 0.10.0__tar.gz

{django_ninja_aio_crud-0.9.1 → django_ninja_aio_crud-0.10.0}/PKG-INFO

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

{django_ninja_aio_crud-0.9.1 → django_ninja_aio_crud-0.10.0}/ninja_aio/__init__.py

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

{django_ninja_aio_crud-0.9.1 → django_ninja_aio_crud-0.10.0}/ninja_aio/auth.py

@@ -1,4 +1,4 @@
-from joserfc import jwt, jwk
+from joserfc import jwt, jwk, errors
 from django.http.request import HttpRequest
 from ninja.security.http import HttpBearer
 
@@ -25,11 +25,19 @@ class AsyncJwtBearer(HttpBearer):
         pass
 
     async def authenticate(self, request: HttpRequest, token: str):
+        """
+        Authenticate the request and return the user if authentication is successful.
+        If authentication fails, returns false.
+        """
         try:
             self.dcd = jwt.decode(token, self.jwt_public, algorithms=self.algorithms)
         except ValueError as exc:
-            raise AuthError(", ".join(exc.args), 401)
+            # raise AuthError(", ".join(exc.args), 401)
+            return False
 
-        self.validate_claims(self.dcd.claims)
+        try:
+            self.validate_claims(self.dcd.claims)
+        except errors.JoseError as exc:
+            return False
 
         return await self.auth_handler(request)

{django_ninja_aio_crud-0.9.1 → django_ninja_aio_crud-0.10.0}/ninja_aio/models.py

@@ -60,6 +60,10 @@ class ModelUtil:
         filters: dict = None,
         getters: dict = None,
         with_qs_request=True,
+    ) -> (
+        type["ModelSerializer"]
+        | models.Model
+        | models.QuerySet[type["ModelSerializer"] | models.Model]
     ):
         get_q = {self.model_pk_name: pk} if pk is not None else {}
         if getters:
@@ -73,6 +77,9 @@ class ModelUtil:
         if filters:
             obj_qs = obj_qs.filter(**filters)
 
+        if not get_q:
+            return obj_qs
+
         try:
             obj = await obj_qs.aget(**get_q)
         except ObjectDoesNotExist:

django_ninja_aio_crud-0.10.0/ninja_aio/schemas.py

@@ -0,0 +1,29 @@
+from ninja import Schema
+from pydantic import RootModel
+
+
+class GenericMessageSchema(RootModel[dict[str, str]]):
+    root: dict[str, str]
+
+
+class M2MDetailSchema(Schema):
+    count: int
+    details: list[str]
+
+
+class M2MSchemaOut(Schema):
+    errors: M2MDetailSchema
+    results: M2MDetailSchema
+
+
+class M2MAddSchemaIn(Schema):
+    add: list = []
+
+
+class M2MRemoveSchemaIn(Schema):
+    remove: list = []
+
+
+class M2MSchemaIn(Schema):
+    add: list = []
+    remove: list = []

{django_ninja_aio_crud-0.9.1 → django_ninja_aio_crud-0.10.0}/ninja_aio/views.py

@@ -1,3 +1,4 @@
+import asyncio
 from typing import List
 
 from ninja import NinjaAPI, Router, Schema, Path, Query
@@ -8,7 +9,13 @@ from django.db.models import Model, QuerySet
 from pydantic import create_model
 
 from .models import ModelSerializer, ModelUtil
-from .schemas import GenericMessageSchema
+from .schemas import (
+    GenericMessageSchema,
+    M2MSchemaOut,
+    M2MSchemaIn,
+    M2MAddSchemaIn,
+    M2MRemoveSchemaIn,
+)
 from .types import ModelSerializerMeta, VIEW_TYPES
 
 ERROR_CODES = frozenset({400, 401, 404, 428})
@@ -93,6 +100,11 @@ class APIViewSet:
         - **retrieve_docs** (`str`): Documentation for the retrieve view.
         - **update_docs** (`str`): Documentation for the update view.
         - **delete_docs** (`str`): Documentation for the delete view.
+        - **m2m_relations** (`tuple[ModelSerializer | Model, str]`): Many-to-many relations to manage.
+        - **m2m_add** (`bool`): Enable add operation for M2M relations.
+        - **m2m_remove** (`bool`): Enable remove operation for M2M relations.
+        - **m2m_get** (`bool`): Enable get operation for M2M relations.
+        - **m2m_auth** (`list | None`): Authentication for M2M views.
 
     ## Notes:
         If the model is a ModelSerializer instance, schemas are generated
@@ -137,6 +149,11 @@ class APIViewSet:
     retrieve_docs = "Retrieve a specific object by its primary key."
     update_docs = "Update an object by its primary key."
     delete_docs = "Delete an object by its primary key."
+    m2m_relations: tuple[ModelSerializer | Model, str] = []
+    m2m_add = True
+    m2m_remove = True
+    m2m_get = True
+    m2m_auth: list | None = NOT_SET
 
     def __init__(self) -> None:
         self.error_codes = ERROR_CODES
@@ -219,13 +236,12 @@ class APIViewSet:
         return queryset
 
     def create_view(self):
-        @self.api.post(
-            f"{self.api_route_path}/",
+        @self.router.post(
+            self.path,
             auth=self.post_view_auth(),
             summary=f"Create {self.model._meta.verbose_name.capitalize()}",
             description=self.create_docs,
             response={201: self.schema_out, self.error_codes: GenericMessageSchema},
-            tags=[self.router_tag],
         )
         async def create(request: HttpRequest, data: self.schema_in):  # type: ignore
             return 201, await self.model_util.create_s(request, data, self.schema_out)
@@ -234,8 +250,8 @@ class APIViewSet:
         return create
 
     def list_view(self):
-        @self.api.get(
-            self.api_route_path,
+        @self.router.get(
+            self.get_path,
             auth=self.get_view_auth(),
             summary=f"List {self.model._meta.verbose_name_plural.capitalize()}",
             description=self.list_docs,
@@ -243,7 +259,6 @@ class APIViewSet:
                 200: List[self.schema_out],
                 self.error_codes: GenericMessageSchema,
             },
-            tags=[self.router_tag],
         )
         @paginate(self.pagination_class)
         async def list(
@@ -268,13 +283,12 @@ class APIViewSet:
         return list
 
     def retrieve_view(self):
-        @self.api.get(
-            f"{self.api_route_path}/{self.get_path_retrieve}",
+        @self.router.get(
+            self.get_path_retrieve,
             auth=self.get_view_auth(),
             summary=f"Retrieve {self.model._meta.verbose_name.capitalize()}",
             description=self.retrieve_docs,
             response={200: self.schema_out, self.error_codes: GenericMessageSchema},
-            tags=[self.router_tag],
         )
         async def retrieve(request: HttpRequest, pk: Path[self.path_schema]):  # type: ignore
             obj = await self.model_util.get_object(request, self._get_pk(pk))
@@ -284,13 +298,12 @@ class APIViewSet:
         return retrieve
 
     def update_view(self):
-        @self.api.patch(
-            f"{self.api_route_path}/{self.path_retrieve}",
+        @self.router.patch(
+            self.path_retrieve,
             auth=self.patch_view_auth(),
             summary=f"Update {self.model._meta.verbose_name.capitalize()}",
             description=self.update_docs,
             response={200: self.schema_out, self.error_codes: GenericMessageSchema},
-            tags=[self.router_tag],
         )
         async def update(
             request: HttpRequest,
@@ -305,13 +318,12 @@ class APIViewSet:
         return update
 
     def delete_view(self):
-        @self.api.delete(
-            f"{self.api_route_path}/{self.path_retrieve}",
+        @self.router.delete(
+            self.path_retrieve,
             auth=self.delete_view_auth(),
             summary=f"Delete {self.model._meta.verbose_name.capitalize()}",
             description=self.delete_docs,
             response={204: None, self.error_codes: GenericMessageSchema},
-            tags=[self.router_tag],
         )
         async def delete(request: HttpRequest, pk: Path[self.path_schema]):  # type: ignore
             return 204, await self.model_util.delete_s(request, self._get_pk(pk))
@@ -352,8 +364,145 @@ class APIViewSet:
             pass
         """
 
+    async def _check_m2m_objs(
+        self,
+        request: HttpRequest,
+        objs_pks: list,
+        model: ModelSerializer | Model,
+        related_manager: QuerySet,
+        remove: bool = False,
+    ):
+        errors, objs_detail, objs = [], [], []
+        rel_objs = [rel_obj async for rel_obj in related_manager.select_related().all()]
+        rel_model_name = model._meta.verbose_name.capitalize()
+        for obj_pk in objs_pks:
+            rel_obj = await (
+                await ModelUtil(model).get_object(request, filters={"pk": obj_pk})
+            ).afirst()
+            if rel_obj is None:
+                errors.append(f"{rel_model_name} with pk {obj_pk} not found.")
+                continue
+            if remove ^ (rel_obj in rel_objs):
+                errors.append(
+                    f"{rel_model_name} with id {obj_pk} is {'not ' if remove else ''} in {self.model_util.model_name}"
+                )
+                continue
+            objs.append(rel_obj)
+            objs_detail.append(
+                f"{rel_model_name} with id {obj_pk} successfully {'removed' if remove else 'added'}"
+            )
+        return errors, objs_detail, objs
+
+    def _m2m_views(self):
+        for model, related_name in self.m2m_relations:
+            rel_util = ModelUtil(model)
+            rel_path = rel_util.verbose_name_path_resolver()
+            if self.m2m_get:
+
+                @self.router.get(
+                    f"{self.path_retrieve}{rel_path}",
+                    response={
+                        200: List[
+                            model.generate_related_s(),
+                        ],
+                        self.error_codes : GenericMessageSchema,
+                    },
+                    auth=self.m2m_auth,
+                    summary=f"Get {rel_util.model._meta.verbose_name_plural.capitalize()}",
+                    description=f"Get all related {rel_util.model._meta.verbose_name_plural.capitalize()}",
+                )
+                async def get_related(request: HttpRequest, pk: Path[self.path_schema]):  # type: ignore
+                    obj = await self.model_util.get_object(request, self._get_pk(pk))
+                    related_manager = getattr(obj, related_name)
+                    related_qs = related_manager.all()
+                    related_objs = [
+                        await rel_util.read_s(
+                            request, rel_obj, model.generate_related_s()
+                        )
+                        async for rel_obj in related_qs
+                    ]
+                    return related_objs
+                get_related.__name__ = f"get_{self.model_util.model_name}_{rel_path}"
+                
+                if self.m2m_add or self.m2m_remove:
+                    if self.m2m_add and self.m2m_remove:
+                        schema_in = M2MSchemaIn
+                    elif self.m2m_add:
+                        schema_in = M2MAddSchemaIn
+                    else:  # self.m2m_remove must be True
+                        schema_in = M2MRemoveSchemaIn
+
+                    @self.router.post(
+                        f"{self.path_retrieve}{rel_path}/",
+                        response={
+                            200: M2MSchemaOut,
+                            self.error_codes: GenericMessageSchema,
+                        },
+                        auth=self.m2m_auth,
+                        summary=f"Add or Remove {rel_util.model._meta.verbose_name_plural.capitalize()}",
+                        description=f"Add or remove {rel_util.model._meta.verbose_name_plural.capitalize()}"
+                    )
+                    async def add_and_remove_related(
+                        request: HttpRequest,
+                        pk: Path[self.path_schema],  # type: ignore
+                        data: schema_in,  # type: ignore
+                    ):
+                        obj = await self.model_util.get_object(
+                            request, self._get_pk(pk)
+                        )
+                        related_manager: QuerySet = getattr(obj, related_name)
+                        (
+                            add_errors,
+                            add_details,
+                            add_objs,
+                            remove_errors,
+                            remove_details,
+                            remove_objs,
+                        ) = [], [], [], [], [], []
+                        if self.m2m_add and hasattr(data, "add"):
+                            (
+                                add_errors,
+                                add_details,
+                                add_objs,
+                            ) = await self._check_m2m_objs(
+                                request, data.add, model, related_manager
+                            )
+                        if self.m2m_remove and hasattr(data, "remove"):
+                            (
+                                remove_errors,
+                                remove_details,
+                                remove_objs,
+                            ) = await self._check_m2m_objs(
+                                request,
+                                data.remove,
+                                model,
+                                related_manager,
+                                remove=True,
+                            )
+                        await asyncio.gather(
+                            related_manager.aadd(*add_objs),
+                            related_manager.aremove(*remove_objs),
+                        )
+                        results = add_details + remove_details
+                        errors = add_errors + remove_errors
+
+                        return {
+                            "results": {
+                                "count": len(results),
+                                "details": results,
+                            },
+                            "errors": {
+                                "count": len(errors),
+                                "details": errors,
+                            },
+                        }
+                    add_and_remove_related.__name__ = f"add_and_remove_{self.model_util.model_name}_{rel_path}"
+                
+
     def _add_views(self):
         if "all" in self.disable:
+            if self.m2m_relations:
+                self._m2m_views()
             self.views()
             return self.router
 
@@ -364,8 +513,9 @@ class APIViewSet:
                 view()
 
         self.views()
+        if self.m2m_relations:
+            self._m2m_views()
         return self.router
 
     def add_views_to_route(self):
-        self._add_views()
-        return self.api.add_router(f"{self.api_route_path}", self.router, tags=[self.router_tag])
+        return self.api.add_router(f"{self.api_route_path}", self._add_views())

django_ninja_aio_crud-0.9.1/ninja_aio/schemas.py

@@ -1,5 +0,0 @@
-from pydantic import RootModel
-
-
-class GenericMessageSchema(RootModel[dict[str, str]]):
-    root: dict[str, str]