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

django_smartbase_admin/actions/admin_action_list.py

@@ -427,6 +427,11 @@ class SBAdminListAction(SBAdminAction):
                     data: row.get(data, None)
                     for data in self.view.sbadmin_list_display_data
                 }
+            # Include supporting_annotates values in additional_data
+            for field in visible_columns:
+                if field.supporting_annotates:
+                    for key in field.supporting_annotates.keys():
+                        additional_data[key] = row.get(key, None)
             for field_key, value in row.items():
                 if field_key in field_key_field_map:
                     field = field_key_field_map[field_key]

django_smartbase_admin/admin/widgets.py

@@ -11,7 +11,12 @@ from django.contrib.admin.widgets import (
     ForeignKeyRawIdWidget,
 )
 from django.contrib.auth.forms import ReadOnlyPasswordHashWidget
-from django.core.exceptions import ValidationError, ImproperlyConfigured
+from django.core.exceptions import (
+    FieldDoesNotExist,
+    ImproperlyConfigured,
+    ValidationError,
+)
+from django.db.models import ForeignKey, OneToOneField
 from django.template.loader import render_to_string
 from django.urls import reverse
 from django.utils.formats import get_format
@@ -359,13 +364,19 @@ class SBAdminAutocompleteWidget(
     form = None
     field_name = None
     initialised = None
+    allow_add = None
+    create_value_field = None
     default_create_data = None
+    forward_to_create = 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)
+        self.allow_add = kwargs.pop("allow_add", None)
+        self.create_value_field = kwargs.pop("create_value_field", None)
+        self.forward_to_create = kwargs.pop("forward_to_create", [])
         super().__init__(form_field, *args, **kwargs)
         self.attrs = {} if attrs is None else attrs.copy()
         if self.multiselect and self.allow_add:
@@ -595,6 +606,34 @@ class SBAdminAutocompleteWidget(
 
         return forward_data
 
+    def get_forward_data_to_create(self, request, forward_data):
+        forward_data_to_create = {}
+        for field_name in self.forward_to_create:
+            value = forward_data.get(field_name)
+            if value is None:
+                continue
+            # If forwarding a FK value from the parent form (e.g. for dependent dropdowns),
+            # store it under `<field>_id` so `Model(**kwargs)` accepts the raw PK.
+            store_key = field_name
+            form_model = getattr(getattr(self, "form", None), "model", None)
+            if form_model is not None:
+                try:
+                    form_model_field = form_model._meta.get_field(field_name)
+                except FieldDoesNotExist:
+                    form_model_field = None
+                if isinstance(form_model_field, (ForeignKey, OneToOneField)):
+                    store_key = form_model_field.attname
+
+            forward_data_to_create[store_key] = self.parse_value_from_input(
+                request, value
+            )
+            if not self.is_multiselect():
+                forward_data_to_create[store_key] = next(
+                    iter(forward_data_to_create[store_key]), None
+                )
+
+        return forward_data_to_create
+
     def value_from_datadict(self, data, files, name):
         input_value = super().value_from_datadict(data, files, name)
         threadsafe_request = SBAdminThreadLocalService.get_request()
@@ -630,7 +669,11 @@ class SBAdminAutocompleteWidget(
                 )
                 self.form_field.queryset = qs
                 parsed_value = self.validate(
-                    parsed_value, qs, threadsafe_request, parsed_is_create
+                    parsed_value,
+                    qs,
+                    threadsafe_request,
+                    forward_data,
+                    parsed_is_create,
                 )
 
         return parsed_value
@@ -638,14 +681,18 @@ class SBAdminAutocompleteWidget(
     def should_create_new_obj(self):
         return self.allow_add and self.create_value_field
 
-    def create_new_obj(self, value, queryset, is_create):
+    def create_new_obj(self, value, queryset, request, forward_data):
         if isinstance(value, list):
             # TODO: multiselect creation
             return self.form_field.to_python(value)
         else:
+            forward_data_to_create = self.get_forward_data_to_create(
+                request, forward_data
+            )
             data_to_create = {
                 self.create_value_field: value,
                 **self.default_create_data,
+                **forward_data_to_create,
             }
             new_obj = queryset.model.objects.create(**data_to_create)
             try:
@@ -658,12 +705,12 @@ class SBAdminAutocompleteWidget(
                     params={"value": value},
                 )
 
-    def validate(self, value, queryset, request, is_create=False):
+    def validate(self, value, queryset, request, forward_data, 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)
+            new_object = self.create_new_obj(value, queryset, request, forward_data)
             request.request_data.additional_data[self.REQUEST_CREATED_DATA_KEY] = (
                 request.request_data.additional_data.get(
                     self.REQUEST_CREATED_DATA_KEY, {}

django_smartbase_admin/engine/field_formatter.py

@@ -1,9 +1,10 @@
 from enum import Enum
 
 from django.template.defaultfilters import date, time
+from django.utils import timezone
+from django.utils.html import format_html, format_html_join
 from django.utils.safestring import mark_safe
 from django.utils.translation import gettext_lazy as _
-from django.utils import timezone
 
 
 class BadgeType(Enum):
@@ -39,21 +40,26 @@ def datetime_formatter_with_format(date_format=None, time_format=None):
 
 def boolean_formatter(object_id, value):
     if value:
-        return mark_safe(
-            f'<span class="badge badge-simple badge-positive">{_("Yes")}</span>'
+        return format_html(
+            '<span class="badge badge-simple badge-positive">{}</span>', _("Yes")
         )
-    return mark_safe(f'<span class="badge badge-simple badge-neutral">{_("No")}</span>')
+    return format_html(
+        '<span class="badge badge-simple badge-neutral">{}</span>', _("No")
+    )
 
 
 def format_array(value_list, separator="", badge_type: BadgeType = BadgeType.NOTICE):
-    result = ""
     if not value_list:
-        return result
-    for value in value_list:
-        if not value:
-            continue
-        result += f'<span class="badge badge-simple badge-{badge_type.value} mr-4">{value}</span>{separator}'
-    return mark_safe(result)
+        return ""
+
+    # `separator` is intended to be an internal constant (e.g. "" or "<br>").
+    # We mark it safe so HTML separators render as HTML rather than being escaped.
+    sep = mark_safe(separator) if separator else ""
+    return format_html_join(
+        sep,
+        '<span class="badge badge-simple badge-{} mr-4">{}</span>',
+        ((badge_type.value, value) for value in value_list if value),
+    )
 
 
 def array_badge_formatter(object_id, value_list):
@@ -61,14 +67,18 @@ def array_badge_formatter(object_id, value_list):
 
 
 def newline_separated_array_badge_formatter(object_id, value_list):
-    return mark_safe(f'<div>{format_array(value_list, separator="<br>")}</div>')
+    return format_html("<div>{}</div>", format_array(value_list, separator="<br>"))
 
 
 def rich_text_formatter(object_id, value):
-    return mark_safe(
-        f'<div style="max-width: 500px; white-space: normal;">{value}</div>'
+    # Intentionally renders HTML (e.g. from a rich text editor field).
+    return format_html(
+        '<div style="max-width: 500px; white-space: normal;">{}</div>',
+        mark_safe(value) if value else "",
     )
 
 
 def link_formatter(object_id, value):
-    return mark_safe(f'<a href="{value}">{value}</a>')
+    if not value:
+        return ""
+    return format_html('<a href="{0}">{0}</a>', value)

django_smartbase_admin/engine/filter_widgets.py

@@ -492,7 +492,6 @@ class AutocompleteFilterWidget(
     forward = None
     label_lambda = None
     value_lambda = None
-    allow_add = False
     hide_clear_button = False
     search_query_lambda = None
     create_value_field = None
@@ -515,10 +514,8 @@ class AutocompleteFilterWidget(
         value_lambda=None,
         multiselect=None,
         forward=None,
-        allow_add=None,
         hide_clear_button=None,
         search_query_lambda=None,
-        create_value_field=None,
         **kwargs,
     ) -> None:
         super().__init__(template_name, default_value, **kwargs)
@@ -534,8 +531,6 @@ class AutocompleteFilterWidget(
         self.multiselect = multiselect if multiselect is not None else self.multiselect
         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