django-importexport-flow 0.1.0__py3-none-any.whl

django_importexport_flow/__init__.py

@@ -0,0 +1,81 @@
+"""django-importexport-flow package."""
+
+from importlib.metadata import PackageNotFoundError, version
+
+try:
+    __version__ = version("django-importexport-flow")
+except PackageNotFoundError:
+    __version__ = "0.0.0"
+
+__all__ = [
+    "ExportConfigPdf",
+    "ExportConfigTable",
+    "ExportDefinition",
+    "ImportDefinition",
+    "ImportRequest",
+    "ExportRequest",
+    "ExportManager",
+    "__version__",
+    "get_export_definitions",
+    "serialize_export_configuration",
+    "serialize_import_definition",
+    "import_import_definition",
+    "serialize_report_import",
+    "import_report_import",
+]
+
+
+def __getattr__(name: str):
+    if name == "ExportManager":
+        from .managers import ExportManager
+
+        return ExportManager
+    if name == "serialize_export_configuration":
+        from .utils.serialization import serialize_export_configuration
+
+        return serialize_export_configuration
+    if name == "serialize_import_definition":
+        from .utils.serialization import serialize_import_definition
+
+        return serialize_import_definition
+    if name == "import_import_definition":
+        from .utils.serialization import import_import_definition
+
+        return import_import_definition
+    if name == "serialize_report_import":
+        from .utils.serialization import serialize_report_import
+
+        return serialize_report_import
+    if name == "import_report_import":
+        from .utils.serialization import import_report_import
+
+        return import_report_import
+    if name == "get_export_definitions":
+        from .utils import get_export_definitions
+
+        return get_export_definitions
+    if name == "ExportDefinition":
+        from .models import ExportDefinition
+
+        return ExportDefinition
+    if name == "ExportConfigPdf":
+        from .models import ExportConfigPdf
+
+        return ExportConfigPdf
+    if name == "ExportConfigTable":
+        from .models import ExportConfigTable
+
+        return ExportConfigTable
+    if name == "ImportDefinition":
+        from .models import ImportDefinition
+
+        return ImportDefinition
+    if name == "ImportRequest":
+        from .models import ImportRequest
+
+        return ImportRequest
+    if name == "ExportRequest":
+        from .models import ExportRequest
+
+        return ExportRequest
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")

django_importexport_flow/admin/__init__.py

@@ -0,0 +1,23 @@
+"""Django admin registration for django-importexport-flow."""
+
+from __future__ import annotations
+
+# Load modules so @admin.register runs.
+from . import export_definition  # noqa: F401
+from . import import_definition  # noqa: F401
+from . import import_request  # noqa: F401
+from . import export_request  # noqa: F401
+
+from .export_definition import (
+    ExportConfigPdfInline,
+    ExportConfigTableInline,
+    ExportDefinitionAdmin,
+)
+from .import_definition import ImportDefinitionAdmin
+
+__all__ = [
+    "ExportConfigPdfInline",
+    "ExportConfigTableInline",
+    "ExportDefinitionAdmin",
+    "ImportDefinitionAdmin",
+]

django_importexport_flow/admin/export_definition.py

@@ -0,0 +1,90 @@
+from __future__ import annotations
+
+from django.contrib import admin
+from django.contrib import messages
+from django.core.exceptions import PermissionDenied
+from django.urls import reverse
+from django.utils.translation import gettext_lazy as _
+
+from django_boosted import AdminBoostModel, admin_boost_view
+
+from ..forms import ExportConfigurationImportForm
+from ..models import ExportConfigPdf, ExportConfigTable, ExportDefinition
+from ..utils.serialization import import_export_configuration, serialize_export_configuration
+from .generate_export import GenerateExportMixin
+from .import_config import run_json_configuration_import
+
+
+class ExportConfigPdfInline(admin.StackedInline):
+    model = ExportConfigPdf
+    extra = 0
+    classes = ("collapse",)
+    fields = ("template", "configuration")
+
+
+class ExportConfigTableInline(admin.StackedInline):
+    model = ExportConfigTable
+    extra = 0
+    classes = ("collapse",)
+    fields = ("columns", "configuration")
+
+
+@admin.register(ExportDefinition)
+class ExportDefinitionAdmin(GenerateExportMixin, AdminBoostModel):
+    list_display = ("name", "target", "manager", "uuid")
+    search_fields = ("name", "description", "uuid")
+    readonly_fields = (
+        "uuid",
+        "created_by",
+        "updated_by",
+        "created_at",
+        "updated_at",
+    )
+    inlines = (ExportConfigPdfInline, ExportConfigTableInline)
+    fieldsets = (
+        (None, {"fields": ("name", "uuid", "description")}),
+        (
+            _("Model and queryset"),
+            {"fields": ("target", "manager", "order_by")},
+        ),
+        (
+            _("Filters"),
+            {"fields": ("filter_config", "filter_request", "filter_mandatory")},
+        ),
+        (
+            _("Audit"),
+            {"fields": ("created_by", "updated_by", "created_at", "updated_at")},
+        ),
+    )
+
+    @admin_boost_view("json", _("Export configuration (JSON)"))
+    def export_configuration_json(self, request, obj):
+        return serialize_export_configuration(obj)
+
+    @admin_boost_view("adminform", _("Import configuration (JSON)"))
+    def import_configuration_json(self, request, form=None):
+        if not self.has_add_permission(request) and not self.has_change_permission(
+            request
+        ):
+            raise PermissionDenied
+        if form is None:
+            return {"form": ExportConfigurationImportForm()}
+        imported = run_json_configuration_import(
+            request,
+            form,
+            import_export_configuration,
+            log_label="import_export_configuration",
+        )
+        if imported is None:
+            return {"form": form}
+        messages.success(
+            request,
+            _("Imported export “%(name)s”.") % {"name": imported.name},
+        )
+        opts = self.model._meta
+        url = reverse(
+            f"admin:{opts.app_label}_{opts.model_name}_change",
+            args=[imported.pk],
+            current_app=self.admin_site.name,
+        )
+        return {"redirect_url": url}

django_importexport_flow/admin/export_request.py

@@ -0,0 +1,47 @@
+"""Admin for :class:`~django_importexport_flow.models.ExportRequest` (export audit)."""
+
+from __future__ import annotations
+
+from django.contrib import admin
+from django.utils.translation import gettext_lazy as _
+
+from ..models import ExportRequest
+
+
+@admin.register(ExportRequest)
+class ExportRequestAdmin(admin.ModelAdmin):
+    list_display = (
+        "uuid",
+        "export_definition",
+        "export_format",
+        "status",
+        "output_bytes",
+        "created_at",
+        "completed_at",
+        "initiated_by",
+        "created_by",
+        "updated_by",
+        "updated_at",
+    )
+    list_filter = ("status", "export_format", "created_at")
+    search_fields = ("uuid",)
+    readonly_fields = (
+        "uuid",
+        "export_definition",
+        "export_format",
+        "filter_payload",
+        "status",
+        "output_bytes",
+        "error_trace",
+        "created_at",
+        "completed_at",
+        "initiated_by",
+        "created_by",
+        "updated_by",
+        "updated_at",
+    )
+    ordering = ("-created_at",)
+
+    def has_add_permission(self, request):
+        """Rows are created by *Generate export* only."""
+        return False

django_importexport_flow/admin/generate_export.py

@@ -0,0 +1,133 @@
+"""Admin mixin: generate table export with filter_request (GET) + filter_config merge."""
+
+from __future__ import annotations
+
+import json
+import logging
+import re
+import traceback
+from typing import Any
+
+from django.contrib import messages
+from django.core.exceptions import PermissionDenied, ValidationError
+from django.http import HttpResponse
+from django.utils import timezone
+from django.utils.translation import gettext_lazy as _
+
+from django_boosted import admin_boost_view
+from django_boosted.decorators import AdminBoostViewConfig
+
+from ..utils.export import definition_has_table_config, run_table_export
+from ..forms import make_export_form_class
+from ..models import ExportRequest
+from ..utils.http import content_disposition_attachment
+
+logger = logging.getLogger(__name__)
+
+
+def safe_download_stem(
+    raw_name: str | None,
+    *,
+    fallback: str = "export",
+    max_len: int = 80,
+) -> str:
+    """Sanitize a title or name for use as a download filename stem (no extension)."""
+    base = re.sub(r"[^\w\-.]+", "_", raw_name or "").strip("_") or fallback
+    return base[:max_len]
+
+
+def _safe_export_filename(name: str) -> str:
+    return safe_download_stem(name, fallback="export")
+
+
+def _export_timestamp_for_filename() -> str:
+    """Local time, second precision, safe for filenames (e.g. ``20260329_143045``)."""
+    return timezone.localtime(timezone.now()).strftime("%Y%m%d_%H%M%S")
+
+
+def _filter_payload_snapshot(cleaned_data: dict[str, Any]) -> dict[str, Any]:
+    """JSON-safe subset: ``export_format`` and ``fr_*`` keys only."""
+    subset = {
+        k: v
+        for k, v in cleaned_data.items()
+        if k == "export_format" or k.startswith("fr_")
+    }
+    return json.loads(json.dumps(subset, default=str))
+
+
+def dated_export_filename(safe_stem: str, ext: str) -> str:
+    """
+    ``safe_stem`` = basename without extension (already sanitized).
+    ``ext`` must include the leading dot (e.g. ``.csv``).
+    """
+    return f"{safe_stem}_{_export_timestamp_for_filename()}{ext}"
+
+
+class GenerateExportMixin:
+    @admin_boost_view(
+        "adminform",
+        _("Generate export"),
+        config=AdminBoostViewConfig(permission="change"),
+    )
+    def generate_export(self, request, obj, form=None):
+        if not self.has_change_permission(request, obj):
+            raise PermissionDenied
+        FormClass = make_export_form_class(obj)
+        if form is None:
+            return {"form": FormClass()}
+        if not form.is_valid():
+            return {"form": form}
+        if not definition_has_table_config(obj):
+            messages.error(
+                request,
+                _("Add a table configuration (columns) before exporting."),
+            )
+            return {"form": form}
+        cleaned = form.cleaned_data
+        payload = _filter_payload_snapshot(cleaned)
+        export_fmt = str(cleaned.get("export_format") or "")
+        user = (
+            request.user
+            if getattr(request.user, "is_authenticated", False)
+            else None
+        )
+        try:
+            content, content_type, ext = run_table_export(obj, cleaned)
+        except (ValidationError, ValueError) as exc:
+            ExportRequest.objects.create(
+                export_definition=obj,
+                export_format=export_fmt,
+                filter_payload=payload,
+                status=ExportRequest.Status.FAILURE,
+                error_trace=str(exc),
+                completed_at=timezone.now(),
+                initiated_by=user,
+            )
+            messages.error(request, str(exc))
+            return {"form": form}
+        except Exception:
+            logger.exception("Table export failed for export definition %r", getattr(obj, "pk", None))
+            ExportRequest.objects.create(
+                export_definition=obj,
+                export_format=export_fmt,
+                filter_payload=payload,
+                status=ExportRequest.Status.FAILURE,
+                error_trace=traceback.format_exc(),
+                completed_at=timezone.now(),
+                initiated_by=user,
+            )
+            messages.error(request, _("Export failed."))
+            return {"form": form}
+        ExportRequest.objects.create(
+            export_definition=obj,
+            export_format=export_fmt,
+            filter_payload=payload,
+            status=ExportRequest.Status.SUCCESS,
+            output_bytes=len(content),
+            completed_at=timezone.now(),
+            initiated_by=user,
+        )
+        filename = dated_export_filename(_safe_export_filename(obj.name), ext)
+        response = HttpResponse(content, content_type=content_type)
+        response["Content-Disposition"] = content_disposition_attachment(filename)
+        return response

django_importexport_flow/admin/import_config.py

@@ -0,0 +1,57 @@
+"""Shared admin logic for JSON report configuration import."""
+
+from __future__ import annotations
+
+import logging
+from collections.abc import Callable
+from typing import Any
+
+from django.contrib import messages
+from django.core.exceptions import ValidationError
+from django.core.serializers.base import DeserializationError
+from django.db import IntegrityError
+from django.http import HttpRequest
+from django.utils.translation import gettext_lazy as _
+
+logger = logging.getLogger(__name__)
+
+
+def run_json_configuration_import(
+    request: HttpRequest,
+    form: Any,
+    import_fn: Callable[[dict[str, Any]], Any],
+    *,
+    log_label: str,
+) -> Any | None:
+    """
+    Call ``import_fn(form.import_data)`` and surface errors via messages.
+
+    Returns the imported instance on success, or ``None`` on failure (the view
+    should then return ``{"form": form}``).
+    """
+    try:
+        return import_fn(form.import_data)
+    except (ValueError, ValidationError) as exc:
+        messages.error(request, str(exc))
+        return None
+    except DeserializationError as exc:
+        logger.warning("%s JSON deserialize failed: %s", log_label, exc)
+        messages.error(
+            request,
+            _("Could not read the configuration from this file."),
+        )
+        return None
+    except IntegrityError as exc:
+        logger.warning("%s import integrity error: %s", log_label, exc)
+        messages.error(
+            request,
+            _("Import failed: this configuration conflicts with existing data."),
+        )
+        return None
+    except Exception:
+        logger.exception("%s failed", log_label)
+        messages.error(
+            request,
+            _("Import failed. Check the file format and try again."),
+        )
+        return None

django_importexport_flow/admin/import_data.py

@@ -0,0 +1,158 @@
+"""Admin wizard: upload → preview table → confirm import."""
+
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+from django.contrib import messages
+from django.core.exceptions import PermissionDenied
+from django.http import HttpResponse
+from django.shortcuts import render
+from django.utils.translation import gettext_lazy as _
+
+from django_boosted import admin_boost_view
+from django_boosted.decorators import AdminBoostViewConfig
+
+from ..forms import (
+    MAX_TABULAR_IMPORT_BYTES,
+    TabularImportForm,
+    make_tabular_import_form_class,
+)
+from ..utils.import_tabular import (
+    create_import_request,
+    read_uploaded_tabular,
+    run_tabular_import_for_request,
+    validate_import_preview,
+)
+from ..utils import dataframe_preview_table
+from ..models import ImportRequest
+
+logger = logging.getLogger(__name__)
+
+# ``admin/change_form.html`` only sets ``enctype="multipart/form-data"`` when
+# ``has_file_field`` is true; otherwise POST drops uploaded files.
+_UPLOAD_FORM_CONTEXT = {"import_preview": False, "has_file_field": True}
+
+
+def _filter_keys_from_cleaned(cleaned: dict) -> dict:
+    return {k: v for k, v in cleaned.items() if k.startswith("fr_")}
+
+
+class ImportDataPreviewMixin:
+    @admin_boost_view(
+        "adminform",
+        _("Import data (preview)"),
+        config=AdminBoostViewConfig(
+            permission="change",
+            template_name="django_importexport_flow/admin/report_import_import_data.html",
+        ),
+    )
+    def import_tabular_data(self, request, obj, form=None):
+        if not self.has_change_permission(request, obj):
+            raise PermissionDenied
+        FormClass = make_tabular_import_form_class(obj)
+
+        if form is None:
+            return {
+                "form": FormClass(initial={"step": TabularImportForm.STEP_UPLOAD}),
+                **_UPLOAD_FORM_CONTEXT,
+            }
+
+        if not form.is_valid():
+            return {"form": form, **_UPLOAD_FORM_CONTEXT}
+
+        cleaned = form.cleaned_data
+        step = cleaned.get("step") or TabularImportForm.STEP_UPLOAD
+
+        if step == TabularImportForm.STEP_UPLOAD:
+            upload = cleaned["file"]
+            try:
+                df = read_uploaded_tabular(upload, MAX_TABULAR_IMPORT_BYTES)
+            except Exception as exc:
+                messages.error(request, str(exc))
+                return {"form": form, **_UPLOAD_FORM_CONTEXT}
+
+            errs, warns, resolved_cols, df_norm = validate_import_preview(df, obj)
+            for w in warns:
+                messages.warning(request, w)
+            if errs:
+                for e in errs:
+                    messages.error(request, e)
+                return {"form": form, **_UPLOAD_FORM_CONTEXT}
+
+            filter_subset = _filter_keys_from_cleaned(cleaned)
+            ask_kw: dict[str, Any] = {"inferred_column_paths": resolved_cols}
+            try:
+                ask = create_import_request(
+                    obj,
+                    upload,
+                    filter_subset,
+                    request.user,
+                    **ask_kw,
+                )
+            except Exception as exc:
+                logger.exception("Creating ImportRequest failed")
+                messages.error(request, str(exc))
+                return {"form": form, **_UPLOAD_FORM_CONTEXT}
+
+            preview_columns, preview_rows = dataframe_preview_table(
+                df_norm if df_norm is not None else df,
+                limit=30,
+            )
+            context = {
+                **self.admin_site.each_context(request),
+                "title": _("Confirm import"),
+                "opts": self.model._meta,
+                "original": obj,
+                "preview_rows": preview_rows,
+                "preview_columns": preview_columns,
+                "import_request_uuid": str(ask.uuid),
+            }
+            return render(
+                request,
+                "django_importexport_flow/admin/report_import_import_confirm.html",
+                context,
+            )
+
+        uid = cleaned.get("import_request_uuid")
+        ask = (
+            ImportRequest.objects.filter(
+                uuid=uid,
+                import_definition=obj,
+                status=ImportRequest.Status.PENDING,
+            )
+            .first()
+        )
+        if ask is None:
+            messages.error(request, _("Import request not found or already processed."))
+            return {
+                "form": FormClass(initial={"step": TabularImportForm.STEP_UPLOAD}),
+                **_UPLOAD_FORM_CONTEXT,
+            }
+
+        run_tabular_import_for_request(ask)
+        ask.refresh_from_db()
+
+        if ask.status == ImportRequest.Status.SUCCESS:
+            messages.success(
+                request,
+                _("Imported %(n)s row(s).") % {"n": ask.imported_row_count or 0},
+            )
+        else:
+            messages.error(
+                request,
+                _("Import failed. See the import request record for details."),
+            )
+            if ask.error_trace:
+                messages.error(request, ask.error_trace[:4000])
+
+        opts = self.model._meta
+        from django.urls import reverse
+
+        url = reverse(
+            f"admin:{opts.app_label}_{opts.model_name}_change",
+            args=[obj.pk],
+            current_app=self.admin_site.name,
+        )
+        return {"redirect_url": url}