django-adminflow 1.0.0__py3-none-any.whl

adminflow/__init__.py

@@ -0,0 +1 @@
+# AdminFlow Django Admin Package

adminflow/apps.py

@@ -0,0 +1,22 @@
+from django.apps import AppConfig
+from django.conf import settings
+
+class AdminflowConfig(AppConfig):
+    default_auto_field = 'django.db.models.BigAutoField'
+    name = 'adminflow'
+    label = 'adminflow'
+
+    def ready(self):
+        # Pre-built Email OTP minimalist templates and subject defaults
+        if not hasattr(settings, 'OTP_EMAIL_BODY_HTML_TEMPLATE_PATH'):
+            setattr(settings, 'OTP_EMAIL_BODY_HTML_TEMPLATE_PATH', 'otp/email/token.html')
+        if not hasattr(settings, 'OTP_EMAIL_BODY_TEMPLATE_PATH'):
+            setattr(settings, 'OTP_EMAIL_BODY_TEMPLATE_PATH', 'otp/email/token.txt')
+        app_title = getattr(settings, 'ADMINFLOW_TITLE', getattr(settings, 'ADMINFLOW_COMPANY', 'AdminFlow'))
+        if not hasattr(settings, 'OTP_EMAIL_SUBJECT'):
+            setattr(settings, 'OTP_EMAIL_SUBJECT', f'Your {app_title} Verification Code: {{token}}')
+
+        if getattr(settings, 'ADMINFLOW_DJANGO_OTP', False):
+            from django.contrib import admin
+            from .views import adminflow_login_view
+            admin.site.login = adminflow_login_view

adminflow/context_processors.py

@@ -0,0 +1,72 @@
+from django.conf import settings
+from django.templatetags.static import static
+
+DEFAULTS = {
+    'title': 'AdminFlow',
+    'logo': None,
+    'favicon': None,
+    'company': 'AdminFlow',
+    'sidebar_style': 'rounded',  # rounded, flat, sleek
+    'theme': 'system',  # system, light, dark
+    'density': 'comfortable',  # compact, comfortable
+    'layout': 'default',
+    'bg_color': '#f8f9ff',
+    'sidebar_color': '#0f172a',
+    'sidebar_text_color': '#94a3b8',
+    'sidebar_active_text_color': '#ffffff',
+    'navbar_color': '#ffffff',
+    'primary_color': '#2563eb',
+    'secondary_color': '#64748b',
+    'success_color': '#22c55e',
+    'warning_color': '#f59e0b',
+    'danger_color': '#ef4444',
+    'info_color': '#06b6d4',
+    'border_radius': '16px',
+    'font': 'Inter',
+    'card_shadow': 'medium',
+    'dark_mode': True,
+    'compact_tables': True,
+    'enable_glass_effect': False,
+    'sidebar_collapsible': True,
+    'sidebar_width': 280,
+    'topbar_height': 64,
+    'animation_speed': 'normal',
+    'icon_pack': 'lucide',
+    'table_density': 'comfortable',
+    'date_format': 'MMM dd, yyyy',
+    'time_format': '12h',
+    'language': 'en',
+    'rtl': False,
+    'enable_command_palette': True,
+    'enable_notifications': True,
+    'enable_activity_log': True,
+    'enable_audit_logs': True,
+    'enable_global_search': True,
+    'enable_quick_actions': True,
+    'enable_multi_tab': True,
+    'enable_theme_builder': True,
+    'login_title': 'Master Your Enterprise Flow',
+    'login_subtitle': 'A unified administrative engine built for scale, security, and developer productivity within the Django ecosystem.',
+    'django_otp': False,
+}
+
+def adminflow_settings(request):
+    context = {}
+    for key, val in DEFAULTS.items():
+        setting_name = f"ADMINFLOW_{key.upper()}"
+        context[f"adminflow_{key}"] = getattr(settings, setting_name, val)
+
+    # Automatically resolve logo URL:
+    # 1) If user specified ADMINFLOW_LOGO:
+    #    - If relative (e.g. 'logo.svg'), resolve against MEDIA_URL ('/media/logo.svg')
+    #    - If absolute ('/static/...' or 'https://...'), use directly
+    # 2) If ADMINFLOW_LOGO is not set (None), fall back to default package logo at static('adminflow/img/logo.svg')
+    logo = context.get('adminflow_logo')
+    if logo:
+        if not (logo.startswith('/') or logo.startswith('http://') or logo.startswith('https://')):
+            media_url = getattr(settings, 'MEDIA_URL', '/media/')
+            context['adminflow_logo'] = f"{media_url.rstrip('/')}/{logo.lstrip('/')}"
+    else:
+        context['adminflow_logo'] = static('adminflow/img/logo.png')
+
+    return context

adminflow/forms.py

@@ -0,0 +1,89 @@
+from django import forms
+from django.contrib.auth.forms import AuthenticationForm
+from django.contrib.auth import authenticate, get_user_model
+from django.core.exceptions import ValidationError
+from django.utils.translation import gettext_lazy as _
+
+User = get_user_model()
+
+class AdminFlowLoginForm(AuthenticationForm):
+    username = forms.CharField(
+        label=_("Username or Email"),
+        widget=forms.TextInput(attrs={'autofocus': True, 'placeholder': 'Username or email address'})
+    )
+
+    def clean(self):
+        username_input = self.cleaned_data.get('username', '').strip()
+        password = self.cleaned_data.get('password')
+
+        if username_input and password:
+            # 1. Try exact username match
+            self.user_cache = authenticate(self.request, username=username_input, password=password)
+
+            # 2. Try case-insensitive username match
+            if self.user_cache is None:
+                user_by_username = User.objects.filter(username__iexact=username_input).first()
+                if user_by_username:
+                    self.user_cache = authenticate(self.request, username=user_by_username.get_username(), password=password)
+
+            # 3. Try case-insensitive email match
+            if self.user_cache is None:
+                users_by_email = User.objects.filter(email__iexact=username_input)
+                for u in users_by_email:
+                    cached = authenticate(self.request, username=u.get_username(), password=password)
+                    if cached:
+                        self.user_cache = cached
+                        break
+
+            # 4. Detailed error check if user_cache is still None
+            if self.user_cache is None:
+                user_candidate = (
+                    User.objects.filter(username__iexact=username_input).first() or
+                    User.objects.filter(email__iexact=username_input).first()
+                )
+                if user_candidate and user_candidate.check_password(password):
+                    if not user_candidate.is_active:
+                        raise ValidationError(
+                            _("This account is currently inactive. Please contact an administrator."),
+                            code='inactive',
+                        )
+                raise self.get_invalid_login_error()
+            else:
+                self.confirm_login_allowed(self.user_cache)
+
+        return self.cleaned_data
+
+class AdminFlowOTPAuthenticationForm(AuthenticationForm):
+    otp_token = forms.CharField(
+        required=False,
+        widget=forms.TextInput(attrs={'autocomplete': 'off', 'placeholder': '123456 or Backup Code'})
+    )
+
+    def clean(self):
+        cleaned_data = super().clean()
+        user = self.get_user()
+
+        from django.conf import settings
+        if getattr(settings, 'ADMINFLOW_DJANGO_OTP', False) and user:
+            try:
+                import django_otp
+                from django_otp import match_token
+
+                if django_otp.user_has_device(user, confirmed=True):
+                    otp_token = self.data.get('otp_token', '').strip()
+                    if not otp_token:
+                        raise ValidationError(
+                            _("2FA Verification Required! Please enter your mobile app code, email code, or emergency backup code."),
+                            code='otp_required'
+                        )
+                    device = match_token(user, otp_token)
+                    if not device:
+                        raise ValidationError(
+                            _("Invalid 2FA Code or Emergency Backup Code. Please check your mobile authenticator app, email code, or 10 recovery codes."),
+                            code='otp_invalid'
+                        )
+                    self.otp_device = device
+            except ImportError:
+                pass
+
+        return cleaned_data

adminflow/import_export.py

@@ -0,0 +1,224 @@
+"""
+adminflow.import_export
+=======================
+Plug-and-play multi-sheet export/import mixin for Django admin.
+
+Usage::
+
+    from adminflow.import_export import MultiSheetExportImportMixin
+    from import_export.admin import ImportExportModelAdmin
+
+    class CustomerAdmin(MultiSheetExportImportMixin, ImportExportModelAdmin, ...):
+        combined_sheets = [
+            ('General Details', CustomerResource, None),
+            ('Orders', OrderResource, lambda qs: Order.objects.filter(customer__in=qs)),
+        ]
+
+combined_sheets format:
+    [(sheet_title, ResourceClass, queryset_lambda_or_None), ...]
+
+Export behaviour:
+    - XLSX  → one .xlsx file with one sheet per entry (requires openpyxl)
+    - Other → ZIP archive containing one file per entry (e.g. Customers.csv + Orders.csv)
+
+Import behaviour:
+    - Multi-sheet .xlsx → each sheet processed by its paired resource
+    - Single-sheet / other → falls back to default single-resource import
+"""
+
+try:
+    import tablib
+    HAS_TABLIB = True
+except ImportError:
+    HAS_TABLIB = False
+
+
+class MultiSheetExportImportMixin:
+    """
+    Adds multi-resource export/import to any ImportExportModelAdmin subclass.
+    """
+
+    combined_sheets = []  # [(title, ResourceClass, qs_lambda_or_None), ...]
+
+    # Formats shown in the export form. Override in subclass if needed.
+    # Defaults to XLSX + JSON when combined_sheets is set; all formats otherwise.
+    export_formats_override = None  # set to a list of format classes to force specific formats
+
+    # ── Restrict available export formats ────────────────────────────────────
+    def get_export_formats(self):
+        from import_export.formats.base_formats import XLSX, JSON
+        if self.export_formats_override is not None:
+            return [f for f in self.export_formats_override if f().is_available()]
+        if self.combined_sheets:
+            return [f for f in [XLSX, JSON] if f().is_available()]
+        return super().get_export_formats()
+
+    # ── Export page context ───────────────────────────────────────────────────
+    def init_request_context_data(self, request, form):
+        context = super().init_request_context_data(request, form)
+        if not self.combined_sheets:
+            return context
+
+        sub_sheets = []
+        for title, resource_cls, _ in self.combined_sheets[1:]:
+            try:
+                resource_kwargs = self.get_export_resource_kwargs(request)
+            except Exception:
+                resource_kwargs = {}
+            instance = resource_cls(**resource_kwargs)
+            col_names = [f.column_name for f in instance.get_user_visible_fields()]
+            sub_sheets.append({'title': title, 'fields': col_names})
+
+        context['sub_sheets'] = sub_sheets
+        context['primary_sheet_title'] = self.combined_sheets[0][0]
+        return context
+
+    # ── Override _do_file_export to produce XLSX or ZIP ──────────────────────
+    def _do_file_export(self, file_format, request, queryset, export_form=None):
+        if not self.combined_sheets or not HAS_TABLIB:
+            return super()._do_file_export(file_format, request, queryset, export_form)
+
+        from django.http import HttpResponse
+        from import_export.signals import post_export
+
+        try:
+            ext = file_format.get_extension().lower()
+        except Exception:
+            ext = ''
+
+        model_name = self.model._meta.model_name
+
+        if ext == 'xlsx':
+            # ── Multi-sheet XLSX ──────────────────────────────────────────
+            book = tablib.Databook()
+            for title, resource_cls, qs_func in self.combined_sheets:
+                qs = qs_func(queryset) if qs_func is not None else queryset
+                dataset = resource_cls().export(qs)
+                dataset.title = title
+                book.add_sheet(dataset)
+
+            data = book.xlsx  # bytes
+            response = HttpResponse(
+                data,
+                content_type='application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+            )
+            response['Content-Disposition'] = (
+                f'attachment; filename="{model_name}_export.xlsx"'
+            )
+
+        else:
+            # ── Truly nested JSON ─────────────────────────────────────────
+            # Output structure (children embedded inside each parent):
+            # [
+            #   {
+            #     "id": "1", "name": "Rooney", ...,   ← parent fields
+            #     "orders": [                           ← nest_key from sub-sheet title
+            #       {"id": "1", "customer_email": ..., ...}
+            #     ]
+            #   },
+            #   ...
+            # ]
+            import json
+
+            primary_title, primary_cls, _ = self.combined_sheets[0]
+            sub_sheets = self.combined_sheets[1:]  # [(title, cls, qs_func), ...]
+
+            all_records = []
+            for obj in queryset:
+                # Export this single parent
+                single_qs = queryset.model.objects.filter(pk=obj.pk)
+                parent_ds = primary_cls().export(single_qs)
+                if not parent_ds or len(parent_ds) == 0:
+                    continue
+                parent_row = dict(zip(parent_ds.headers, parent_ds[0]))
+
+                # Nest each sub-sheet under the parent using its title as key
+                for sub_title, sub_cls, sub_qs_func in sub_sheets:
+                    nest_key = sub_title.lower().replace(' ', '_')
+                    if sub_qs_func is not None:
+                        child_qs = sub_qs_func(single_qs)
+                        child_ds = sub_cls().export(child_qs)
+                        children = [
+                            dict(zip(child_ds.headers, row))
+                            for row in child_ds
+                        ]
+                    else:
+                        children = []
+                    parent_row[nest_key] = children
+
+                all_records.append(parent_row)
+
+            raw_json = json.dumps(all_records, indent=2, default=str)
+            response = HttpResponse(raw_json, content_type='application/json')
+            response['Content-Disposition'] = (
+                f'attachment; filename="{model_name}_export.json"'
+            )
+
+        post_export.send(sender=None, model=self.model)
+        return response
+
+
+    # ── Import: detect multi-sheet XLSX ──────────────────────────────────────
+    def import_action(self, request, *args, **kwargs):
+        if not self.combined_sheets or not HAS_TABLIB:
+            return super().import_action(request, *args, **kwargs)
+
+        if request.method != 'POST' or 'confirm' not in request.POST:
+            return super().import_action(request, *args, **kwargs)
+
+        upload = request.FILES.get('import_file') or request.FILES.get('original_file_name')
+        if upload is None:
+            return super().import_action(request, *args, **kwargs)
+
+        if not getattr(upload, 'name', '').lower().endswith('.xlsx'):
+            return super().import_action(request, *args, **kwargs)
+
+        try:
+            raw = upload.read()
+            book = tablib.Databook()
+            book.load(raw, 'xlsx')
+            sheets = book.sheets()
+        except Exception:
+            return super().import_action(request, *args, **kwargs)
+
+        if len(sheets) < 2:
+            return super().import_action(request, *args, **kwargs)
+
+        from django.contrib import messages
+
+        total_new = total_updated = total_error = 0
+        for i, (title, resource_cls, _) in enumerate(self.combined_sheets):
+            if i >= len(sheets):
+                break
+            try:
+                result = resource_cls().import_data(
+                    sheets[i],
+                    dry_run=False,
+                    raise_errors=False,
+                    user=request.user,
+                )
+                total_new     += result.totals.get('new', 0)
+                total_updated += result.totals.get('update', 0)
+                total_error   += result.totals.get('error', 0)
+            except Exception as e:
+                messages.error(request, f"Error importing sheet '{title}': {e}")
+
+        if total_error:
+            messages.warning(
+                request,
+                f"Import finished — {total_new} new, {total_updated} updated, "
+                f"{total_error} errors across all sheets.",
+            )
+        else:
+            messages.success(
+                request,
+                f"Successfully imported all sheets — "
+                f"{total_new} new records, {total_updated} updated.",
+            )
+
+        from django.http import HttpResponseRedirect
+        from django.urls import reverse
+        opts = self.model._meta
+        return HttpResponseRedirect(
+            reverse(f'admin:{opts.app_label}_{opts.model_name}_changelist')
+        )

adminflow/templates/admin/actions.html

@@ -0,0 +1,79 @@
+{% load i18n %}
+<div class="flex flex-wrap items-center gap-3 bg-surface-low border border-outline-variant p-3 rounded-xl">
+    {% block actions %}
+        <div class="flex items-center gap-2">
+            <span class="text-xs font-bold text-on-surface-variant">{% translate "Actions:" %}</span>
+            {% block actions-form %}
+                {% for field in action_form %}
+                    <div class="inline-block relative">
+                        {{ field }}
+                    </div>
+                {% endfor %}
+            {% endblock %}
+        </div>
+        
+        {% block actions-submit %}
+            <button type="submit" class="px-4 py-1.5 bg-primary text-white text-xs font-bold rounded-lg hover:bg-primary/90 transition-all shadow-sm" 
+                    title="{% translate "Run the selected action" %}" name="index" value="{{ action_index|default:0 }}">
+                {% translate "Go" %}
+            </button>
+        {% endblock %}
+        
+        {% block actions-counter %}
+            {% if actions_selection_counter %}
+                <span class="text-xs text-on-surface-variant font-medium ml-2 action-counter" data-actions-icnt="{{ cl.result_list|length }}">
+                    {{ selection_note }}
+                </span>
+                {% if cl.show_full_result_count %}
+                    <span class="hidden text-xs text-primary hover:underline cursor-pointer ml-2 clear-selection">
+                        {% translate "Clear selection" %}
+                    </span>
+                {% endif %}
+            {% endif %}
+        {% endblock %}
+    {% endblock %}
+</div>
+
+<script>
+    document.addEventListener("DOMContentLoaded", function() {
+        // Style the action select dropdown
+        const select = document.querySelector('select[name="action"]');
+        if (select) {
+            select.className = "pl-3 pr-8 py-1.5 bg-surface-lowest border border-outline-variant rounded-lg text-xs appearance-none focus:ring-2 focus:ring-primary/20 focus:border-primary transition-all outline-none";
+        }
+
+        // Live Action Counter update script
+        function updateActionCounter() {
+            const counter = document.querySelector('span.action-counter');
+            if (!counter) return;
+            const total = counter.dataset.actionsIcnt || document.querySelectorAll('input[type="checkbox"].action-select').length;
+            const selected = document.querySelectorAll('input[type="checkbox"].action-select:checked').length;
+            counter.textContent = selected + " of " + total + " selected";
+        }
+
+        // Handle #action-toggle select all / unselect all
+        const actionToggle = document.getElementById("action-toggle");
+        if (actionToggle) {
+            actionToggle.addEventListener("click", function() {
+                const isChecked = this.checked;
+                const rowCheckboxes = document.querySelectorAll('input[type="checkbox"].action-select');
+                rowCheckboxes.forEach(cb => {
+                    cb.checked = isChecked;
+                    const tr = cb.closest('tr');
+                    if (tr) tr.classList.toggle('selected', isChecked);
+                });
+                setTimeout(updateActionCounter, 10);
+            });
+        }
+
+        // Listen for any individual checkbox click/change
+        document.addEventListener('change', function(e) {
+            if (e.target && e.target.type === 'checkbox') {
+                setTimeout(updateActionCounter, 10);
+            }
+        });
+
+        // Sync counter on load
+        updateActionCounter();
+    });
+</script>