django-ninja-aio-crud 0.9.2__tar.gz → 0.10.1__tar.gz

{django_ninja_aio_crud-0.9.2 → django_ninja_aio_crud-0.10.1}/PKG-INFO

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

{django_ninja_aio_crud-0.9.2 → django_ninja_aio_crud-0.10.1}/ninja_aio/__init__.py

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

{django_ninja_aio_crud-0.9.2 → django_ninja_aio_crud-0.10.1}/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.2 → django_ninja_aio_crud-0.10.1}/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.1/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.2 → django_ninja_aio_crud-0.10.1}/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
@@ -347,21 +364,138 @@ class APIViewSet:
             pass
         """
 
-    def _add_views(self):
-        if "all" in self.disable:
-            self.views()
-            return self.router
-
-        for views_type, (schema, view) in self._crud_views.items():
-            if views_type not in self.disable and (
-                schema is not None or views_type == "delete"
-            ):
-                view()
-
-        self.views()
-        return self.router
-
-    def add_views_to_route(self):
-        return self.api.add_router(
-            f"{self.api_route_path}", self._add_views()
-        )
+    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()}",
+                )
+                @paginate(self.pagination_class)
+                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:
+                    summary = f"{'Add or Remove' if self.m2m_add and self.m2m_remove else 'Add' if self.m2m_add else 'Remove'} {rel_util.model._meta.verbose_name_plural.capitalize()}"
+                    description = f"{'Add or remove' if self.m2m_add and self.m2m_remove else 'Add' if self.m2m_add else 'Remove'} {rel_util.model._meta.verbose_name_plural.capitalize()}"
+                    schema_in = (
+                        M2MSchemaIn
+                        if self.m2m_add and self.m2m_remove
+                        else M2MAddSchemaIn
+                        if self.m2m_add
+                        else M2MRemoveSchemaIn
+                    )
+
+                    @self.router.post(
+                        f"{self.path_retrieve}{rel_path}/",
+                        response={
+                            200: M2MSchemaOut,
+                            self.error_codes: GenericMessageSchema,
+                        },
+                        auth=self.m2m_auth,
+                        summary=summary,
+                        description=description,
+                    )
+                    async def manage_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,
+                            },
+                        }
+
+                    manage_related.__name__ = (
+                        f"manage_{self.model_util.model_name}_{rel_path}"
+                    )

django_ninja_aio_crud-0.9.2/ninja_aio/schemas.py

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