django-smartbase-admin 0.2.54__py3-none-any.whl → 1.0.38__py3-none-any.whl

django_smartbase_admin/admin/admin_base.py

@@ -1,5 +1,10 @@
 import json
+import logging
 import urllib.parse
+from collections.abc import Iterable
+from functools import partial
+from typing import Any
+from urllib.parse import urlparse
 
 from ckeditor.fields import RichTextFormField
 from ckeditor_uploader.fields import RichTextUploadingFormField
@@ -9,24 +14,32 @@ 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.postgres.forms import SimpleArrayField
+from django.contrib.contenttypes.forms import BaseGenericInlineFormSet
+from django.contrib.contenttypes.models import ContentType
 from django.core.exceptions import (
     FieldDoesNotExist,
     ImproperlyConfigured,
     PermissionDenied,
 )
 from django.db import models
+from django.db.models import QuerySet, Q, Model
 from django.forms import HiddenInput
-from django.forms.models import ModelFormMetaclass
+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.utils.safestring import mark_safe
+from django.urls import reverse, NoReverseMatch, resolve
+from django.utils.safestring import mark_safe, SafeString
 from django.utils.text import capfirst
 from django.utils.translation import gettext_lazy as _
-from django.utils.translation import override as translation_override
 from django_admin_inline_paginator.admin import TabularInlinePaginated
-from filer.fields.image import AdminImageFormField
+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,
@@ -35,12 +48,14 @@ from nested_admin.nested import (
     NestedGenericStackedInline,
 )
 
-from django_smartbase_admin.actions.admin_action_list import SBAdminListAction
 from django_smartbase_admin.engine.actions import SBAdminCustomAction
-from django_smartbase_admin.utils import FormFieldsetMixin
+from django_smartbase_admin.services.thread_local import SBAdminThreadLocalService
+from django_smartbase_admin.utils import FormFieldsetMixin, is_modal
 
 parler_enabled = None
 try:
+    from parler.admin import TranslatableAdmin
+
     from parler.forms import (
         TranslatableModelForm,
         TranslatableModelFormMetaclass,
@@ -54,6 +69,30 @@ try:
 except ImportError:
     pass
 
+postrgres_enabled = None
+try:
+    from django.contrib.postgres.forms import SimpleArrayField
+
+    postrgres_enabled = True
+except ImportError:
+    pass
+
+django_cms_attributes = None
+try:
+    from djangocms_attributes_field.fields import AttributesFormField
+
+    django_cms_attributes = True
+except ImportError:
+    pass
+
+color_field_enabled = None
+try:
+    from colorfield.fields import ColorField
+
+    color_field_enabled = True
+except ImportError:
+    pass
+
 from django_smartbase_admin.admin.widgets import (
     SBAdminTextInputWidget,
     SBAdminTextareaWidget,
@@ -74,19 +113,32 @@ from django_smartbase_admin.admin.widgets import (
     SBAdminPasswordInputWidget,
     SBAdminReadOnlyPasswordHashWidget,
     SBAdminHiddenWidget,
+    SBAdminCKEditorUploadingWidget,
+    SBAdminAttributesWidget,
+    SBAdminMultipleChoiceInlineWidget,
+    SBAdminColorWidget,
+    SBAdminFilerFileWidget,
 )
 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,
+    SBADMIN_RELOAD_ON_SAVE_VAR,
 )
 from django_smartbase_admin.engine.const import (
     OBJECT_ID_PLACEHOLDER,
     TRANSLATIONS_SELECTED_LANGUAGES,
+    ROW_CLASS_FIELD,
 )
 from django_smartbase_admin.services.translations import SBAdminTranslationsService
 from django_smartbase_admin.services.views import SBAdminViewService
 
+logger = logging.getLogger(__name__)
+
 
 class SBAdminFormFieldWidgetsMixin:
     formfield_widgets = {
@@ -109,15 +161,26 @@ class SBAdminFormFieldWidgetsMixin:
         forms.BooleanField: SBAdminToggleWidget,
         forms.SlugField: SBAdminTextInputWidget,
         RichTextFormField: SBAdminCKEditorWidget,
-        RichTextUploadingFormField: SBAdminCKEditorWidget,
+        RichTextUploadingFormField: SBAdminCKEditorUploadingWidget,
         forms.ChoiceField: SBAdminSelectWidget,
         forms.TypedChoiceField: SBAdminSelectWidget,
+        forms.MultipleChoiceField: SBAdminMultipleChoiceInlineWidget,
+        forms.TypedMultipleChoiceField: SBAdminMultipleChoiceInlineWidget,
         forms.NullBooleanField: SBAdminNullBooleanSelectWidget,
-        SimpleArrayField: SBAdminArrayWidget,
         AdminImageFormField: SBAdminImageWidget,
         ReadOnlyPasswordHashWidget: SBAdminReadOnlyPasswordHashWidget,
         forms.HiddenInput: SBAdminHiddenWidget,
     }
+    db_field_widgets = {
+        FilerImageField: SBAdminFilerFileWidget,
+        FilerFileField: SBAdminFilerFileWidget,
+    }
+    if postrgres_enabled:
+        formfield_widgets[SimpleArrayField] = SBAdminArrayWidget
+    if django_cms_attributes:
+        formfield_widgets[AttributesFormField] = SBAdminAttributesWidget
+    if color_field_enabled:
+        db_field_widgets[ColorField] = SBAdminColorWidget
 
     django_widget_to_widget = {
         forms.PasswordInput: SBAdminPasswordInputWidget,
@@ -125,7 +188,9 @@ class SBAdminFormFieldWidgetsMixin:
     }
 
     def get_form_field_widget_class(self, form_field, db_field, request):
-        default_widget_class = self.formfield_widgets.get(form_field.__class__)
+        default_widget_class = self.db_field_widgets.get(
+            db_field.__class__, self.formfield_widgets.get(form_field.__class__)
+        )
         if not hasattr(request, "request_data"):
             # in case of login the view is not wrapped and we have no request_data present
             return default_widget_class
@@ -161,7 +226,19 @@ class SBAdminFormFieldWidgetsMixin:
         widget_attrs.pop(
             "class", None
         )  # remove origin classes to prevent override our custom widget class
-        form_field.widget = widget(form_field=form_field, attrs=widget_attrs)
+        kwargs = {}
+        if isinstance(form_field, RichTextFormField):
+            kwargs["config_name"] = getattr(
+                form_field.widget, "config_name", None
+            ) or getattr(db_field, "config_name", "default")
+
+            kwargs["external_plugin_resources"] = getattr(
+                form_field.widget, "external_plugin_resources", None
+            ) or getattr(db_field, "external_plugin_resources", [])
+            kwargs["extra_plugins"] = getattr(
+                form_field.widget, "extra_plugins", None
+            ) or getattr(db_field, "extra_plugins", [])
+        form_field.widget = widget(form_field=form_field, attrs=widget_attrs, **kwargs)
         return form_field
 
     def formfield_for_foreignkey(self, db_field, request, **kwargs):
@@ -233,13 +310,21 @@ class SBAdminFormFieldWidgetsMixin:
 
 
 class SBAdminBaseFormInit(SBAdminFormFieldWidgetsMixin, FormFieldsetMixin):
-    threadsafe_request = None
     view = None
 
     def __init__(self, *args, **kwargs):
         self.view = kwargs.pop("view", self.view)
-        self.threadsafe_request = kwargs.pop("request", self.threadsafe_request)
+        threadsafe_request = kwargs.pop(
+            "request", SBAdminThreadLocalService.get_request()
+        )
         super().__init__(*args, **kwargs)
+        self.init_widgets_dynamic(threadsafe_request)
+        for field in self.declared_fields:
+            form_field = self.fields.get(field)
+            if form_field:
+                self.assign_widget_to_form_field(form_field, request=threadsafe_request)
+
+    def init_widgets_dynamic(self, request):
         for field in self.fields:
             if not hasattr(self.fields[field].widget, "init_widget_dynamic"):
                 continue
@@ -248,19 +333,11 @@ class SBAdminBaseFormInit(SBAdminFormFieldWidgetsMixin, FormFieldsetMixin):
                 self.fields[field],
                 field,
                 self.view,
-                self.threadsafe_request,
+                request,
             )
-        for field in self.declared_fields:
-            form_field = self.fields.get(field)
-            if form_field:
-                self.assign_widget_to_form_field(
-                    form_field, request=self.threadsafe_request
-                )
 
 
-class SBAdminBaseForm(
-    SBAdminBaseFormInit, forms.ModelForm, SBAdminFormFieldWidgetsMixin
-):
+class SBAdminBaseForm(SBAdminBaseFormInit, forms.ModelForm):
     pass
 
 
@@ -403,6 +480,7 @@ if parler_enabled:
 
 class SBAdminInlineAndAdminCommon(SBAdminFormFieldWidgetsMixin):
     sbadmin_fake_inlines = None
+    all_base_fields_form = None
 
     def init_view_static(self, configuration, model, admin_site):
         configuration.view_map[self.get_id()] = self
@@ -413,17 +491,14 @@ class SBAdminInlineAndAdminCommon(SBAdminFormFieldWidgetsMixin):
         for inline_view in inlines:
             if issubclass(inline_view, SBAdminInline):
                 inline_view_instance = inline_view(model, admin_site)
-                configuration.view_map[inline_view_instance.get_id()] = (
-                    inline_view_instance
-                )
                 inline_view_instance.init_view_static(
                     configuration, inline_view_instance.model, admin_site
                 )
 
-    def get_sbadmin_fake_inlines(self, request, obj):
+    def get_sbadmin_fake_inlines(self, request, obj) -> Iterable:
         return self.sbadmin_fake_inlines or []
 
-    def get_inline_instances(self, request, obj=None):
+    def get_inline_instances(self, request, obj=None) -> list:
         inline_classes = self.get_inlines(request, obj)
         inline_classes = [*inline_classes] or []
         inline_classes.extend(self.get_sbadmin_fake_inlines(request, obj))
@@ -442,7 +517,7 @@ class SBAdminInlineAndAdminCommon(SBAdminFormFieldWidgetsMixin):
             inlines.append(inline)
         return inlines
 
-    def init_view_dynamic(self, request, request_data=None, **kwargs):
+    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
@@ -454,23 +529,26 @@ class SBAdminInlineAndAdminCommon(SBAdminFormFieldWidgetsMixin):
                     f"Admin '{self}' form class '{self.form}' needs to extend SBTranslatableModelForm in case of translatable model."
                 )
         super().init_view_dynamic(request, request_data, **kwargs)
-        self.initialize_form_class(self.form)
+        self.initialize_form_class(self.form, request)
 
-    def initialize_form_class(self, form):
+    def initialize_form_class(self, form, request) -> None:
         if form:
             form.view = self
 
-    def initialize_form_class_threadsafe(self, form, request):
-        self.initialize_form_class(form)
-        if form:
-            form.threadsafe_request = request
+    def initialize_all_base_fields_form(self, request) -> None:
+        params = {
+            "form": self.form,
+            "fields": "__all__",
+            "formfield_callback": partial(self.formfield_for_dbfield, request=request),
+        }
+        self.all_base_fields_form = modelform_factory(self.model, **params)
 
 
 class SBAdminThirdParty(SBAdminInlineAndAdminCommon, SBAdminBaseView):
-    def get_menu_view_url(self, request):
+    def get_menu_view_url(self, request) -> str:
         return reverse(f"sb_admin:{self.get_id()}_changelist")
 
-    def get_id(self):
+    def get_id(self) -> str:
         return self.get_model_path()
 
     def change_view(self, request, object_id, form_url="", extra_context=None):
@@ -483,10 +561,14 @@ class SBAdminThirdParty(SBAdminInlineAndAdminCommon, SBAdminBaseView):
         extra_context.update(self.get_global_context(request))
         return super().changelist_view(request, extra_context)
 
-    def get_action_url(self, action, modifier="template"):
+    def get_action_url(self, action, modifier="template") -> str:
         return reverse(
-            f"sb_admin:{self.get_id()}_action",
-            kwargs={"action": action, "modifier": modifier},
+            "sb_admin:sb_admin_base",
+            kwargs={
+                "view": self.get_id(),
+                "action": action,
+                "modifier": modifier,
+            },
         )
 
 
@@ -498,7 +580,7 @@ class SBAdminTranslationStatusMixin:
         main_language_code,
         current_lang_code,
         translations_edit_url,
-    ):
+    ) -> dict[str, Any]:
         language_code = language[0]
         language_title = language[1]
         this_lang_count = languages_count.get(language_code, 0)
@@ -534,11 +616,11 @@ class SBAdminTranslationStatusMixin:
         }
 
     @classmethod
-    def get_empty_state(cls):
+    def get_empty_state(cls) -> SafeString:
         return mark_safe("<div class='is-empty'></div>")
 
     @admin.display(description="")
-    def sbadmin_translation_status(self, obj):
+    def sbadmin_translation_status(self, obj) -> SafeString:
         if not SBAdminTranslationsService.is_i18n_enabled():
             return self.get_empty_state()
 
@@ -582,6 +664,29 @@ 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,
@@ -590,8 +695,8 @@ class SBAdmin(
     NestedModelAdmin,
 ):
     change_list_template = "sb_admin/actions/list.html"
+    reorder_list_template = "sb_admin/actions/list.html"
     change_form_template = "sb_admin/actions/change_form.html"
-    delete_confirmation_template = "sb_admin/actions/delete_confirmation.html"
     delete_selected_confirmation_template = (
         "sb_admin/actions/delete_selected_confirmation.html"
     )
@@ -602,19 +707,29 @@ class SBAdmin(
     sbadmin_tabs = None
     request_data = None
     menu_label = None
+    sbadmin_is_generic_model = False
+
+    def save_formset(self, request, form, formset, change):
+        if not change and hasattr(formset, "inline_instance"):
+            # update inline_instance parent_instance on formset when creating new object
+            formset.inline_instance.parent_instance = form.instance
+        super().save_formset(request, form, formset, change)
 
-    def get_sbadmin_list_filter(self, request):
+    def get_sbadmin_list_filter(self, request) -> Iterable:
         return self.sbadmin_list_filter or self.get_list_filter(request)
 
     def get_form(self, request, obj=None, **kwargs):
+        self.initialize_all_base_fields_form(request)
         form = super().get_form(request, obj, **kwargs)
-        self.initialize_form_class_threadsafe(form, request)
+        self.initialize_form_class(form, request)
         return form
 
-    def get_id(self):
+    def get_id(self) -> str:
         return self.get_model_path()
 
-    def get_sbadmin_fieldsets(self, request, object_id=None):
+    def get_sbadmin_fieldsets(
+        self, request, object_id=None
+    ) -> list[tuple[str | None, dict[str, Any]]]:
         fieldsets = self.sbadmin_fieldsets or self.fieldsets
         if fieldsets:
             return fieldsets
@@ -623,9 +738,12 @@ class SBAdmin(
         )
 
     def register_autocomplete_views(self, request):
+        super().register_autocomplete_views(request)
         self.get_form(request)()
 
-    def get_fieldsets(self, request, obj):
+    def get_fieldsets(
+        self, request, obj=None
+    ) -> list[tuple[str | None, dict[str, Any]]]:
         fieldsets = []
         object_id = obj.id if obj else None
         for fieldset in self.get_sbadmin_fieldsets(request, object_id):
@@ -640,7 +758,9 @@ class SBAdmin(
             fieldsets.append(fieldset_django)
         return fieldsets
 
-    def get_fieldsets_context(self, request, object_id):
+    def get_fieldsets_context(
+        self, request, object_id
+    ) -> dict[str, dict[str | None, dict[str, Any]]]:
         fielsets_context = {}
         for fieldset in self.get_sbadmin_fieldsets(request, object_id):
             actions = fieldset[1].get("actions", [])
@@ -654,53 +774,69 @@ class SBAdmin(
             fielsets_context[fieldset[0]] = fieldset[1]
         return {"fieldsets_context": fielsets_context}
 
-    def get_sbadmin_tabs(self, request, object_id):
+    def get_sbadmin_tabs(self, request, object_id) -> Iterable:
         return self.sbadmin_tabs
 
-    def get_tabs_context(self, request, object_id):
+    def get_tabs_context(self, request, object_id) -> dict[str, Iterable]:
         return {"tabs_context": self.get_sbadmin_tabs(request, object_id)}
 
-    def get_context_data(self, request):
+    def get_context_data(self, request) -> dict[str, Any]:
         return {
             "base_change_list_template": self.change_list_template,
         }
 
-    def get_menu_view_url(self, request):
+    def get_menu_view_url(self, request) -> str:
         all_config = self.get_all_config(request)
         url_suffix = ""
         if all_config and all_config.get("all_params_changed", False):
-            url_params_dict = all_config.get("url_params")
+            url_params_dict = SBAdminViewService.process_url_params(
+                view_id=self.get_id(),
+                url_params=all_config.get("url_params"),
+                filter_version=self.get_filters_version(request),
+            )
             if url_params_dict:
                 url_suffix = f"?{SBAdminViewService.build_list_url(self.get_id(), url_params_dict)}"
 
         return f'{reverse(f"sb_admin:{self.get_id()}_changelist")}{url_suffix}'
 
-    def get_menu_label(self):
+    def get_menu_label(self) -> str:
         return self.menu_label or self.model._meta.verbose_name_plural
 
-    def get_action_url(self, action, modifier="template"):
+    def get_action_url(self, action, modifier="template") -> str:
         if not hasattr(self, action):
             raise ImproperlyConfigured(f"Action {action} does not exist on {self}")
         return reverse(
-            f"sb_admin:{self.get_id()}_action",
+            "sb_admin:sb_admin_base",
             kwargs={
+                "view": self.get_id(),
                 "action": action,
-                "modifier": (
-                    urllib.parse.quote(str(modifier), safe="") if modifier else None
-                ),
+                "modifier": modifier,
             },
         )
 
-    def get_detail_url(self, object_id=None):
+    def get_detail_url(self, object_id=None) -> str:
         return reverse(
             f"sb_admin:{self.get_id()}_change",
             kwargs={"object_id": object_id or OBJECT_ID_PLACEHOLDER},
         )
 
-    def get_new_url(self):
+    def get_new_url(self, request) -> str:
         return reverse(f"sb_admin:{self.get_id()}_add")
 
-    def get_previous_next_context(self, request, object_id):
+    def get_additional_filter_for_previous_next_context(self, request, object_id) -> Q:
+        return Q()
+
+    def get_change_view_context(self, request, object_id) -> dict | dict[str, Any]:
+        return {
+            "show_back_button": True,
+            "back_url": reverse(
+                "sb_admin:{}_{}_changelist".format(
+                    self.opts.app_label, self.opts.model_name
+                )
+            ),
+        }
+
+    def get_previous_next_context(self, request, object_id) -> dict | dict[str, Any]:
         if not self.sbadmin_previous_next_buttons_enabled or not object_id:
             return {}
         changelist_filters = request.GET.get("_changelist_filters", "")
@@ -712,15 +848,20 @@ class SBAdmin(
             )
         except:
             all_params = {}
-        list_action = SBAdminListAction(self, request, all_params=all_params)
+        list_action = self.sbadmin_list_action_class(
+            self, request, all_params=all_params
+        )
+        additional_filter = self.get_additional_filter_for_previous_next_context(
+            request, object_id
+        )
         all_ids = list(
-            list_action.build_final_data_count_queryset()
+            list_action.build_final_data_count_queryset(additional_filter)
             .order_by(*list_action.get_order_by_from_request())
             .values_list("id", flat=True)
         )
         index = all_ids.index(int(object_id))
-        previous_id = None if index == 0 else all_ids[index - 1]
-        next_id = None if index == len(all_ids) - 1 else all_ids[index + 1]
+        previous_id = all_ids[-1] if index == 0 else all_ids[index - 1]
+        next_id = all_ids[0] if index == len(all_ids) - 1 else all_ids[index + 1]
         return {
             "previous_url": (
                 f"{self.get_detail_url(previous_id)}?_changelist_filters={changelist_filters}"
@@ -736,8 +877,16 @@ class SBAdmin(
             ),
         }
 
+    def add_view(self, request, form_url="", extra_context=None):
+        extra_context = extra_context or {}
+        extra_context.update(self.get_global_context(request, None))
+        extra_context.update(self.get_fieldsets_context(request, None))
+        extra_context.update(self.get_tabs_context(request, None))
+        return self.changeform_view(request, None, form_url, extra_context)
+
     def change_view(self, request, object_id, form_url="", extra_context=None):
         extra_context = extra_context or {}
+        extra_context.update(self.get_change_view_context(request, object_id))
         extra_context.update(self.get_global_context(request, object_id))
         extra_context.update(self.get_fieldsets_context(request, object_id))
         extra_context.update(self.get_tabs_context(request, object_id))
@@ -747,16 +896,6 @@ class SBAdmin(
     def changelist_view(self, request, extra_context=None):
         return self.action_list(request, extra_context=extra_context)
 
-    def _get_changed_field_labels_from_form(form, changed_data):
-        changed_field_labels = []
-        for field_name in changed_data:
-            try:
-                verbose_field_name = form.fields[field_name].label or field_name
-            except KeyError:
-                verbose_field_name = field_name
-            changed_field_labels.append(str(verbose_field_name))
-        return changed_field_labels
-
     def history_view(self, request, object_id, extra_context=None):
         try:
             "The 'history' admin view for this model."
@@ -821,6 +960,52 @@ 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_VAR) == "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:
+            prefix, app_label, model_name, field, parent_model = (
+                parent_model_path.split("_", 5)
+            )
+            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
@@ -831,21 +1016,43 @@ class SBAdminInline(
     sbadmin_inline_list_actions = None
     extra = 0
     ordering = None
-
-    def get_ordering(self, request):
+    all_base_fields_form = None
+    sb_admin_add_modal = False
+
+    def get_instance_label(self, request, obj: Model | None = None) -> str | None:
+        if obj:
+            return str(obj)
+        return None
+
+    def get_readonly_fields(self, request, obj=None):
+        readonly_fields = super().get_readonly_fields(request, obj)
+        if ROW_CLASS_FIELD not in readonly_fields:
+            readonly_fields += (ROW_CLASS_FIELD,)
+        return readonly_fields
+
+    def get_fields(self, request, obj=None):
+        fields = super().get_fields(request, obj)
+        if ROW_CLASS_FIELD not in fields:
+            fields += (ROW_CLASS_FIELD,)
+        return fields
+
+    def get_sbadmin_row_class(self, obj):
+        return ""
+
+    def get_ordering(self, request) -> tuple[str]:
         """
         Hook for specifying field ordering.
         """
         return self.ordering or ("-id",)
 
-    def get_queryset(self, request=None):
+    def get_queryset(self, request=None) -> QuerySet:
         qs = super().get_queryset(request)
         return qs.order_by(*self.get_ordering(request))
 
-    def get_sbadmin_inline_list_actions(self):
+    def get_sbadmin_inline_list_actions(self, request) -> list:
         return [*(self.sbadmin_inline_list_actions or [])]
 
-    def get_action_url(self, action, modifier="template"):
+    def get_action_url(self, action, modifier="template") -> str:
         return reverse(
             "sb_admin:sb_admin_base",
             kwargs={
@@ -855,17 +1062,72 @@ class SBAdminInline(
             },
         )
 
-    def register_autocomplete_views(self, request):
+    def register_autocomplete_views(self, request) -> None:
         super().register_autocomplete_views(request)
         form_class = self.get_formset(request, self.model()).form
-        self.initialize_form_class_threadsafe(form_class, request)
+        self.initialize_form_class(form_class, request)
         form_class()
 
-    @property
-    def get_context_data(self):
-        return {"inline_list_actions": self.get_sbadmin_inline_list_actions()}
+    def get_parent_instance_from_request(self):
+        # Try to get parent instance from request referrer
+        request = (
+            getattr(self, "threadsafe_request", None)
+            or SBAdminThreadLocalService.get_request()
+        )
+        allowed = SBAdminViewService.has_permission(
+            request=request, model=self.parent_model, permission="view"
+        )
+        if not allowed:
+            return None
+
+        referer = request.META.get("HTTP_REFERER")
+        if not referer:
+            return None
+        resolved = resolve(urlparse(referer).path)
+        # Try common kwargs for object ID
+        object_id = resolved.kwargs.get("object_id")
+        if not object_id:
+            return None
+        base_qs = SBAdminViewService.get_restricted_queryset(
+            self.parent_model, request, request.request_data
+        )
+        return base_qs.get(pk=object_id)
+
+    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)
+        )
+        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):
+    def init_sortable_field(self) -> None:
         if not self.sortable_field_name:
             for field_name in self.sbadmin_sortable_field_options:
                 is_sortable_field_present = False
@@ -881,15 +1143,15 @@ class SBAdminInline(
         self.init_sortable_field()
         super().__init__(parent_model, admin_site)
 
-    def init_view_dynamic(self, request, request_data=None, **kwargs):
+    def init_view_dynamic(self, request, request_data=None, **kwargs) -> None:
         return super().init_view_dynamic(request, request_data, **kwargs)
 
-    def get_id(self):
+    def get_id(self) -> str:
         return (
             f"{self.__class__.__name__}_{SBAdminViewService.get_model_path(self.model)}"
         )
 
-    def init_inline_dynamic(self, request, obj=None):
+    def init_inline_dynamic(self, request, obj=None) -> None:
         self.threadsafe_request = request
         self.parent_instance = obj
 
@@ -900,18 +1162,21 @@ class SBAdminInline(
         return formfield
 
     def get_formset(self, request, obj=None, **kwargs):
+        self.initialize_all_base_fields_form(request)
         formset = super().get_formset(request, obj, **kwargs)
         form_class = formset.form
-        self.initialize_form_class_threadsafe(form_class, request)
+        self.initialize_form_class(form_class, request)
         return formset
 
 
 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):
@@ -924,11 +1189,51 @@ class SBAdminGenericTableInlinePaginated(SBAdminGenericTableInline):
     per_page = 50
 
 
-class SBAdminStackedInline(SBAdminInline, NestedStackedInline):
+class SBAdminStackedInlineBase(SBAdminInline):
+    default_collapsed = False
+
+    def get_sbadmin_default_collapsed(self, request):
+        return self.default_collapsed
+
+    def get_context_data(self, request) -> dict[str, Any]:
+        context_data = super().get_context_data(request)
+        context_data["default_collapsed"] = self.get_sbadmin_default_collapsed(request)
+        return context_data
+
+    def get_sbadmin_inline_list_actions(self, request) -> list:
+        actions = super().get_sbadmin_inline_list_actions(request)
+        actions.append(
+            SBAdminCustomAction(
+                title="Collapse",
+                css_class=f"collapse-all-stacked-inlines {'collapsed' if self.get_sbadmin_default_collapsed(request) else ''}",
+                url=request.get_full_path(),
+            )
+        )
+        return actions
+
+
+class SBAdminStackedInline(SBAdminStackedInlineBase, NestedStackedInline):
     template = "sb_admin/inlines/stacked_inline.html"
     fieldset_template = "sb_admin/includes/inline_fieldset.html"
+    formset = SBAdminNestedInlineFormSet
 
 
-class SBAdminGenericStackedInline(SBAdminInline, NestedGenericStackedInline):
+class SBAdminGenericStackedInline(SBAdminStackedInlineBase, NestedGenericStackedInline):
     template = "sb_admin/inlines/stacked_inline.html"
     fieldset_template = "sb_admin/includes/inline_fieldset.html"
+    formset = SBAdminGenericInlineFormSet
+
+
+if parler_enabled:
+
+    class SBTranslatableAdmin(SBAdmin, TranslatableAdmin):
+        def get_readonly_fields(self, request, obj=...):
+            readonly_fields = super().get_readonly_fields(request, obj)
+            if "sbadmin_translation_status" not in readonly_fields:
+                readonly_fields += ("sbadmin_translation_status",)
+            return readonly_fields
+
+        def get_fieldsets(self, request, obj=...):
+            fieldsets = super().get_fieldsets(request, obj)
+            fieldsets.append(SBAdminTranslationsService.get_translation_fieldset())
+            return fieldsets