django-smartbase-admin 1.0.32__py3-none-any.whl → 1.0.34__py3-none-any.whl

django_smartbase_admin/admin/admin_base.py

@@ -4,6 +4,7 @@ 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
@@ -30,7 +31,7 @@ from django.forms.models import (
 from django.http import HttpResponse
 from django.template.loader import render_to_string
 from django.template.response import TemplateResponse
-from django.urls import reverse, NoReverseMatch
+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 _
@@ -126,6 +127,7 @@ from django_smartbase_admin.engine.admin_base_view import (
     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,
@@ -316,6 +318,13 @@ class SBAdminBaseFormInit(SBAdminFormFieldWidgetsMixin, FormFieldsetMixin):
             "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
@@ -324,12 +333,8 @@ class SBAdminBaseFormInit(SBAdminFormFieldWidgetsMixin, FormFieldsetMixin):
                 self.fields[field],
                 field,
                 self.view,
-                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=threadsafe_request)
 
 
 class SBAdminBaseForm(SBAdminBaseFormInit, forms.ModelForm):
@@ -822,7 +827,14 @@ class SBAdmin(
         return Q()
 
     def get_change_view_context(self, request, object_id) -> dict | dict[str, Any]:
-        return {"show_back_button": True}
+        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:
@@ -958,7 +970,7 @@ class SBAdmin(
                 "field": request.POST.get("sb_admin_source_field"),
                 "id": obj.pk,
                 "label": str(obj),
-                "reload": request.POST.get("sbadmin_reload_on_save") == "1",
+                "reload": request.POST.get(SBADMIN_RELOAD_ON_SAVE_VAR) == "1",
             },
         )
         trigger_client_event(response, "hideModal", {"elt": "sb-admin-modal"})
@@ -1051,6 +1063,31 @@ class SBAdminInline(
         self.initialize_form_class(form_class, request)
         form_class()
 
+    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)

django_smartbase_admin/admin/widgets.py

@@ -1,5 +1,6 @@
 import json
 import logging
+import sys
 
 from ckeditor.widgets import CKEditorWidget
 from ckeditor_uploader.widgets import CKEditorUploadingWidget
@@ -10,7 +11,7 @@ from django.contrib.admin.widgets import (
     ForeignKeyRawIdWidget,
 )
 from django.contrib.auth.forms import ReadOnlyPasswordHashWidget
-from django.core.exceptions import ValidationError
+from django.core.exceptions import ValidationError, ImproperlyConfigured
 from django.template.loader import render_to_string
 from django.urls import reverse
 from django.utils.formats import get_format
@@ -358,11 +359,19 @@ class SBAdminAutocompleteWidget(
     form = None
     field_name = None
     initialised = None
+    default_create_data = None
+    reload_on_save = None
+    REQUEST_CREATED_DATA_KEY = "autocomplete_created_data"
 
     def __init__(self, form_field=None, *args, **kwargs):
         attrs = kwargs.pop("attrs", None)
+        self.reload_on_save = kwargs.pop("reload_on_save", False)
         super().__init__(form_field, *args, **kwargs)
         self.attrs = {} if attrs is None else attrs.copy()
+        if self.multiselect and self.allow_add:
+            raise ImproperlyConfigured(
+                "Multiselect with creation is currently not supported."
+            )
 
     def get_id(self):
         base_id = super().get_id()
@@ -370,7 +379,9 @@ class SBAdminAutocompleteWidget(
             base_id += f"_{self.form.__class__.__name__}"
         return base_id
 
-    def init_widget_dynamic(self, form, form_field, field_name, view, request):
+    def init_widget_dynamic(
+        self, form, form_field, field_name, view, request, default_create_data=None
+    ):
         super().init_widget_dynamic(form, form_field, field_name, view, request)
         if self.initialised:
             return
@@ -378,6 +389,7 @@ class SBAdminAutocompleteWidget(
         self.field_name = field_name
         self.view = view
         self.form = form
+        self.default_create_data = default_create_data or {}
         self.init_autocomplete_widget_static(
             self.field_name,
             self.model,
@@ -416,20 +428,50 @@ class SBAdminAutocompleteWidget(
         parsed_value = None
         if value:
             parsed_value = self.parse_value_from_input(threadsafe_request, value)
+            is_create = self.parse_is_create_from_input(
+                threadsafe_request,
+                threadsafe_request.request_data.request_post.get(name),
+            )
+            selected_options = []
+            if is_create:
+                errors = getattr(self.form, "errors", {})
+                if errors.get(self.field_name):
+                    parsed_value = None
             if parsed_value:
-                selected_options = []
-                for item in self.get_queryset(threadsafe_request).filter(
-                    **{f"{self.get_value_field()}{query_suffix}": parsed_value}
-                ):
-                    selected_options.append(
-                        {
-                            "value": self.get_value(threadsafe_request, item),
-                            "label": self.get_label(threadsafe_request, item),
-                        }
-                    )
-
-                context["widget"]["value"] = json.dumps(selected_options)
-                context["widget"]["value_list"] = selected_options
+                if self.is_multiselect() and not isinstance(parsed_value, list):
+                    parsed_value = [parsed_value]
+
+                try:
+                    for item in self.get_queryset(threadsafe_request).filter(
+                        **{f"{self.get_value_field()}{query_suffix}": parsed_value}
+                    ):
+                        selected_options.append(
+                            {
+                                "value": self.get_value(threadsafe_request, item),
+                                "label": self.get_label(threadsafe_request, item),
+                            }
+                        )
+                except ValueError as e:
+                    new_object_id = threadsafe_request.request_data.additional_data.get(
+                        self.REQUEST_CREATED_DATA_KEY, {}
+                    ).get(self.field_name)
+                    if new_object_id:
+                        selected_options.append(
+                            {
+                                "value": new_object_id,
+                                "label": value,
+                            }
+                        )
+                    elif hasattr(self.form, "add_error"):
+                        self.form.add_error(
+                            self.field_name,
+                            _(
+                                "The new value was created but became unselected due to another validation error. Please select it again."
+                            ),
+                        )
+
+            context["widget"]["value"] = json.dumps(selected_options)
+            context["widget"]["value_list"] = selected_options
 
         if (
             threadsafe_request.request_data.configuration.autocomplete_show_related_buttons(
@@ -441,6 +483,7 @@ class SBAdminAutocompleteWidget(
             and not self.is_multiselect()
         ):
             self.add_related_buttons_urls(parsed_value, threadsafe_request, context)
+            context["reload_on_save"] = self.reload_on_save
 
         return context
 
@@ -472,13 +515,165 @@ class SBAdminAutocompleteWidget(
         model_field = getattr(self.field, "model_field", None)
         return not (model_field and (model_field.one_to_one or model_field.many_to_one))
 
+    def _is_in_validation_context(self):
+        """
+        Check if value_from_datadict is being called during form validation
+        (full_clean, _clean_fields, etc.) vs. during change detection by formsets.
+
+        Returns True if called during actual validation, False if called during
+        change detection or other non-validation contexts.
+
+        Uses sys._getframe() instead of inspect.currentframe() for better performance,
+        as this method is called frequently during form processing.
+        """
+        # Get the call stack - using sys._getframe() for better performance
+        # sys._getframe(1) gets the caller's frame (skipping this method)
+        try:
+            current_frame = sys._getframe(1)
+        except ValueError:
+            # Fallback if _getframe is not available (unlikely in CPython)
+            return False
+
+        # Look for validation-related methods in the call stack
+        validation_methods = {
+            "_clean_bound_field",
+        }
+
+        # Walk up the call stack
+        depth = 0
+        while current_frame and depth < 5:  # Limit depth to avoid infinite loops
+            method_name = current_frame.f_code.co_name
+            if method_name in validation_methods:
+                return True
+            current_frame = current_frame.f_back
+            depth += 1
+
+        return False
+
+    def get_forward_data(self, request, name):
+        """
+        Parse forward data from request.request_data.request_post.
+
+        For each field in self.forward, use name as base field name and replace
+        in it current field name with forward field name, return dict.
+
+        Args:
+            request: The request object
+            name: The base field name (e.g., "product__category")
+
+        Returns:
+            dict: Forward data with keys being forward field names and values
+                  from request data
+        """
+        forward_data = {}
+        if not getattr(self, "forward", None):
+            return forward_data
+
+        post_data = getattr(request.request_data, "request_post", {})
+        if not post_data:
+            return forward_data
+
+        # For each field in self.forward list
+        for forward_field in self.forward:
+            # Replace only from end of name, separated by last -
+            # Example: if name="prefix-field_name", self.field_name="field_name",
+            # forward_field="parent" -> result="prefix-parent"
+            name_parts = name.split("-")
+
+            # Replace only if the last part matches self.field_name
+            if name_parts and name_parts[-1] == self.field_name:
+                # Replace the last part with forward_field and join back
+                name_parts[-1] = forward_field
+                forward_field_name = "-".join(name_parts)
+            else:
+                # If last part doesn't match, don't create forward field name
+                continue
+
+            # Get value from post_data if it exists
+            if forward_field_name in post_data:
+                forward_data[forward_field] = post_data.get(forward_field_name)
+
+        return forward_data
+
     def value_from_datadict(self, data, files, name):
         input_value = super().value_from_datadict(data, files, name)
         threadsafe_request = SBAdminThreadLocalService.get_request()
         parsed_value = self.parse_value_from_input(threadsafe_request, input_value)
         if parsed_value is None:
             return parsed_value
-        return parsed_value if self.is_multiselect() else next(iter(parsed_value), None)
+
+        if not self.is_multiselect():
+            parsed_value = next(iter(parsed_value), None)
+
+        # Only perform validation during actual form cleaning, not during change detection
+        # by inline formsets or during HTML rendering
+        is_in_validation = self._is_in_validation_context()
+        if is_in_validation:
+            try:
+                has_changed = self.form_field.has_changed(
+                    self.form.initial.get(self.field_name, None), parsed_value
+                )
+            except AttributeError:
+                has_changed = False
+            if has_changed:
+                parsed_is_create = self.parse_is_create_from_input(
+                    threadsafe_request, input_value
+                )
+                if not self.is_multiselect():
+                    parsed_is_create = next(iter(parsed_is_create), None)
+                base_qs = self.get_queryset(threadsafe_request)
+                forward_data = self.get_forward_data(threadsafe_request, name)
+                qs = self.filter_search_queryset(
+                    threadsafe_request,
+                    base_qs,
+                    forward_data=forward_data,
+                )
+                self.form_field.queryset = qs
+                parsed_value = self.validate(
+                    parsed_value, qs, threadsafe_request, parsed_is_create
+                )
+
+        return parsed_value
+
+    def should_create_new_obj(self):
+        return self.allow_add and self.create_value_field
+
+    def create_new_obj(self, value, queryset, is_create):
+        if isinstance(value, list):
+            # TODO: multiselect creation
+            return self.form_field.to_python(value)
+        else:
+            data_to_create = {
+                self.create_value_field: value,
+                **self.default_create_data,
+            }
+            new_obj = queryset.model.objects.create(**data_to_create)
+            try:
+                return self.form_field.to_python(new_obj.id)
+            except ValidationError:
+                new_obj.delete()
+                raise ValidationError(
+                    self.form_field.error_messages["invalid_choice"],
+                    code="invalid_choice",
+                    params={"value": value},
+                )
+
+    def validate(self, value, queryset, request, is_create=False):
+        is_create_value = (
+            True in is_create if isinstance(is_create, list) else is_create
+        )
+        if is_create_value and self.should_create_new_obj():
+            new_object = self.create_new_obj(value, queryset, is_create)
+            request.request_data.additional_data[self.REQUEST_CREATED_DATA_KEY] = (
+                request.request_data.additional_data.get(
+                    self.REQUEST_CREATED_DATA_KEY, {}
+                )
+            )
+            request.request_data.additional_data[self.REQUEST_CREATED_DATA_KEY][
+                self.field_name
+            ] = new_object.pk
+            return new_object
+        return self.form_field.to_python(value)
 
     @classmethod
     def apply_to_model_field(cls, model_field):

django_smartbase_admin/engine/configuration.py

@@ -99,7 +99,7 @@ class SBAdminRoleConfiguration(metaclass=Singleton):
 
             for name, view in plugin_pool.plugins.items():
                 if hasattr(view, "get_id"):
-                    view_instance = view()
+                    view_instance = view(view.model, sb_admin_site)
                     self.view_map[view_instance.get_id()] = view_instance
                     view_instance.init_view_static(
                         self, view_instance.model, sb_admin_site

django_smartbase_admin/engine/filter_widgets.py

@@ -2,6 +2,7 @@ import json
 from datetime import datetime, timedelta
 
 from django.core.exceptions import ImproperlyConfigured
+from django.contrib.postgres.fields import ArrayField
 from django.db.models import Q, fields, FilteredRelation, Count
 from django.http import JsonResponse
 from django.utils import timezone
@@ -45,6 +46,22 @@ class AutocompleteParseMixin:
             value = input_value
         return value
 
+    def parse_is_create_from_input(self, request, input_value):
+        try:
+            input_value = json.loads(input_value)
+        except:
+            pass
+        if isinstance(input_value, list):
+            value = []
+            for data in input_value:
+                if type(data) is dict:
+                    value.append(data.get("create", False))
+                else:
+                    value.append(False)
+        else:
+            value = False
+        return value
+
 
 class SBAdminFilterWidget(JSONSerializableMixin):
     template_name = None
@@ -212,6 +229,8 @@ class ChoiceFilterWidget(SBAdminFilterWidget):
             return found_label[0] if found_label else default_value
 
     def get_base_filter_query_for_parsed_value(self, request, filter_value):
+        if isinstance(self.model_field, ArrayField):
+            return Q(**{f"{self.field.filter_field}__contains": [filter_value]})
         return Q(**{self.field.filter_field: filter_value})
 
 
@@ -248,6 +267,11 @@ class MultipleChoiceFilterWidget(AutocompleteParseMixin, ChoiceFilterWidget):
         self.select_all_label = select_all_label
 
     def get_base_filter_query_for_parsed_value(self, request, filter_value):
+        if isinstance(self.model_field, ArrayField):
+            q_objects = Q()
+            for value in filter_value:
+                q_objects |= Q(**{f"{self.field.filter_field}__contains": [value]})
+            return q_objects
         return Q(**{f"{self.field.filter_field}__in": filter_value})
 
     def get_advanced_filter_operators(self):
@@ -471,6 +495,7 @@ class AutocompleteFilterWidget(
     allow_add = False
     hide_clear_button = False
     search_query_lambda = None
+    create_value_field = None
 
     def get_field_name(self):
         return self.field.name
@@ -493,13 +518,16 @@ class AutocompleteFilterWidget(
         allow_add=None,
         hide_clear_button=None,
         search_query_lambda=None,
+        create_value_field=None,
         **kwargs,
     ) -> None:
         super().__init__(template_name, default_value, **kwargs)
         self.model = model or self.model
         self.value_field = value_field or self.value_field
         self.filter_query_lambda = filter_query_lambda or self.filter_query_lambda
+        # filters queryset to search in
         self.filter_search_lambda = filter_search_lambda or self.filter_search_lambda
+        # defines fields to search on
         self.search_query_lambda = search_query_lambda or self.search_query_lambda
         self.label_lambda = label_lambda or self.label_lambda
         self.value_lambda = value_lambda or self.value_lambda
@@ -507,6 +535,7 @@ class AutocompleteFilterWidget(
         self.multiselect = self.multiselect if self.multiselect is not None else True
         self.forward = forward or self.forward
         self.allow_add = allow_add or self.allow_add
+        self.create_value_field = create_value_field or self.create_value_field
         self.hide_clear_button = (
             hide_clear_button
             if hide_clear_button is not None
@@ -615,8 +644,9 @@ class AutocompleteFilterWidget(
     def get_value_field(self):
         return self.value_field or self.model._meta.pk.name
 
-    def filter_search_queryset(self, request, qs, search_term, forward_data):
+    def filter_search_queryset(self, request, qs, search_term="", forward_data=None):
         if self.filter_search_lambda:
+            forward_data = forward_data or {}
             qs = qs.filter(
                 self.filter_search_lambda(request, search_term, forward_data)
             )
@@ -628,9 +658,16 @@ class AutocompleteFilterWidget(
         page_num = int(post_data.get(AUTOCOMPLETE_PAGE_NUM, 1))
         from_item = (page_num - 1) * AUTOCOMPLETE_PAGE_SIZE
         to_item = (page_num) * AUTOCOMPLETE_PAGE_SIZE
+
+        # filter queryset
+        # base restricted queryset
         qs = self.get_queryset(request)
+        # filters queryset to search in, uses filter_search_lambda
         qs = self.filter_search_queryset(request, qs, search_term, forward_data)
+
+        # search in queryset
         if self.search_query_lambda:
+            # defines fields to search on
             qs = self.search_query_lambda(
                 request,
                 qs,
@@ -639,6 +676,7 @@ class AutocompleteFilterWidget(
                 SBAdminTranslationsService.get_main_lang_code(),
             )
         else:
+            # defines default fields to search on - all char fields
             qs = self.get_default_search_query(
                 request,
                 qs,

django_smartbase_admin/engine/request.py

@@ -20,6 +20,7 @@ class SBAdminViewRequestData(object):
     configuration = None
     selected_view = None
     session = None
+    additional_data = None
 
     def __init__(
         self,
@@ -47,6 +48,7 @@ class SBAdminViewRequestData(object):
         self.request_method = request_method
         self.global_filter = global_filter or {}
         self.session = session or {}
+        self.additional_data = {}
 
     def refresh_selected_view(self, request):
         self.configuration = SBAdminConfigurationService.get_configuration(self)

django_smartbase_admin/services/views.py

@@ -141,7 +141,7 @@ class SBAdminViewService(object):
         )
 
     @classmethod
-    def has_permission(cls, request, view, model=None, obj=None, permission=None):
+    def has_permission(cls, request, view=None, model=None, obj=None, permission=None):
         return request.request_data.configuration.has_permission(
             request, request.request_data, view, model, obj, permission
         )
@@ -154,8 +154,9 @@ class SBAdminViewService(object):
         request_data,
         global_filter=True,
         global_filter_data_map=None,
+        qs=None,
     ):
-        qs = model.objects.all()
+        qs = qs or model.objects.all()
         if global_filter:
             qs = cls.apply_global_filter_to_queryset(
                 qs, request, request_data, global_filter_data_map