django-api-admin 1.2.0__tar.gz → 1.2.1__tar.gz

{django_api_admin-1.2.0 → django_api_admin-1.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: django-api-admin
-Version: 1.2.0
+Version: 1.2.1
 Summary: A RESTful API implementation of django.contrib.admin, designed for writing custom frontends.
 Author-email: Muhammad Salah <msbizzacc0unt@outlook.com>
 License: MIT License

django_api_admin-1.2.1/django_api_admin/__init__.py

@@ -0,0 +1,47 @@
+from django.utils.module_loading import autodiscover_modules
+
+from django_api_admin.decorators import action, display, register
+from django_api_admin.filters import (
+    AllValuesFieldListFilter,
+    BooleanFieldListFilter,
+    ChoicesFieldListFilter,
+    DateFieldListFilter,
+    EmptyFieldListFilter,
+    FieldListFilter,
+    ListFilter,
+    RelatedFieldListFilter,
+    RelatedOnlyFieldListFilter,
+    SimpleListFilter,
+)
+from django_api_admin.constants.vars import HORIZONTAL, VERTICAL
+from django_api_admin.admins.model_admin import APIModelAdmin
+from django_api_admin.admins.inline_admin import StackedInlineAPI, TabularInlineAPI
+from django_api_admin.sites import APIAdminSite, site
+
+__all__ = [
+    "action",
+    "display",
+    "register",
+    "APIModelAdmin",
+    "HORIZONTAL",
+    "VERTICAL",
+    "StackedInlineAPI",
+    "TabularInlineAPI",
+    "APIAdminSite",
+    "site",
+    "ListFilter",
+    "SimpleListFilter",
+    "FieldListFilter",
+    "BooleanFieldListFilter",
+    "RelatedFieldListFilter",
+    "ChoicesFieldListFilter",
+    "DateFieldListFilter",
+    "AllValuesFieldListFilter",
+    "EmptyFieldListFilter",
+    "RelatedOnlyFieldListFilter",
+    "autodiscover",
+]
+
+
+def autodiscover():
+    autodiscover_modules("admin", register_to=site)

django_api_admin-1.2.1/django_api_admin/actions.py

@@ -0,0 +1,40 @@
+from django.utils.translation import gettext_lazy, gettext as _
+
+from rest_framework import status
+from rest_framework.exceptions import PermissionDenied
+from rest_framework.response import Response
+
+from django_api_admin.utils.model_ngettext import model_ngettext
+from django_api_admin.utils.get_deleted_objects import get_deleted_objects
+from django_api_admin.decorators import action
+
+
+@action(
+    permissions=['delete'],
+    description=gettext_lazy('Delete selected %(verbose_name_plural)s')
+)
+def delete_selected(modeladmin, request, queryset):
+    """
+    default api_admin action deletes the selected objects
+    no confirmation page
+    """
+    _deletable_objects, _model_count, perms_needed, _protected = get_deleted_objects(
+        queryset, request, modeladmin.admin_site)
+
+    # check the permissions
+    if perms_needed:
+        objects_name = model_ngettext(queryset)
+        msg = _("Cannot delete %(name)s") % {"name": objects_name}
+        raise PermissionDenied(detail=msg)
+
+    # log the deletion of all the objects inside the queryset
+    n = queryset.count()
+    if n:
+        for obj in queryset:
+            modeladmin.log_deletion(request, obj, str(obj))
+
+    # delete the queryset
+    queryset.delete()
+    msg = _("Successfully deleted %s %s.") % (
+        n, model_ngettext(modeladmin.opts, n))
+    return Response({'detail': msg}, status=status.HTTP_200_OK)

django_api_admin-1.2.1/django_api_admin/admin_views/admin_site_views/admin_api_root.py

@@ -0,0 +1,23 @@
+from django.utils.translation import gettext_lazy as _
+
+from rest_framework import status
+from rest_framework.response import Response
+from rest_framework.views import APIView
+from rest_framework.reverse import reverse
+
+
+class AdminAPIRootView(APIView):
+    """
+    A list of all root urls in django_api_admin
+    """
+    root_urls = None
+
+    def get(self, request, *args, **kwargs):
+        namespace = request.resolver_match.namespace
+        data = dict()
+
+        for url in self.root_urls:
+            data[url.name] = reverse(
+                namespace + ':' + url.name, args=args, kwargs=kwargs, request=request)
+
+        return Response(data or {}, status=status.HTTP_200_OK)

django_api_admin-1.2.1/django_api_admin/admin_views/admin_site_views/admin_log.py

@@ -0,0 +1,83 @@
+import json
+
+from django.utils.translation import gettext_lazy as _
+
+from rest_framework import status
+from rest_framework.response import Response
+from rest_framework.views import APIView
+
+from drf_spectacular.utils import extend_schema, OpenApiResponse
+
+from django_api_admin.models import LogEntry
+from django_api_admin.openapi import CommonAPIResponses
+from django_api_admin.serializers import LogEntrySerializer, AdminLogRequestSerializer
+
+
+class AdminLogView(APIView):
+    """
+    Returns a list of actions that were preformed using django admin.
+    """
+    serializer_class = None
+    pagination_class = None
+    permission_classes = []
+    ordering_fields = ['action_time', '-action_time']
+    admin_site = None
+
+    @extend_schema(
+        methods=['GET'],
+        parameters=[AdminLogRequestSerializer],
+        responses={
+            200: OpenApiResponse(
+                response=LogEntrySerializer(many=True),
+                description=_('Successfully retrieved admin log entries')
+            ),
+            401: CommonAPIResponses.unauthorized(),
+            403: CommonAPIResponses.permission_denied(),
+        },
+        description=_('Retrieve a list of admin log entries'),
+        tags=['admin-log']
+    )
+    def get(self, request):
+        queryset = LogEntry.objects.all()
+
+        # order the queryset
+        try:
+            ordering = self.request.query_params.get('o')
+            if ordering is not None:
+                if ordering not in self.ordering_fields:
+                    raise KeyError
+                queryset = queryset.order_by(ordering)
+        except:
+            return Response({'detail': _('Wrong ordering field set.')}, status=status.HTTP_400_BAD_REQUEST)
+
+        # filter the queryset.
+        try:
+            object_id = self.request.query_params.get('object_id')
+            if object_id is not None:
+                queryset = queryset.filter(object_id=object_id)
+        except:
+            return Response({'detail': _('Bad filters.')}, status=status.HTTP_400_BAD_REQUEST)
+
+        # paginate queryset.
+        paginator = self.pagination_class()
+        page = paginator.paginate_queryset(queryset, request, view=self)
+
+        # serialize queryset.
+        serializer = self.serializer_class(page, many=True)
+
+        return Response({
+            'action_list': self.serialize_messages(serializer.data),
+            'config': self.get_config(page, queryset)},
+            status=status.HTTP_200_OK)
+
+    def serialize_messages(self, data):
+        for idx, item in enumerate(data, start=0):
+            data[idx]['change_message'] = json.loads(
+                item['change_message'] or '[]')
+        return data
+
+    def get_config(self, page, queryset):
+        return {
+            'result_count': len(page),
+            'full_result_count': queryset.count(),
+        }

django_api_admin-1.2.1/django_api_admin/admin_views/admin_site_views/app_index.py

@@ -0,0 +1,62 @@
+from django.utils.translation import gettext_lazy as _
+
+from rest_framework.response import Response
+from rest_framework import status
+from rest_framework.exceptions import ParseError
+
+from rest_framework.views import APIView
+
+from drf_spectacular.utils import extend_schema, OpenApiResponse
+
+from django_api_admin.serializers import AppIndexSerializer, AppSerializer
+from django_api_admin.openapi import CommonAPIResponses
+
+
+class AppIndexView(APIView):
+    """
+    Lists models inside a given app.
+    """
+    serializer_class = AppIndexSerializer
+    permission_classes = []
+    admin_site = None
+
+    @extend_schema(
+        request=AppIndexSerializer,
+        responses={
+            200: OpenApiResponse(
+                response=AppSerializer,
+                description=_(
+                    "Successfully constructed the list of registered models")
+            ),
+            403: CommonAPIResponses.permission_denied(),
+            401: CommonAPIResponses.unauthorized()
+        }
+    )
+    def get(self, request, app_label):
+        serializer = self.get_serializer(app_label)
+        if not serializer.is_valid():
+            raise ParseError({"detail": _("invalid app_label")})
+
+        app_dict = self.admin_site._build_app_dict(request, app_label)
+
+        if not app_dict:
+            return Response({'detail': _('The requested admin page does not exist.')},
+                            status=status.HTTP_404_NOT_FOUND)
+
+        # Sort the models alphabetically within each app.
+        app_dict['models'].sort(key=lambda x: x['name'])
+
+        data = {
+            'app_label': app_label,
+            'app': app_dict,
+        }
+        return Response(data, status=status.HTTP_200_OK)
+
+    def get_serializer(self, app_label):
+        registered_app_labels = {
+            model._meta.app_label for model in self.admin_site._registry.keys()
+        }
+        return AppIndexSerializer(
+            data={"app_label": app_label},
+            context={'registered_app_labels': registered_app_labels}
+        )

django_api_admin-1.2.1/django_api_admin/admin_views/admin_site_views/autocomplete.py

@@ -0,0 +1,155 @@
+from django.apps import apps
+from django.utils.translation import gettext_lazy as _
+from django.core.exceptions import FieldDoesNotExist
+
+from rest_framework.exceptions import PermissionDenied, ParseError
+from rest_framework.views import APIView
+from rest_framework.response import Response
+from rest_framework import status
+from rest_framework.views import APIView
+
+from drf_spectacular.utils import extend_schema, OpenApiExample, OpenApiResponse
+
+from django_api_admin.serializers import AutoCompleteSerializer
+from django_api_admin.openapi import CommonAPIResponses
+
+
+class AutoCompleteView(APIView):
+    """
+    API view for handling autocomplete functionality in admin fields.
+    """
+    permission_classes = []
+    admin_site = None
+
+    @extend_schema(
+        parameters=[AutoCompleteSerializer],
+        responses={
+            200: OpenApiResponse(
+                description=_("Successful autocomplete response"),
+                response=AutoCompleteSerializer,
+                examples=[
+                    OpenApiExample(
+                        name=_("Success Response"),
+                        summary=_(
+                            "Example of a successful autocomplete response"),
+                        description="Returns matching records based on the search term",
+                        value=[{
+                            "id": 1,
+                            "name": "Muhammad",
+                            "age": 60,
+                            "is_vip": True,
+                            "date_joined": "2025-02-02T23:09:31.994853Z",
+                            "title": None,
+                            "user": 1,
+                            "publisher": [1],
+                            "pk": 1
+                        }],
+                        status_codes=["200"],
+                    )
+                ]
+            ),
+            403: CommonAPIResponses.permission_denied(),
+            401: CommonAPIResponses.unauthorized(),
+        },
+        description=_(
+            "Endpoint for autocomplete functionality on model fields")
+    )
+    def get(self, request):
+        """
+        Process the request to extract search parameters,
+        validates user permissions, retrieves the relevant queryset,
+        paginates the results, and returns them as a JSON response.
+        """
+        (
+            self.term,
+            self.model_admin,
+            self.source_field,
+            to_field_name,
+        ) = self.process_request(request)
+
+        if not self.has_perm(request):
+            raise PermissionDenied
+
+        self.queryset = self.get_queryset()
+        page = self.admin_site.paginate_queryset(
+            self.queryset, request, view=self)
+
+        # serialize data
+        serializer_class = self.model_admin.get_serializer_class()
+        serializer = serializer_class(page, many=True)
+        data = serializer.data
+
+        return Response(
+            data,
+            status=status.HTTP_200_OK
+        )
+
+    def get_queryset(self):
+        """Return queryset based on model_admin.get_search_results()."""
+        qs = self.model_admin.get_queryset()
+        qs = qs.complex_filter(self.source_field.get_limit_choices_to())
+        qs, search_use_distinct = self.model_admin.get_search_results(
+            qs, self.term)
+        if search_use_distinct:
+            qs = qs.distinct()
+        return qs
+
+    def process_request(self, request):
+        """
+        Validate request integrity, extract and return request parameters.
+
+        Since the subsequent view permission check requires the target model
+        admin, which is determined here, raise PermissionDenied if the
+        requested app, model or field are malformed.
+
+        Raise Http404 if the target model admin is not configured properly with
+        search_fields.
+        """
+        term = request.GET.get("term", "")
+
+        try:
+            app_label = request.GET["app_label"]
+            model_name = request.GET["model_name"]
+            field_name = request.GET["field_name"]
+        except KeyError:
+            raise ParseError(
+                {'detail': _('missing values app_label, model_name, and field_name')})
+
+        # Retrieve objects from parameters.
+        try:
+            source_model = apps.get_model(app_label, model_name)
+        except LookupError:
+            raise ParseError({'detail': _('source model not found')})
+        try:
+            source_field = source_model._meta.get_field(field_name)
+        except FieldDoesNotExist:
+            raise ParseError(
+                {f'detail': _(f'source field not found in source model {source_model._meta.verbose_name}')})
+        try:
+            remote_model = source_field.remote_field.model
+        except AttributeError:
+            raise ParseError(
+                {'detail': _(f'unable to locate the related model using source field {source_field.name}')})
+        try:
+            model_admin = self.admin_site._registry[remote_model]
+        except KeyError:
+            raise ParseError(
+                {'detail': _('the remote model is not registered in the admin')})
+
+        # Validate suitability of objects.
+        if not getattr(model_admin, "search_fields"):
+            raise ParseError(_('%s must have search_fields for the autocomplete_view."') % type(
+                model_admin).__qualname__)
+
+        to_field_name = getattr(
+            source_field.remote_field, "field_name", remote_model._meta.pk.attname
+        )
+        to_field_name = remote_model._meta.get_field(to_field_name).attname
+        if not model_admin.to_field_allowed(to_field_name):
+            raise PermissionDenied
+
+        return term, model_admin, source_field, to_field_name
+
+    def has_perm(self, request):
+        """Check if user has permission to access the related model."""
+        return self.model_admin.has_view_permission(request)

django_api_admin-1.2.1/django_api_admin/admin_views/admin_site_views/index.py

@@ -0,0 +1,37 @@
+# from django.utils.translation import gettext_lazy as _
+
+from rest_framework import status
+from rest_framework.response import Response
+from rest_framework.reverse import reverse
+from rest_framework.views import APIView
+
+from drf_spectacular.utils import extend_schema
+
+from django_api_admin.serializers import AppListSerializer
+from django_api_admin.openapi import CommonAPIResponses
+
+
+class IndexView(APIView):
+    """
+    Return json object that lists all the installed
+    apps that have been registered by the admin site.
+    """
+    permission_classes = []
+    admin_site = None
+
+    @extend_schema(
+        responses={
+            200: AppListSerializer,
+            403: CommonAPIResponses.permission_denied(),
+            401: CommonAPIResponses.unauthorized()
+        },
+    )
+    def get(self, request):
+        app_list = self.admin_site.get_app_list(request)
+        # add an url to app_index in every app in app_list
+        for app in app_list:
+            app['url'] = reverse(f'{self.admin_site.name}:app_list', kwargs={
+                                 'app_label': app['app_label']}, request=request)
+        data = {'app_list': app_list}
+        request.current_app = self.admin_site.name
+        return Response(data, status=status.HTTP_200_OK)

django_api_admin-1.2.1/django_api_admin/admin_views/admin_site_views/language_catalog.py

@@ -0,0 +1,98 @@
+
+from django.utils.translation import gettext_lazy as _
+import json
+
+from django.views.i18n import JSONCatalog
+
+from rest_framework.response import Response
+from rest_framework.views import APIView
+
+from drf_spectacular.utils import extend_schema, OpenApiResponse, OpenApiExample
+
+from django_api_admin.serializers import LanguageCatalogSerializer
+from django_api_admin.openapi import CommonAPIResponses
+
+
+class LanguageCatalogView(APIView):
+    """
+      Returns json object with i18n translation catalog
+      to be used by a client site javascript library
+    """
+    permission_classes = []
+    admin_site = None
+
+    @extend_schema(
+        responses={
+            200: OpenApiResponse(
+                response=LanguageCatalogSerializer,
+                description=_("Successful retrieval of the language catalog."),
+                examples=[
+                    OpenApiExample(
+                        name=_("Success Response"),
+                        summary=_(
+                            "Example of a successful language catalog request"),
+                        description=_(
+                            "return the translation string used in this app"),
+                        value={
+                            "catalog": {
+                                "AM": "ص",
+                                "PM": "م",
+                                "January": "يناير",
+                                "February": "فبراير"
+                            },
+                            "formats": {
+                                "DATE_FORMAT": "j F، Y",
+                                "DATETIME_FORMAT": "N j, Y, P",
+                                "TIME_FORMAT": "g:i A",
+                                "YEAR_MONTH_FORMAT": "F Y",
+                                "MONTH_DAY_FORMAT": "j F",
+                                "SHORT_DATE_FORMAT": "d/m/Y",
+                                "SHORT_DATETIME_FORMAT": "m/d/Y P",
+                                "FIRST_DAY_OF_WEEK": 0,
+                                "DECIMAL_SEPARATOR": ",",
+                                "THOUSAND_SEPARATOR": ".",
+                                "NUMBER_GROUPING": 0,
+                                "DATE_INPUT_FORMATS": [
+                                    "%Y-%m-%d",
+                                    "%m/%d/%Y",
+                                    "%m/%d/%y",
+                                    "%b %d %Y",
+                                    "%b %d, %Y",
+                                    "%d %b %Y",
+                                    "%d %b, %Y",
+                                    "%B %d %Y",
+                                    "%B %d, %Y",
+                                    "%d %B %Y",
+                                    "%d %B, %Y"
+                                ],
+                                "TIME_INPUT_FORMATS": [
+                                    "%H:%M:%S",
+                                    "%H:%M:%S.%f",
+                                    "%H:%M"
+                                ],
+                                "DATETIME_INPUT_FORMATS": [
+                                    "%Y-%m-%d %H:%M:%S",
+                                    "%Y-%m-%d %H:%M:%S.%f",
+                                    "%Y-%m-%d %H:%M",
+                                    "%m/%d/%Y %H:%M:%S",
+                                    "%m/%d/%Y %H:%M:%S.%f",
+                                    "%m/%d/%Y %H:%M",
+                                    "%m/%d/%y %H:%M:%S",
+                                    "%m/%d/%y %H:%M:%S.%f",
+                                    "%m/%d/%y %H:%M"
+                                ]
+                            },
+                            "plural": "n==0 ? 0 : n==1 ? 1 : n==2 ? 2 : n%100>=3 && n%100<=10 ? 3 : n%100>=11 && n%100<=99 ? 4 : 5",
+                        },
+                        status_codes=["200"],
+                    )
+                ]
+            ),
+            403: CommonAPIResponses.permission_denied(),
+            401: CommonAPIResponses.unauthorized(),
+        }
+    )
+    def get(self, request):
+        response = JSONCatalog.as_view(
+            packages=['django_api_admin'], domain='django')(request)
+        return Response(json.loads(response.content), status=response.status_code)

django_api_admin-1.2.1/django_api_admin/admin_views/admin_site_views/obtain_token.py

@@ -0,0 +1,95 @@
+from django.utils.translation import gettext_lazy as _
+
+from rest_framework import status
+from rest_framework.response import Response
+from rest_framework.views import APIView
+
+from rest_framework_simplejwt.tokens import RefreshToken
+
+from drf_spectacular.utils import extend_schema, OpenApiExample, OpenApiResponse
+
+from django_api_admin.utils.get_form_fields import get_form_fields
+from django_api_admin.openapi import CommonAPIResponses, APIResponseExamples, User
+from django_api_admin.serializers import FormFieldsSerializer, ObtainTokenResponseSerializer
+
+
+class ObtainTokenView(APIView):
+    """
+    Allow users to login using username and password.
+    """
+    serializer_class = None
+    permission_classes = []
+    admin_site = None
+
+    @extend_schema(
+        responses={
+            200: OpenApiResponse(
+                description=_(
+                    "Successfully returned the field attributes list"),
+                response=FormFieldsSerializer,
+                examples=[
+                    APIResponseExamples.field_attributes()
+                ]
+            ),
+            403: CommonAPIResponses.permission_denied(),
+            401: CommonAPIResponses.unauthorized()
+        }
+    )
+    def get(self, request):
+        serializer = self.serializer_class()
+        form_fields = get_form_fields(serializer)
+        return Response({'fields': form_fields}, status=status.HTTP_200_OK)
+
+    @extend_schema(
+        responses={
+            200: OpenApiResponse(
+                description=_("Successful token obtainment"),
+                response=ObtainTokenResponseSerializer,
+                examples=[
+                    OpenApiExample(
+                        name=_("Success Response"),
+                        summary=_(
+                            "Example of a successful token obtain response"),
+                        description=_(
+                            "Returns a pair of tokens containing both the refresh and access tokens"),
+                        value={
+                            "detail": "you are logged in successfully",
+                            "user": User,
+                            "tokens": {
+                                "refresh": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ0b2tlbl90eXBlIjoicmVmcmVzaCIsImV4cCI6MTczOTIyODYzMywiaWF0IjoxNzM4NjIzODMzLCJqdGkiOiI0NWFmYTUzYzk4MWY0MjdkODQ5ODgwMGRlOTNiNTY3NSIsInVzZXJfaWQiOjF9.ekHLcEXJRzuim0GlIckd4iFfSiljqfdPpIBgK2_a12s",
+                                "access": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ0b2tlbl90eXBlIjoiYWNjZXNzIiwiZXhwIjoxNzM4NzEwMjMzLCJpYXQiOjE3Mzg2MjM4MzMsImp0aSI6IjkxNjljOWUxNzliMDQ3MmI4NmY0MTJhYzIyOTRkZThiIiwidXNlcl9pZCI6MX0.Gwb23W-clas-K9VfmDeXRNfEBCFRpxVdMpcp3k-fpXM"
+                            }
+                        },
+                        status_codes=["200"]
+                    )
+                ],
+            ),
+            403: CommonAPIResponses.permission_denied(),
+            401: CommonAPIResponses.unauthorized()
+        }
+    )
+    def post(self, request):
+        serializer = self.serializer_class(
+            data=request.data, context={'request': request})
+        if serializer.is_valid():
+            user = serializer.get_user()
+            tokens = self.get_tokens_for_user(user)
+            user_serializer = self.admin_site.user_serializer(user)
+            data = {
+                'detail': _('you are logged in successfully'),
+                'user': user_serializer.data,
+                'tokens': tokens
+            }
+            return Response(data, status=status.HTTP_200_OK)
+
+        for error in serializer.errors.get('non_field_errors', []):
+            if error.code == 'permission_denied':
+                return Response(serializer.errors, status=status.HTTP_403_FORBIDDEN)
+        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+
+    def get_tokens_for_user(self, user):
+        refresh = RefreshToken.for_user(user)
+        return {
+            'refresh': str(refresh),
+            'access': str(refresh.access_token),
+        }