django-snapadmin 0.1.0a1__py3-none-any.whl

django_snapadmin-0.1.0a1.dist-info/METADATA

@@ -0,0 +1,197 @@
+Metadata-Version: 2.4
+Name: django-snapadmin
+Version: 0.1.0a1
+Summary: Automatic and customizable admin interface for Django projects.
+License: MIT
+License-File: LICENSE
+Keywords: django,admin,ui,Snap,extra-settings
+Author: Alexander Wiese
+Requires-Python: >=3.10
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Dist: Django (>=5.2)
+Requires-Dist: colorama (>=0.4.6)
+Requires-Dist: django-admin-autocomplete-filter (>=0.7.1)
+Requires-Dist: django-admin-rangefilter (>=0.13.3)
+Requires-Dist: django-ckeditor-5 (>=0.0.12)
+Requires-Dist: django-colorfield (>=0.11.0)
+Requires-Dist: django-cors-headers (>=4.4.0)
+Requires-Dist: django-extra-settings (>=0.12.0)
+Requires-Dist: django-unfold (>=0.40.0)
+Requires-Dist: djangorestframework (>=3.15.0)
+Requires-Dist: djangorestframework-simplejwt (>=5.3.0)
+Requires-Dist: drf-spectacular (>=0.27.0)
+Requires-Dist: graphene-django (>=3.2.0)
+Requires-Dist: python-dotenv (>=1.0.0)
+Requires-Dist: structlog (>=24.1.0)
+Project-URL: Homepage, https://github.com/drofji/django-snapadmin
+Project-URL: Repository, https://github.com/drofji/django-snapadmin
+Description-Content-Type: text/markdown
+
+# 🚀 SnapAdmin — Declarative Django Admin & API Package
+
+**SnapAdmin** is a high-performance, declarative Django package that eliminates admin and API boilerplate. Define your model fields once — get a feature-rich, beautiful Django admin (powered by Unfold), a full REST API, and a dynamic GraphQL API automatically.
+
+[![Python](https://img.shields.io/badge/Python-3.10+-blue?logo=python)](https://python.org)
+[![Django](https://img.shields.io/badge/Django-5.2+-green?logo=django)](https://djangoproject.com)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow)](LICENSE)
+
+---
+
+## 📦 SnapAdmin Package Features
+
+The core `snapadmin` package provides everything you need to bootstrap your project's admin and API:
+
+| Feature | Description |
+|---------|-------------|
+| **Declarative Admin** | Configure `list_display`, `search_fields`, `list_filter` directly in your models using `SnapField`. |
+| **Beautiful UI** | Native integration with `django-unfold` for a modern, responsive admin experience. |
+| **Status Badges** | Easily add color-coded HTML badges for choices and status fields. |
+| **Advanced Layout** | Support for horizontal field rows and tabbed interfaces within the admin form. |
+| **Range Filters** | Built-in date and numeric range filters for efficient data exploration. |
+| **Change Logging** | Automatic tracking of field-level changes (`old → new`) with a dedicated history view. |
+| **Automatic REST API** | Instantly generated CRUD endpoints for every `SnapModel` with zero extra code. |
+| **Dynamic GraphQL API** | Automatically generated GraphQL schema with support for complex data fetching. |
+| **Token Auth** | Secure, expirable API tokens with granular model-level access control. |
+| **Configurable** | Easily enable/disable REST API, GraphQL, Swagger docs, and search modes via settings. |
+| **Elasticsearch Ready** | Multi-mode storage (`DB_ONLY`, `DUAL`, `ES_ONLY`) for blazing fast search. |
+| **Structured Logging** | Integrated `structlog` for readable local logs and JSON logs in production. |
+
+---
+
+## 🏗 Package Architecture
+
+```
+snapadmin/
+├── api/             # REST & GraphQL API core: views, serializers, auth
+├── management/      # Custom management commands
+├── migrations/      # Core package migrations (e.g., APIToken)
+├── static/          # UI assets (CSS, JS, SVG logos)
+├── templates/       # Custom admin templates & dashboard
+├── fields.py        # SnapField definitions with admin introspection
+├── models.py        # SnapModel base, EsManager, and core logic
+└── urls.py          # Auto-configurable API and documentation routes
+```
+
+---
+
+## 🚀 Quickstart: Installation
+
+### From PyPI (Recommended)
+```bash
+pip install django-snapadmin
+```
+
+### From GitHub (Latest/Development)
+```bash
+pip install git+https://github.com/drofji/django-snapadmin.git
+```
+
+---
+
+## 🛠 Usage & Configuration
+
+### 1. Configure Settings
+Add required apps to `INSTALLED_APPS` in `settings.py`:
+```python
+INSTALLED_APPS = [
+    "unfold",
+    "snapadmin",
+    "rest_framework",
+    "drf_spectacular",
+    "graphene_django",
+    # ...
+]
+```
+
+### 2. Define your Model
+```python
+from snapadmin import fields as snap, models as snap_models
+
+class Product(snap_models.SnapModel):
+    name = snap.SnapCharField(max_length=200, searchable=True, show_in_list=True)
+    # Group fields into a single horizontal row
+    price = snap.SnapDecimalField(max_digits=10, decimal_places=2, row="pricing")
+    available = snap.SnapBooleanField(default=True, row="pricing")
+```
+
+### 3. Register Admin
+```python
+# admin.py
+from snapadmin.models import SnapModel
+SnapModel.register_all_admins()
+```
+
+---
+
+## ⚙️ Advanced Settings
+
+Control core features via Django settings:
+
+```python
+SNAPADMIN_REST_API_ENABLED = True   # Enable/Disable the REST API
+SNAPADMIN_GRAPHQL_ENABLED = True    # Enable/Disable the GraphQL API
+SNAPADMIN_SWAGGER_ENABLED = True    # Enable/Disable Swagger UI documentation
+ELASTICSEARCH_ENABLED = False       # Toggle ES search engine support
+```
+
+---
+
+## 🌟 Demo Application Features
+
+The repository includes a `demo/` app and a `sandbox/` project to showcase SnapAdmin's power:
+
+- **Complete Project Setup**: Ready-to-use Docker environment with PostgreSQL, Redis, and Elasticsearch.
+- **Example Domain Models**: Product, Customer, and Order models showing complex relationships.
+- **Interactive Dashboard**: A custom system dashboard with health checks and environment stats.
+- **Seeder Command**: `python manage.py seed_demo` to instantly populate your environment.
+- **Celery Integration**: Example background tasks for data indexing and stats generation.
+
+---
+
+## 🐳 Running the Demo (Docker)
+
+```bash
+git clone https://github.com/drofji/django-snapadmin.git
+cd django-snapadmin
+cp dist.env .env
+docker compose up --build
+```
+- **Admin**: http://localhost:8000/admin/ (admin / admin)
+- **REST API Docs**: http://localhost:8000/api/docs/
+- **GraphQL API**: http://localhost:8000/api/graphql/
+
+---
+
+## 💻 Local Development Setup
+
+```bash
+# Clone and setup environment
+git clone https://github.com/drofji/django-snapadmin.git
+cd django-snapadmin
+python -m venv .venv
+source .venv/bin/activate
+
+# Install in editable mode
+pip install -r requirements.txt
+pip install -e .
+
+# Initialize DB and run
+python manage.py migrate
+python manage.py seed_demo
+python manage.py runserver
+```
+
+---
+
+## 📜 License
+
+MIT License — see [LICENSE](LICENSE).
+
+
+

django_snapadmin-0.1.0a1.dist-info/RECORD

@@ -0,0 +1,35 @@
+snapadmin/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+snapadmin/admin.py,sha256=2_rnohqRkroMNkj1ejNRds0JUjeCBq-JXQZyvpIdlYU,3485
+snapadmin/api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+snapadmin/api/authentication.py,sha256=ktutur2Hczc6FddK_ZsRMnLL71KcNeAA9Ith1FzKvyc,2400
+snapadmin/api/graphql.py,sha256=bHYyTwZagupiIIxe4KmshyXrN5ffn4tXl9SZgccyInE,2396
+snapadmin/api/health.py,sha256=sbY6PRPm051saDzBQY4UtKPlB6Obu5SW-WZq8fp2nJM,1926
+snapadmin/api/serializers.py,sha256=ipw6bOQHp3R2vncZrniXKpiBIarUbYhkd0ndfMBqprI,2360
+snapadmin/api/tasks.py,sha256=ktk9feCjbPTL7pPRqTEla7B_FP7ojdEdAhKtvEoT98w,677
+snapadmin/api/views.py,sha256=MGNeqETTXU6J3n_eh2-_GBDBSh9-EYsn6-UhsY-mAGA,7038
+snapadmin/apps.py,sha256=l-5MPVxGK7a_4Su0O6RZeyQdwgBruvWehJhzRs3b-sc,656
+snapadmin/fields.py,sha256=mfdOQyLDZxAE-NviX4eX3atZ5M2-IWMj4zSh8xB38ho,13455
+snapadmin/init.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+snapadmin/logging_config.py,sha256=PxK8L5cTr3ssIvdNl0etRA8MHj7W1aQ4EVh1GT2ui1U,4948
+snapadmin/management/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+snapadmin/management/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+snapadmin/migrations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+snapadmin/models.py,sha256=18zAuago4evZ2Z23ta5oG6JcduCWTli4Oy1PycHNI4Q,30600
+snapadmin/static/snapadmin/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+snapadmin/static/snapadmin/css/admin.css,sha256=LqOh99rYVxXSZJXWT3kj7DLL2zAT36lynxidVd09gG8,5151
+snapadmin/static/snapadmin/css/select2.min.css,sha256=pkvUefja_UodiarFG3vnvcNsuwFQeC1c9ny4L7ENyiw,16263
+snapadmin/static/snapadmin/js/admin.js,sha256=LnyvEJIqosb0jP_-_-BQTlorKAt_oZK_TEVij8vs_Rk,2917
+snapadmin/static/snapadmin/js/jquery_bridge.js,sha256=N24-Srv8O2xA2pYfdVRsJEqYQL-4BM4J54t9_j_suNc,41
+snapadmin/static/snapadmin/js/model_selector.js,sha256=SdpqRRHbpoD5gfL1VAqDpIOIqLa7WHi-rg5IXtYuR4A,3265
+snapadmin/static/snapadmin/js/select2.min.js,sha256=9yRP_2EFlblE92vzCA10469Ctd0jT48HnmmMw5rJZrA,73163
+snapadmin/static/snapadmin/snap-logo.svg,sha256=CSSIPXwvI2JX4WxPLtZ6d4cpLoRCHgxBtycFdYiVLzo,322
+snapadmin/templates/snapadmin/dashboard.html,sha256=WmdAW02V_3AploVColcXzljmnWDhKV-o0lKJ9IcaLoA,10516
+snapadmin/templates/snapadmin/widgets/smart_model_selector.html,sha256=yPAPD1zj9kfor1lmwJAc8sFBalnCg6loHN1Mew1wEZk,1537
+snapadmin/urls.py,sha256=2XyjfX6T8F87R5_zQ4LdQUxNPMdy2txyiqp8yzPe_kw,2609
+snapadmin/validators.py,sha256=51Ijp9H67Sp_3Ffc4vuyyWvuj-lAnaR3hGwyrj240Z0,3834
+snapadmin/views.py,sha256=8W3o9x1mpXVJlTbfa5goRsS8D_FkBVs8J0dcX6efTk4,5218
+snapadmin/widgets.py,sha256=fl72i01LslGjrFsFBiCK69clH6taLOJZ87FMra95-mk,1819
+django_snapadmin-0.1.0a1.dist-info/METADATA,sha256=QWIzT_HifVKWilOyzzphkb8eP4U9hzDRdsC3HMhWBgA,6912
+django_snapadmin-0.1.0a1.dist-info/WHEEL,sha256=eY7nduwzv-ldUxpzbRlxwvC693Hg6PX8bWDjEHjZ_dk,88
+django_snapadmin-0.1.0a1.dist-info/licenses/LICENSE,sha256=kqHaMN1Qp29lpNatNRZxhhsJOIEKQ6kia-tkqFwMJ6w,1072
+django_snapadmin-0.1.0a1.dist-info/RECORD,,

django_snapadmin-0.1.0a1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 2.4.1
+Root-Is-Purelib: true
+Tag: py3-none-any

django_snapadmin-0.1.0a1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Alexander Wiese
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

snapadmin/admin.py

@@ -0,0 +1,111 @@
+from django.contrib import admin
+from django.utils.html import format_html
+from django.utils.translation import gettext_lazy as _
+
+try:
+    from django.conf import settings
+    if 'unfold' not in settings.INSTALLED_APPS:
+        raise ImportError("Unfold not in INSTALLED_APPS")
+
+    from unfold.admin import ModelAdmin, TabularInline, StackedInline
+    from unfold.contrib.filters.admin import RelatedDropdownFilter, ChoicesDropdownFilter
+    from unfold.decorators import display
+    UNFOLD_INSTALLED = True
+except (ImportError, RuntimeError):
+    from django.contrib.admin import ModelAdmin, TabularInline, StackedInline
+    RelatedDropdownFilter = admin.RelatedFieldListFilter
+    ChoicesDropdownFilter = admin.ChoicesFieldListFilter
+    UNFOLD_INSTALLED = False
+
+    def display(description=None, header=False, label=False, **kwargs):
+        def decorator(func):
+            if description:
+                func.short_description = description
+            return func
+        return decorator
+
+from snapadmin.models import APIToken
+from snapadmin.widgets import SmartModelSelectorWidget
+
+
+class SnapTabularInline(TabularInline):
+    """
+    Standard inline class for SnapAdmin. Fallback to Django admin if Unfold is missing.
+    """
+    extra = 1
+
+
+class SnapStackedInline(StackedInline):
+    """
+    Standard stacked inline class for SnapAdmin. Fallback to Django admin if Unfold is missing.
+    """
+    extra = 1
+
+
+class APITokenAdmin(ModelAdmin):
+    """
+    Admin interface for managing API tokens using Unfold.
+    """
+
+    list_display = [
+        "token_name",
+        "user",
+        "masked_key",
+        "expiration_date",
+        "is_active",
+        "status_badge",
+        "last_used_at",
+        "created_at",
+    ]
+    list_filter  = [
+        ("is_active", ChoicesDropdownFilter),
+        ("user", RelatedDropdownFilter),
+    ]
+    search_fields = ["token_name", "user__username"]
+    readonly_fields = ["token_key", "created_at", "last_used_at"]
+    ordering = ["-created_at"]
+
+    warn_unsaved_form = True
+    list_filter_submit = True
+
+    fieldsets = [
+        (None, {
+            "fields": ["token_name", "user", "token_key"],
+        }),
+        (_("Access Control"), {
+            "fields": ["is_active", "expiration_date", "allowed_models"],
+        }),
+        (_("Audit"), {
+            "fields": ["created_at", "last_used_at"],
+            "classes": ["collapse"],
+        }),
+    ]
+
+    def formfield_for_dbfield(self, db_field, request, **kwargs):
+        if db_field.name == "allowed_models":
+            kwargs["widget"] = SmartModelSelectorWidget()
+        return super().formfield_for_dbfield(db_field, request, **kwargs)
+
+    @display(description=_("Token Key"), header=True)
+    def masked_key(self, obj: APIToken):
+        """Show only the first 8 characters of the token key."""
+        val = f"{obj.token_key[:8]}••••••••"
+        if UNFOLD_INSTALLED:
+            return [val, None, None]
+        return val
+
+    @display(description=_("Status"), label=True)
+    def status_badge(self, obj: APIToken):
+        """Render a coloured pill badge reflecting the token's current state."""
+        if not obj.is_active:
+            res = (_("Disabled"), "danger")
+        elif obj.is_expired:
+            res = (_("Expired"), "warning")
+        else:
+            res = (_("Active"), "success")
+
+        if UNFOLD_INSTALLED:
+            return res
+
+        # Fallback for standard admin: just return the label
+        return res[0]

snapadmin/api/authentication.py

@@ -0,0 +1,81 @@
+"""
+snapadmin/api/authentication.py
+
+Custom DRF authentication backend for SnapAdmin API Tokens.
+"""
+
+import logging
+
+from django.contrib.auth.models import User
+from rest_framework import authentication, exceptions
+
+from snapadmin.models import APIToken
+
+logger = logging.getLogger("snapadmin.api.auth")
+
+
+class APITokenAuthentication(authentication.BaseAuthentication):
+    keyword = "Token"
+
+    def authenticate(self, request):
+        auth_header = authentication.get_authorization_header(request).split()
+
+        if not auth_header or auth_header[0].lower() != b"token":
+            return None
+
+        if len(auth_header) == 1:
+            raise exceptions.AuthenticationFailed("Invalid token header: no token key provided.")
+        if len(auth_header) > 2:
+            raise exceptions.AuthenticationFailed("Invalid token header: spaces are not allowed in token keys.")
+
+        try:
+            token_key = auth_header[1].decode("utf-8")
+        except UnicodeDecodeError:
+            raise exceptions.AuthenticationFailed("Invalid token header: token key contained invalid characters.")
+
+        return self._validate_token(token_key)
+
+    def _validate_token(self, token_key: str):
+        try:
+            token = (
+                APIToken.objects
+                .select_related("user")
+                .get(token_key=token_key)
+            )
+        except APIToken.DoesNotExist:
+            raise exceptions.AuthenticationFailed("Invalid token.")
+
+        if not token.is_active:
+            raise exceptions.AuthenticationFailed("Token has been disabled.")
+
+        if token.is_expired:
+            raise exceptions.AuthenticationFailed("Token has expired.")
+
+        if not token.user.is_active:
+            raise exceptions.AuthenticationFailed("User account is disabled.")
+
+        token.touch()
+
+        logger.debug(
+            "api_token_authenticated",
+            extra={"token_name": token.token_name, "user": token.user.username},
+        )
+
+        return (token.user, token)
+
+    def authenticate_header(self, request):
+        return self.keyword
+
+
+def token_has_permission(
+    token: APIToken,
+    user: User,
+    app_label: str,
+    model_name: str,
+    action: str,
+) -> bool:
+    if not token.can_access_model(app_label, model_name):
+        return False
+
+    perm_codename = f"{app_label}.{action}_{model_name.lower()}"
+    return user.has_perm(perm_codename)

snapadmin/api/graphql.py

@@ -0,0 +1,52 @@
+
+import graphene
+from graphene_django import DjangoObjectType
+from django.apps import apps
+from snapadmin.models import SnapModel, EsStorageMode
+
+def get_dynamic_graphql_schema():
+    class Query(graphene.ObjectType):
+        pass
+
+    for model in apps.get_models():
+        if issubclass(model, SnapModel) and model is not SnapModel:
+            try:
+                type_name = f"{model._meta.app_label.capitalize()}{model.__name__}Type"
+
+                # Create the DjangoObjectType dynamically
+                # We use a closure for model_class to avoid the late binding issue in loops
+                meta_attr = type('Meta', (), {'model': model, 'fields': "__all__"})
+                object_type = type(type_name, (DjangoObjectType,), {'Meta': meta_attr})
+
+                # Add fields to Query
+                field_name = f"{model._meta.app_label}_{model.__name__.lower()}"
+                list_field_name = f"all_{model._meta.app_label}_{model.__name__.lower()}s"
+
+                # Use factories for resolvers to correctly bind the model class
+                def make_single_resolver(m):
+                    def resolve_single(self, info, id):
+                        if getattr(m, 'es_storage_mode', None) == EsStorageMode.ES_ONLY:
+                            # For ES_ONLY, try to find in ES
+                            return m.objects.get(pk=id)
+                        return m.objects.get(pk=id)
+                    return resolve_single
+
+                def make_list_resolver(m):
+                    def resolve_list(self, info):
+                        # If DUAL or ES_ONLY, we could potentially use snap_search here
+                        # But objects.all() for SnapModel is already ES-aware if ES_ONLY
+                        return m.objects.all()
+                    return resolve_list
+
+                setattr(Query, field_name, graphene.Field(object_type, id=graphene.ID(required=True)))
+                setattr(Query, f"resolve_{field_name}", make_single_resolver(model))
+
+                setattr(Query, list_field_name, graphene.List(object_type))
+                setattr(Query, f"resolve_{list_field_name}", make_list_resolver(model))
+            except Exception:
+                # Skip models that can't be introspected (e.g. no DB table for non-managed)
+                continue
+
+    return graphene.Schema(query=Query)
+
+schema = get_dynamic_graphql_schema()

snapadmin/api/health.py

@@ -0,0 +1,55 @@
+
+import logging
+from django.db import connections
+from django.db.utils import OperationalError
+from django.conf import settings
+from rest_framework.views import APIView
+from rest_framework.response import Response
+from rest_framework.permissions import AllowAny
+from drf_spectacular.utils import extend_schema
+
+logger = logging.getLogger("snapadmin.api.health")
+
+class HealthCheckView(APIView):
+    """
+    Check the health of the system.
+    """
+    permission_classes = [AllowAny]
+
+    @extend_schema(summary="Health check for services")
+    def get(self, request):
+        health_status = {
+            "status": "healthy",
+            "services": {
+                "database": "offline",
+                "elasticsearch": "offline",
+            }
+        }
+
+        # Check Database
+        try:
+            db_conn = connections['default']
+            db_conn.cursor()
+            health_status["services"]["database"] = "online"
+        except OperationalError:
+            health_status["status"] = "unhealthy"
+            health_status["services"]["database"] = "offline"
+
+        # Check Elasticsearch
+        if getattr(settings, "ELASTICSEARCH_ENABLED", False):
+            try:
+                from elasticsearch import Elasticsearch
+                url = getattr(settings, "ELASTICSEARCH_URL", "http://localhost:9200")
+                es = Elasticsearch([url], request_timeout=2)
+                if es.ping():
+                    health_status["services"]["elasticsearch"] = "online"
+                else:
+                    health_status["status"] = "degraded"
+                    health_status["services"]["elasticsearch"] = "offline"
+            except Exception:
+                health_status["status"] = "degraded"
+                health_status["services"]["elasticsearch"] = "offline"
+        else:
+            health_status["services"]["elasticsearch"] = "disabled"
+
+        return Response(health_status)

snapadmin/api/serializers.py

@@ -0,0 +1,84 @@
+"""
+snapadmin/api/serializers.py
+
+DRF serializers for the SnapAdmin auto-generated REST API.
+"""
+
+from django.apps import apps
+from django.contrib.auth.models import User
+from rest_framework import serializers
+
+from snapadmin.models import APIToken
+
+
+class APITokenSerializer(serializers.ModelSerializer):
+    owner_username = serializers.CharField(source="user.username", read_only=True)
+    is_expired = serializers.BooleanField(read_only=True)
+    is_valid = serializers.BooleanField(read_only=True)
+
+    class Meta:
+        model = APIToken
+        fields = [
+            "id",
+            "token_name",
+            "token_key",
+            "owner_username",
+            "expiration_date",
+            "allowed_models",
+            "is_active",
+            "is_expired",
+            "is_valid",
+            "created_at",
+            "last_used_at",
+        ]
+        read_only_fields = ["token_key", "created_at", "last_used_at"]
+
+
+class APITokenCreateSerializer(serializers.ModelSerializer):
+    expires_in_days = serializers.IntegerField(
+        required=False,
+        allow_null=True,
+        write_only=True,
+    )
+
+    class Meta:
+        model = APIToken
+        fields = ["token_name", "allowed_models", "expires_in_days"]
+
+    def create(self, validated_data):
+        expires_in_days = validated_data.pop("expires_in_days", None)
+        request = self.context["request"]
+        return APIToken.create_for_user(
+            user=request.user,
+            token_name=validated_data["token_name"],
+            allowed_models=validated_data.get("allowed_models", []),
+            expires_in_days=expires_in_days,
+        )
+
+
+def build_model_serializer(model_class):
+    meta_class = type(
+        "Meta",
+        (),
+        {
+            "model": model_class,
+            "fields": "__all__",
+        },
+    )
+    serializer_class = type(
+        f"{model_class.__name__}Serializer",
+        (serializers.ModelSerializer,),
+        {"Meta": meta_class},
+    )
+    return serializer_class
+
+
+_serializer_cache: dict = {}
+
+
+def get_serializer_for_model(app_label: str, model_name: str):
+    cache_key = f"{app_label}.{model_name}"
+    if cache_key not in _serializer_cache:
+        model_class = apps.get_model(app_label, model_name)
+        _serializer_cache[cache_key] = build_model_serializer(model_class)
+    return _serializer_cache[cache_key]

snapadmin/api/tasks.py

@@ -0,0 +1,27 @@
+"""
+snapadmin/api/tasks.py
+
+Celery background tasks for the API module.
+"""
+
+import logging
+
+from celery import shared_task
+from django.utils import timezone
+
+logger = logging.getLogger("snapadmin.api.tasks")
+
+
+@shared_task(bind=True, name="api.tasks.purge_expired_tokens")
+def purge_expired_tokens(self):
+    from snapadmin.models import APIToken
+
+    cutoff = timezone.now()
+    deleted_qs = APIToken.objects.filter(
+        expiration_date__lt=cutoff,
+        expiration_date__isnull=False,
+    )
+    count, _ = deleted_qs.delete()
+
+    logger.info("expired_tokens_purged", count=count, cutoff=cutoff.isoformat())
+    return {"deleted": count, "cutoff": cutoff.isoformat()}