django-smartbase-admin 1.0.4b1__py3-none-any.whl → 1.0.6b1__py3-none-any.whl

django_smartbase_admin/admin/admin_base.py

@@ -1,4 +1,5 @@
 import json
+import logging
 import urllib.parse
 from collections.abc import Iterable
 from functools import partial
@@ -12,6 +13,8 @@ from django.contrib.admin.options import get_content_type_for_model
 from django.contrib.admin.utils import unquote
 from django.contrib.admin.widgets import AdminTextareaWidget
 from django.contrib.auth.forms import UsernameField, ReadOnlyPasswordHashWidget
+from django.contrib.contenttypes.forms import BaseGenericInlineFormSet
+from django.contrib.contenttypes.models import ContentType
 from django.core.exceptions import (
     FieldDoesNotExist,
     ImproperlyConfigured,
@@ -24,15 +27,18 @@ from django.forms.models import (
     ModelFormMetaclass,
     modelform_factory,
 )
+from django.http import HttpResponse
 from django.template.loader import render_to_string
 from django.template.response import TemplateResponse
-from django.urls import reverse
+from django.urls import reverse, NoReverseMatch
 from django.utils.safestring import mark_safe, SafeString
 from django.utils.text import capfirst
 from django.utils.translation import gettext_lazy as _
 from django_admin_inline_paginator.admin import TabularInlinePaginated
+from django_htmx.http import trigger_client_event
 from filer.fields.file import FilerFileField
 from filer.fields.image import AdminImageFormField, FilerImageField
+from nested_admin.formsets import NestedInlineFormSet
 from nested_admin.nested import (
     NestedModelAdmin,
     NestedTabularInline,
@@ -43,7 +49,7 @@ from nested_admin.nested import (
 
 from django_smartbase_admin.engine.actions import SBAdminCustomAction
 from django_smartbase_admin.services.thread_local import SBAdminThreadLocalService
-from django_smartbase_admin.utils import FormFieldsetMixin
+from django_smartbase_admin.utils import FormFieldsetMixin, is_modal
 
 parler_enabled = None
 try:
@@ -68,7 +74,6 @@ try:
 except ImportError:
     pass
 
-
 django_cms_attributes = None
 try:
     from djangocms_attributes_field.fields import AttributesFormField
@@ -77,7 +82,6 @@ try:
 except ImportError:
     pass
 
-
 color_field_enabled = None
 try:
     from colorfield.fields import ColorField
@@ -86,7 +90,6 @@ try:
 except ImportError:
     pass
 
-
 from django_smartbase_admin.admin.widgets import (
     SBAdminTextInputWidget,
     SBAdminTextareaWidget,
@@ -117,6 +120,10 @@ from django_smartbase_admin.engine.admin_base_view import (
     SBAdminBaseListView,
     SBAdminBaseView,
     SBAdminBaseQuerysetMixin,
+    SBADMIN_IS_MODAL_VAR,
+    SBADMIN_PARENT_INSTANCE_PK_VAR,
+    SBADMIN_PARENT_INSTANCE_LABEL_VAR,
+    SBADMIN_PARENT_INSTANCE_FIELD_NAME_VAR,
 )
 from django_smartbase_admin.engine.const import (
     OBJECT_ID_PLACEHOLDER,
@@ -126,6 +133,8 @@ from django_smartbase_admin.engine.const import (
 from django_smartbase_admin.services.translations import SBAdminTranslationsService
 from django_smartbase_admin.services.views import SBAdminViewService
 
+logger = logging.getLogger(__name__)
+
 
 class SBAdminFormFieldWidgetsMixin:
     formfield_widgets = {
@@ -186,7 +195,7 @@ class SBAdminFormFieldWidgetsMixin:
         )
 
     def get_autocomplete_widget(
-        self, request, form_field, db_field, model, multiselect=False
+            self, request, form_field, db_field, model, multiselect=False
     ):
         return request.request_data.configuration.get_autocomplete_widget(
             self, request, form_field, db_field, model, multiselect
@@ -277,7 +286,7 @@ class SBAdminFormFieldWidgetsMixin:
             )
             form_field.widget = form_field_widget_instance
             if form_field.help_text == _(
-                "Hold down “Control”, or “Command” on a Mac, to select more than one."
+                    "Hold down “Control”, or “Command” on a Mac, to select more than one."
             ):
                 form_field.help_text = ""
         return form_field
@@ -358,25 +367,25 @@ if parler_enabled:
                     for translations_model in form_model._parler_meta.get_all_models():
                         fields = getattr(form_new_meta, "fields", form_meta.fields)
                         exclude = (
-                            getattr(form_new_meta, "exclude", form_meta.exclude) or ()
+                                getattr(form_new_meta, "exclude", form_meta.exclude) or ()
                         )
                         widgets = (
-                            getattr(form_new_meta, "widgets", form_meta.widgets) or ()
+                                getattr(form_new_meta, "widgets", form_meta.widgets) or ()
                         )
                         labels = (
-                            getattr(form_new_meta, "labels", form_meta.labels) or ()
+                                getattr(form_new_meta, "labels", form_meta.labels) or ()
                         )
                         help_texts = (
-                            getattr(form_new_meta, "help_texts", form_meta.help_texts)
-                            or ()
+                                getattr(form_new_meta, "help_texts", form_meta.help_texts)
+                                or ()
                         )
                         error_messages = (
-                            getattr(
-                                form_new_meta,
-                                "error_messages",
-                                form_meta.error_messages,
-                            )
-                            or ()
+                                getattr(
+                                    form_new_meta,
+                                    "error_messages",
+                                    form_meta.error_messages,
+                                )
+                                or ()
                         )
                         formfield_callback = attrs.get("formfield_callback", None)
 
@@ -397,10 +406,10 @@ if parler_enabled:
                             # The next code holds the same logic as fields_for_model()
                             # The f.editable check happens in _get_model_form_field()
                             elif (
-                                f_name not in form_base_fields
-                                and (fields is None or f_name in fields)
-                                and f_name not in exclude
-                                and not f_name in attrs
+                                    f_name not in form_base_fields
+                                    and (fields is None or f_name in fields)
+                                    and f_name not in exclude
+                                    and not f_name in attrs
                             ):
                                 # Get declared widget kwargs
                                 if f_name in widgets:
@@ -421,7 +430,7 @@ if parler_enabled:
                                 # See if this formfield was previously defined using a TranslatedField placeholder.
                                 placeholder = _get_mro_attribute(bases, f_name)
                                 if placeholder and isinstance(
-                                    placeholder, TranslatedField
+                                        placeholder, TranslatedField
                                 ):
                                     kwargs.update(placeholder.kwargs)
 
@@ -454,6 +463,7 @@ if parler_enabled:
                     mcs.parler_orig__new__(mcs, name, bases, attrs)
             return super().__new__(mcs, name, bases, attrs)
 
+
     class SBTranslatableModelForm(
         BaseTranslatableModelForm,
         SBAdminBaseForm,
@@ -504,7 +514,7 @@ class SBAdminInlineAndAdminCommon(SBAdminFormFieldWidgetsMixin):
     def init_view_dynamic(self, request, request_data=None, **kwargs) -> None:
         if SBAdminTranslationsService.is_translated_model(self.model):
             has_default_form = (
-                self.form == TranslatableModelForm or self.form == forms.ModelForm
+                    self.form == TranslatableModelForm or self.form == forms.ModelForm
             )
             if not self.form or has_default_form:
                 self.form = SBTranslatableModelForm
@@ -558,12 +568,12 @@ class SBAdminThirdParty(SBAdminInlineAndAdminCommon, SBAdminBaseView):
 
 class SBAdminTranslationStatusMixin:
     def sbadmin_translation_status_row_context(
-        self,
-        language,
-        languages_count,
-        main_language_code,
-        current_lang_code,
-        translations_edit_url,
+            self,
+            language,
+            languages_count,
+            main_language_code,
+            current_lang_code,
+            translations_edit_url,
     ) -> dict[str, Any]:
         language_code = language[0]
         language_title = language[1]
@@ -648,6 +658,27 @@ class SBAdminTranslationStatusMixin:
         return mark_safe(result)
 
 
+class SBAdminInlineFormSetMixin:
+    @classmethod
+    def get_default_prefix(cls):
+        view = getattr(cls.form, "view", None)
+        if view and view.parent_model and view.opts:
+            parent_opts = view.parent_model._meta
+            opts = view.opts
+            modal_prefix = "modal__" if is_modal(SBAdminThreadLocalService.get_request()) else ""
+            return f"{modal_prefix}{parent_opts.app_label}_{parent_opts.model_name}_{opts.app_label}-{opts.model_name}"
+
+        return super().get_default_prefix()
+
+
+class SBAdminGenericInlineFormSet(SBAdminInlineFormSetMixin, BaseGenericInlineFormSet):
+    pass
+
+
+class SBAdminNestedInlineFormSet(SBAdminInlineFormSetMixin, NestedInlineFormSet):
+    pass
+
+
 class SBAdmin(
     SBAdminInlineAndAdminCommon,
     SBAdminBaseQuerysetMixin,
@@ -668,6 +699,10 @@ class SBAdmin(
     sbadmin_tabs = None
     request_data = None
     menu_label = None
+    sbadmin_is_generic_model = False
+
+    def __init__(self, model, admin_site):
+        super().__init__(model, admin_site)
 
     def save_formset(self, request, form, formset, change):
         if not change and hasattr(formset, "inline_instance"):
@@ -688,7 +723,7 @@ class SBAdmin(
         return self.get_model_path()
 
     def get_sbadmin_fieldsets(
-        self, request, object_id=None
+            self, request, object_id=None
     ) -> Iterable[tuple[str | None, dict[str, Any]]]:
         fieldsets = self.sbadmin_fieldsets or self.fieldsets
         if fieldsets:
@@ -702,7 +737,7 @@ class SBAdmin(
         self.get_form(request)()
 
     def get_fieldsets(
-        self, request, obj=None
+            self, request, obj=None
     ) -> list[tuple[str | None, dict[str, Any]]]:
         fieldsets = []
         object_id = obj.id if obj else None
@@ -719,7 +754,7 @@ class SBAdmin(
         return fieldsets
 
     def get_fieldsets_context(
-        self, request, object_id
+            self, request, object_id
     ) -> dict[str, dict[str | None, dict[str, Any]]]:
         fielsets_context = {}
         for fieldset in self.get_sbadmin_fieldsets(request, object_id):
@@ -903,6 +938,50 @@ class SBAdmin(
         except Exception as e:
             return super().history_view(request, object_id, extra_context)
 
+    @classmethod
+    def get_modal_save_response(cls, request, obj):
+        response = HttpResponse()
+        trigger_client_event(
+            response,
+            "sbadmin:modal-change-form-response",
+            {
+                "field": request.POST.get("sb_admin_source_field"),
+                "id": obj.pk,
+                "label": str(obj),
+                "reload": request.POST.get("sbadmin_reload_on_save") == "1",
+            },
+        )
+        trigger_client_event(response, "hideModal", {"elt": "sb-admin-modal"})
+        return response
+
+    def response_add(self, request, obj, post_url_continue=None):
+        if is_modal(request):
+            return self.get_modal_save_response(request, obj)
+        return super().response_add(request, obj, post_url_continue)
+
+    def response_change(self, request, obj):
+        if is_modal(request):
+            return self.get_modal_save_response(request, obj)
+        return super().response_change(request, obj)
+
+    @classmethod
+    def set_generic_relation_from_parent(cls, request, obj):
+        parent_model_path = request.POST.get(SBADMIN_PARENT_INSTANCE_FIELD_NAME_VAR)
+        parent_pk = request.POST.get(SBADMIN_PARENT_INSTANCE_PK_VAR)
+
+        if parent_model_path and parent_pk:
+            app_label, model_name, field, parent_model = parent_model_path.split("_", 4)
+            content_type = ContentType.objects.get(
+                app_label=app_label, model=parent_model
+            )
+            obj.content_type = content_type
+            obj.object_id = int(parent_pk)
+
+    def save_model(self, request, obj, form, change):
+        if self.sbadmin_is_generic_model and SBADMIN_IS_MODAL_VAR in request.POST:
+            self.set_generic_relation_from_parent(request, obj)
+        super().save_model(request, obj, form, change)
+
 
 class SBAdminInline(
     SBAdminInlineAndAdminCommon, SBAdminBaseQuerysetMixin, SBAdminBaseView
@@ -914,6 +993,7 @@ class SBAdminInline(
     extra = 0
     ordering = None
     all_base_fields_form = None
+    sb_admin_add_modal = False
 
     def get_readonly_fields(self, request, obj=None):
         readonly_fields = super().get_readonly_fields(request, obj)
@@ -961,12 +1041,37 @@ class SBAdminInline(
 
     def get_context_data(self, request) -> dict[str, Any]:
         is_sortable_active: bool = self.sortable_field_name and (
-            self.has_add_permission(request) or self.has_change_permission(request)
+                self.has_add_permission(request) or self.has_change_permission(request)
         )
-        return {
+        add_url = None
+        try:
+            if self.sb_admin_add_modal and self.has_add_permission(request):
+                add_url = reverse(
+                    "sb_admin:{}_{}_add".format(
+                        self.opts.app_label, self.opts.model_name
+                    )
+                )
+        except NoReverseMatch:
+            logger.warning(
+                "To use Add in modal, You have to specify SBAdmin view for %s model",
+                self.opts.model_name,
+            )
+        context_data = {
             "inline_list_actions": self.get_sbadmin_inline_list_actions(request),
             "is_sortable_active": is_sortable_active,
+            "add_url": add_url,
         }
+        if self.parent_instance:
+            context_data["parent_data"] = {
+                SBADMIN_PARENT_INSTANCE_PK_VAR: self.parent_instance.pk,
+                SBADMIN_PARENT_INSTANCE_LABEL_VAR: str(self.parent_instance),
+                SBADMIN_PARENT_INSTANCE_FIELD_NAME_VAR: "{}_{}_id_{}".format(
+                    self.model._meta.app_label,
+                    self.model._meta.model_name,
+                    self.parent_model._meta.model_name,
+                ),
+            }
+        return context_data
 
     def init_sortable_field(self) -> None:
         if not self.sortable_field_name:
@@ -1012,10 +1117,12 @@ class SBAdminInline(
 
 class SBAdminTableInline(SBAdminInline, NestedTabularInline):
     template = "sb_admin/inlines/table_inline.html"
+    formset = SBAdminNestedInlineFormSet
 
 
 class SBAdminGenericTableInline(SBAdminInline, NestedGenericTabularInline):
     template = "sb_admin/inlines/table_inline.html"
+    formset = SBAdminGenericInlineFormSet
 
 
 class SBAdminTableInlinePaginated(SBAdminTableInline, TabularInlinePaginated):

django_smartbase_admin/admin/widgets.py

@@ -12,7 +12,7 @@ from django.contrib.admin.widgets import (
 from django.contrib.auth.forms import ReadOnlyPasswordHashWidget
 from django.core.exceptions import ValidationError
 from django.template.loader import render_to_string
-from django.urls import reverse
+from django.urls import reverse, NoReverseMatch
 from django.utils.formats import get_format
 from django.utils.http import urlencode
 from django.utils.safestring import mark_safe
@@ -22,12 +22,17 @@ from filer.fields.file import AdminFileWidget as FilerAdminFileWidget
 from filer.fields.image import AdminImageWidget
 from filer.models import File
 
+from django_smartbase_admin.engine.admin_base_view import (
+    SBADMIN_PARENT_INSTANCE_PK_VAR,
+    SBADMIN_PARENT_INSTANCE_LABEL_VAR,
+)
 from django_smartbase_admin.engine.filter_widgets import (
     AutocompleteFilterWidget,
     SBAdminTreeWidgetMixin,
 )
 from django_smartbase_admin.services.thread_local import SBAdminThreadLocalService
 from django_smartbase_admin.templatetags.sb_admin_tags import SBAdminJSONEncoder
+from django_smartbase_admin.utils import is_modal
 
 logger = logging.getLogger(__name__)
 
@@ -55,6 +60,19 @@ class SBAdminBaseWidget(ContextMixin):
     def get_context(self, name, value, attrs):
         context = super().get_context(name, value, attrs)
         context["widget"]["form_field"] = self.form_field
+        opts = (
+            self.form_field.view.opts
+            if self.form_field
+               and hasattr(self.form_field, "view")
+               and hasattr(self.form_field.view, "opts")
+            else None
+        )
+        modal_prefix = "modal__" if is_modal(SBAdminThreadLocalService.get_request()) else ""
+        if opts:
+            context["widget"]["attrs"][
+                "id"
+            ] = f"{modal_prefix}{opts.app_label}_{opts.model_name}_{context['widget']['attrs']['id']}"
+
         return context
 
 
@@ -118,12 +136,12 @@ class SBAdminToggleWidget(SBAdminBaseWidget, forms.CheckboxInput):
 class SBAdminCKEditorWidget(SBAdminBaseWidget, CKEditorWidget):
 
     def __init__(
-        self,
-        config_name="default",
-        extra_plugins=None,
-        external_plugin_resources=None,
-        form_field=None,
-        attrs=None,
+            self,
+            config_name="default",
+            extra_plugins=None,
+            external_plugin_resources=None,
+            form_field=None,
+            attrs=None,
     ):
         super().__init__(
             form_field,
@@ -340,25 +358,35 @@ class SBAdminAutocompleteWidget(
     def get_context(self, name, value, attrs):
         context = super().get_context(name, value, attrs)
         self.input_id = (
-            context["widget"]["attrs"]["id"] or f'id_{context["widget"]["name"]}'
+                context["widget"]["attrs"]["id"] or f'id_{context["widget"]["name"]}'
         )
         context["widget"]["type"] = "hidden"
         context["widget"]["attrs"]["id"] = self.input_id
         context["widget"]["attrs"]["class"] = "js-autocomplete-detail"
         context["widget"]["attrs"]["data-empty-label"] = (
-            getattr(self.form_field, "empty_label", "---------") or "---------"
+                getattr(self.form_field, "empty_label", "---------") or "---------"
         )
         query_suffix = "__in"
         threadsafe_request = SBAdminThreadLocalService.get_request()
         if not self.is_multiselect():
             query_suffix = ""
             self.multiselect = False
+        context["widget"]["attrs"]["preselect_field"] = threadsafe_request.GET.get(
+            "sbadmin_parent_instance_field"
+        )
+        context["widget"]["attrs"]["preselect_field_label"] = (
+            threadsafe_request.GET.get(SBADMIN_PARENT_INSTANCE_LABEL_VAR)
+        )
+        context["widget"]["attrs"]["preselect_field_value"] = (
+            threadsafe_request.GET.get(SBADMIN_PARENT_INSTANCE_PK_VAR)
+        )
+        parsed_value = None
         if value:
             parsed_value = self.parse_value_from_input(threadsafe_request, value)
             if parsed_value:
                 selected_options = []
                 for item in self.get_queryset(threadsafe_request).filter(
-                    **{f"{self.get_value_field()}{query_suffix}": parsed_value}
+                        **{f"{self.get_value_field()}{query_suffix}": parsed_value}
                 ):
                     selected_options.append(
                         {
@@ -366,10 +394,40 @@ class SBAdminAutocompleteWidget(
                             "label": self.get_label(threadsafe_request, item),
                         }
                     )
+
                 context["widget"]["value"] = json.dumps(selected_options)
                 context["widget"]["value_list"] = selected_options
+
+        if (
+                threadsafe_request.request_data.configuration.autocomplete_show_related_buttons(
+                    self.model,
+                    field_name=self.field_name,
+                    current_view=self.view,
+                    request=threadsafe_request,
+                )
+        ):
+            self.add_related_buttons_urls(parsed_value, context)
+
         return context
 
+    def add_related_buttons_urls(self, parsed_value, context):
+        related_model = self.model
+        app_label = related_model._meta.app_label
+        model_name = related_model._meta.model_name
+
+        try:
+            if parsed_value:
+                change_url = reverse(
+                    "sb_admin:{}_{}_change".format(app_label, model_name),
+                    args=(parsed_value,),
+                )
+                context["widget"]["attrs"]["related_edit_url"] = change_url
+
+            add_url = reverse("sb_admin:{}_{}_add".format(app_label, model_name))
+            context["widget"]["attrs"]["related_add_url"] = add_url
+        except NoReverseMatch:
+            pass
+
     def is_multiselect(self):
         if self.multiselect is not None:
             return self.multiselect
@@ -493,16 +551,16 @@ class SBAdminCodeWidget(SBAdminBaseWidget, forms.Widget):
     def __init__(self, form_field=None, *args, **kwargs):
         super().__init__(form_field, *args, **kwargs)
         self.attrs = {
-            "code-mirror-options": json.dumps(
-                {
-                    "mode": "django",
-                    "theme": "dracula",
-                    "lineWrapping": "true",
-                }
-            ),
-            "code-mirror-width": "100%",
-            "code-mirror-height": "300",
-        } | self.attrs
+                         "code-mirror-options": json.dumps(
+                             {
+                                 "mode": "django",
+                                 "theme": "dracula",
+                                 "lineWrapping": "true",
+                             }
+                         ),
+                         "code-mirror-width": "100%",
+                         "code-mirror-height": "300",
+                     } | self.attrs
 
     class Media:
         css = {
@@ -612,9 +670,9 @@ class SBAdminTreeWidget(SBAdminTreeWidgetMixin, SBAdminAutocompleteWidget):
         parsed_value = self.parse_value_from_input(threadsafe_request, input_value)
         obj = self.form.instance
         if (
-            obj
-            and parsed_value
-            and self.relationship_pick_mode == self.RELATIONSHIP_PICK_MODE_PARENT
+                obj
+                and parsed_value
+                and self.relationship_pick_mode == self.RELATIONSHIP_PICK_MODE_PARENT
         ):
             if obj.id == parsed_value:
                 raise ValidationError(_("Cannot set parent to itself"))

django_smartbase_admin/engine/actions.py

@@ -22,6 +22,8 @@ class SBAdminCustomAction(object):
         no_params=False,
         open_in_modal=False,
         group=None,
+        sub_actions=None,
+        icon=None,
     ) -> None:
         super().__init__()
         self.title = title
@@ -33,9 +35,15 @@ class SBAdminCustomAction(object):
         self.no_params = no_params
         self.open_in_modal = open_in_modal
         self.group = group
+        self.sub_actions = sub_actions
+        self.icon = icon
         self.resolve_url()
 
     def resolve_url(self):
+        if self.sub_actions:
+            for sub_action in self.sub_actions:
+                sub_action.resolve_url()
+            return
         if not (self.url or (self.view and self.action_id)):
             raise ImproperlyConfigured(
                 "You must provide either url or view and action_id"