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

django_smartbase_admin/engine/field_formatter.py

@@ -1,8 +1,18 @@
+from enum import Enum
+
 from django.template.defaultfilters import date, time
+from django.utils.safestring import mark_safe
 from django.utils.translation import gettext_lazy as _
 from django.utils import timezone
 
 
+class BadgeType(Enum):
+    SUCCESS = "positive"
+    NOTICE = "notice"
+    WARNING = "warning"
+    ERROR = "negative"
+
+
 def datetime_formatter(object_id, value):
     if value is None:
         return None
@@ -12,27 +22,38 @@ def datetime_formatter(object_id, value):
 
 def datetime_formatter_with_format(date_format=None, time_format=None):
     def inner_formatter(object_id, value):
+        if value is None:
+            return None
         value = timezone.localtime(value)
-        return f"{date(value, date_format)} {time(value, time_format)}"
+        return_value = ""
+        if date_format:
+            return_value += date(value, date_format)
+        if time_format:
+            if return_value:
+                return_value += " "
+            return_value += time(value, time_format)
+        return return_value
 
     return inner_formatter
 
 
 def boolean_formatter(object_id, value):
     if value:
-        return f'<span class="badge badge-simple badge-positive">{_("Yes")}</span>'
-    return f'<span class="badge badge-simple badge-neutral">{_("No")}</span>'
+        return mark_safe(
+            f'<span class="badge badge-simple badge-positive">{_("Yes")}</span>'
+        )
+    return mark_safe(f'<span class="badge badge-simple badge-neutral">{_("No")}</span>')
 
 
-def format_array(value_list, separator=""):
+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-notice mr-4">{value}</span>{separator}'
-    return result
+        result += f'<span class="badge badge-simple badge-{badge_type.value} mr-4">{value}</span>{separator}'
+    return mark_safe(result)
 
 
 def array_badge_formatter(object_id, value_list):
@@ -40,12 +61,14 @@ def array_badge_formatter(object_id, value_list):
 
 
 def newline_separated_array_badge_formatter(object_id, value_list):
-    return format_array(value_list, separator="<br>")
+    return mark_safe(f'<div>{format_array(value_list, separator="<br>")}</div>')
 
 
 def rich_text_formatter(object_id, value):
-    return f'<div style="max-width: 500px; white-space: normal;">{value}</div>'
+    return mark_safe(
+        f'<div style="max-width: 500px; white-space: normal;">{value}</div>'
+    )
 
 
 def link_formatter(object_id, value):
-    return f'<a href="{value}">{value}</a>'
+    return mark_safe(f'<a href="{value}">{value}</a>')

django_smartbase_admin/engine/filter_widgets.py

@@ -2,10 +2,11 @@ import json
 from datetime import datetime, timedelta
 
 from django.core.exceptions import ImproperlyConfigured
-from django.db.models import Q, fields, FilteredRelation
+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
-from django.utils.translation import gettext_lazy as _
+from django.utils.translation import gettext_lazy as _, pgettext_lazy
 
 from django_smartbase_admin.actions.advanced_filters import (
     AllOperators,
@@ -20,6 +21,7 @@ from django_smartbase_admin.engine.const import (
     Action,
     AUTOCOMPLETE_PAGE_NUM,
     AUTOCOMPLETE_FORWARD_NAME,
+    SELECT_ALL_KEYWORD,
 )
 from django_smartbase_admin.services.translations import SBAdminTranslationsService
 from django_smartbase_admin.services.views import SBAdminViewService
@@ -44,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
@@ -56,6 +74,7 @@ class SBAdminFilterWidget(JSONSerializableMixin):
     default_value = None
     default_label = None
     filter_query_lambda = None
+    exclude_null_operators = False
 
     def __init__(
         self,
@@ -63,6 +82,7 @@ class SBAdminFilterWidget(JSONSerializableMixin):
         default_value=None,
         default_label=None,
         filter_query_lambda=None,
+        exclude_null_operators=None,
         **kwargs,
     ) -> None:
         super().__init__()
@@ -70,6 +90,9 @@ class SBAdminFilterWidget(JSONSerializableMixin):
         self.default_value = self.default_value or default_value
         self.default_label = self.default_label or default_label
         self.filter_query_lambda = filter_query_lambda or self.filter_query_lambda
+        self.exclude_null_operators = (
+            exclude_null_operators or self.exclude_null_operators
+        )
 
     def init_filter_widget_static(self, field, view, configuration):
         self.field = field
@@ -206,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})
 
 
@@ -215,8 +240,38 @@ class RadioChoiceFilterWidget(ChoiceFilterWidget):
 
 class MultipleChoiceFilterWidget(AutocompleteParseMixin, ChoiceFilterWidget):
     template_name = "sb_admin/filter_widgets/multiple_choice_field.html"
+    enable_select_all = False
+    select_all_keyword = None
+    select_all_label = None
+
+    def __init__(
+        self,
+        choices,
+        template_name=None,
+        default_value=None,
+        default_label=None,
+        enable_select_all=False,
+        select_all_keyword=SELECT_ALL_KEYWORD,
+        select_all_label=_("All"),
+        **kwargs,
+    ) -> None:
+        super().__init__(
+            choices=choices,
+            template_name=template_name,
+            default_value=default_value,
+            default_label=default_label,
+            **kwargs,
+        )
+        self.enable_select_all = enable_select_all
+        self.select_all_keyword = select_all_keyword
+        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):
@@ -279,6 +334,7 @@ class DateFilterWidget(SBAdminFilterWidget):
             "label": _("Last 12 months"),
         },
     ]
+    shortcuts_dict = {AllOperators.IN_THE_LAST.value: shortcuts}
     default_value_shortcut_index = None
 
     def __init__(
@@ -301,33 +357,43 @@ class DateFilterWidget(SBAdminFilterWidget):
     def get_advanced_filter_operators(self):
         return DATE_ATTRIBUTES
 
+    def process_shortcut(self, shortcut, now):
+        return shortcut
+
     def get_shortcuts(self):
         now = timezone.now()
         shortcuts = []
         for shortcut in self.shortcuts:
-            shortcuts.append(
-                {
-                    "label": shortcut["label"],
-                    "value": [
-                        now + timedelta(days=shortcut["value"][0]),
-                        now + timedelta(days=shortcut["value"][1]),
-                    ],
-                }
-            )
+            shortcuts.append(self.process_shortcut(shortcut, now))
+        return shortcuts
+
+    def get_shortcuts_dict(self):
+        now = timezone.now()
+        shortcuts = {}
+        for key, shortcuts_group in self.shortcuts_dict.items():
+            shortcuts[key] = []
+            for shortcut in shortcuts_group:
+                shortcuts[key].append(self.process_shortcut(shortcut, now))
         return shortcuts
 
+    def get_default_label(self):
+        if self.default_value_shortcut_index is not None:
+            return self.get_shortcuts()[self.default_value_shortcut_index]["label"]
+        return super().get_default_value()
+
     def get_default_value(self):
         if self.default_value_shortcut_index is not None:
             selected_shortcut_value = self.get_shortcuts()[
                 self.default_value_shortcut_index
             ]["value"]
-            return self.get_value_from_date_or_range(selected_shortcut_value)
+            return SBAdminViewService.json_dumps_for_url(
+                self.get_value_from_date_or_range(selected_shortcut_value)
+            )
         return super().get_default_value()
 
     def get_data(self):
         return json.dumps(
             {
-                "shortcuts": self.get_shortcuts(),
                 "flatpickrOptions": {
                     "locale": {
                         "rangeSeparator": self.DATE_RANGE_SPLIT,
@@ -337,6 +403,19 @@ class DateFilterWidget(SBAdminFilterWidget):
             cls=SBAdminJSONEncoder,
         )
 
+    def get_shortcuts_data(self):
+        return json.dumps(
+            self.get_shortcuts(),
+            cls=SBAdminJSONEncoder,
+        )
+
+    def get_shortcuts_dict_data(self):
+        # used for advanced filters with different calendar operators "in the last", "in the next", etc.
+        return json.dumps(
+            self.get_shortcuts_dict(),
+            cls=SBAdminJSONEncoder,
+        )
+
     @classmethod
     def is_used_for_model_field_type(cls, model_field):
         return isinstance(model_field, fields.DateField)
@@ -351,12 +430,28 @@ class DateFilterWidget(SBAdminFilterWidget):
         if filter_value is None:
             return [None, None]
         date_format = cls.DATE_FORMAT
-        date_range = filter_value.split(cls.DATE_RANGE_SPLIT)
-        if len(date_range) == 2:
-            date_from = datetime.strptime(date_range[0], date_format)
-            date_to = datetime.strptime(date_range[1], date_format)
-            return [date_from, date_to]
-        else:
+        if type(filter_value) is list:
+            if type(filter_value[0]) is int:
+                return [
+                    timezone.now() + timedelta(days=filter_value[0]),
+                    timezone.now() + timedelta(days=filter_value[1]),
+                ]
+            return [
+                datetime.strptime(filter_value[0], date_format),
+                datetime.strptime(filter_value[1], date_format),
+            ]
+        try:
+            days_range = json.loads(filter_value)
+            return [
+                timezone.now() + timedelta(days=days_range[0]),
+                timezone.now() + timedelta(days=days_range[1]),
+            ]
+        except json.decoder.JSONDecodeError:
+            date_range = filter_value.split(cls.DATE_RANGE_SPLIT)
+            if len(date_range) == 2:
+                date_from = datetime.strptime(date_range[0], date_format)
+                date_to = datetime.strptime(date_range[1], date_format)
+                return [date_from, date_to]
             date_value = datetime.strptime(filter_value, date_format)
             return [date_value, date_value]
 
@@ -364,9 +459,11 @@ class DateFilterWidget(SBAdminFilterWidget):
     def get_value_from_date_or_range(cls, date_or_range):
         if not isinstance(date_or_range, list):
             return datetime.strftime(date_or_range, cls.DATE_FORMAT)
+        if type(date_or_range[0]) is int:
+            return date_or_range
         date_from = datetime.strftime(date_or_range[0], cls.DATE_FORMAT)
         date_to = datetime.strftime(date_or_range[1], cls.DATE_FORMAT)
-        return f"{date_from}{cls.DATE_RANGE_SPLIT}{date_to}"
+        return [date_from, date_to]
 
     def parse_value_from_input(self, request, filter_value):
         return self.get_range_from_value(filter_value)
@@ -398,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
@@ -420,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
@@ -434,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
@@ -542,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)
             )
@@ -555,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,
@@ -566,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,
@@ -593,6 +704,8 @@ class AutocompleteFilterWidget(
     def get_label(self, request, item):
         if self.label_lambda:
             return self.label_lambda(request, item)
+        if isinstance(item, list):
+            return ", ".join(map(str, item))
         return str(item)
 
     def get_context(self, name, value, attrs):
@@ -611,3 +724,225 @@ class AutocompleteFilterWidget(
             AllOperators.IS_NULL,
             AllOperators.IS_NOT_NULL,
         ]
+
+
+class FromValuesAutocompleteWidget(AutocompleteFilterWidget):
+    def init_filter_widget_static(self, field, view, configuration):
+        self.model = field.view.model
+        super().init_filter_widget_static(field, view, configuration)
+
+    def get_queryset(self, request=None):
+        qs = super().get_queryset(request)
+        qs = qs.annotate(**self.field.get_field_annotates(values=[]))
+        return qs
+
+    def search(self, request, post_data):
+        search_term = post_data.get(AUTOCOMPLETE_SEARCH_NAME)
+        forward_data = json.loads(post_data.get(AUTOCOMPLETE_FORWARD_NAME, "{}"))
+        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
+        qs = self.get_queryset(request)
+        qs = self.filter_search_queryset(request, qs, search_term, forward_data)
+        qs = (
+            qs.filter(**{f"{self.field.name}__icontains": search_term})
+            .values(self.field.name)
+            .annotate(remove_duplicates_count=Count(self.field.name))
+            .order_by(self.field.name)[from_item:to_item]
+        )
+        result = []
+        for item in qs:
+            result.append(
+                {
+                    "value": self.get_value(request, item),
+                    "label": self.get_label(request, item),
+                }
+            )
+        return result
+
+    def get_value(self, request, item):
+        return item.get(self.field.name)
+
+    def get_label(self, request, item):
+        return item.get(self.field.name)
+
+
+class SBAdminTreeWidgetMixin:
+    order_by = None
+    inline = False
+    RELATIONSHIP_PICK_MODE_NONE = None
+    RELATIONSHIP_PICK_MODE_PARENT = "parent"
+    relationship_pick_mode = RELATIONSHIP_PICK_MODE_NONE
+    additional_columns = None
+    tree_strings = {
+        "loading": pgettext_lazy("Tree widget", "Loading..."),
+        "loadError": pgettext_lazy("Tree widget", "Load error!"),
+        "moreData": pgettext_lazy("Tree widget", "More..."),
+        "noData": pgettext_lazy("Tree widget", "No data."),
+    }
+    model = None
+    path_field = "path"
+
+    def __init__(
+        self,
+        order_by=None,
+        relationship_pick_mode=None,
+        inline=None,
+        additional_columns=None,
+        tree_strings=None,
+        *args,
+        **kwargs,
+    ):
+        self.inline = inline if inline is not None else self.inline
+        self.order_by = order_by if order_by is not None else self.order_by
+        self.relationship_pick_mode = relationship_pick_mode
+        self.additional_columns = (
+            additional_columns
+            if additional_columns is not None
+            else self.additional_columns
+        )
+        self.tree_strings = (
+            tree_strings if tree_strings is not None else self.tree_strings
+        )
+        if self.inline:
+            self.template_name = "sb_admin/widgets/tree_select_inline.html"
+        super().__init__(*args, **kwargs)
+
+    def action_autocomplete(self, request, modifier):
+        result = self.format_tree_data(request, self.get_queryset(request))
+        return JsonResponse(data=result, safe=False)
+
+    def format_tree_data(self, request, queryset):
+        self_id = None
+        if self.relationship_pick_mode == self.RELATIONSHIP_PICK_MODE_PARENT:
+            # disable selecting self and children if selecting parent
+            self_id = self.form.instance.id if self.form.instance else None
+        return self.get_tree_data(request, queryset, self_id=self_id)
+
+    @classmethod
+    def get_tree_base_values(cls):
+        return ["id", cls.path_field]
+
+    @classmethod
+    def get_tree_key(cls, request, item):
+        return item.get(cls.path_field)
+
+    @classmethod
+    def get_tree_title(cls, request, item):
+        raise NotImplementedError
+
+    @classmethod
+    def get_value(cls, request, item):
+        return getattr(item, cls.path_field)
+
+    @classmethod
+    def get_label(cls, request, item):
+        raise NotImplementedError
+
+    @classmethod
+    def tree_process_global_data(cls, request, queryset, **kwargs):
+        return {}
+
+    @classmethod
+    def get_additional_data(cls, request, item, tree_process_global_data):
+        return {}
+
+    @classmethod
+    def get_tree_data(cls, request, queryset, values=None, self_id=None, **kwargs):
+        tree_values = cls.get_tree_base_values()
+        tree_values.extend(values if values else [])
+
+        queryset = queryset.order_by(*cls.order_by)
+        queryset = queryset.annotate(
+            **SBAdminViewService.get_annotates(cls.model, tree_values, [])
+        )
+        flat_data = []
+        tree_data, lnk = [], {}
+        tree_process_global_data = cls.tree_process_global_data(
+            request, queryset, **kwargs
+        )
+
+        data = list(queryset.values(*tree_values))
+        for item in data:
+            path = item.get("path")
+            depth = int(len(path) / cls.model.steplen)
+            item_id = cls.get_tree_key(request, item)
+            item_label = cls.get_tree_title(request, item)
+            newobj = {
+                "title": item_label,
+                "key": str(item_id),
+                "data": {"id": item.get("id")},
+            }
+            if item_id == self_id:
+                # disable selecting self and children if selecting parent
+                newobj["checkbox"] = False
+
+            additional_data = cls.get_additional_data(
+                request, item, tree_process_global_data
+            )
+            newobj.update(additional_data)
+
+            if depth == 1:
+                tree_data.append(newobj)
+                flat_data.append(newobj)
+            else:
+                parentpath = cls.model._get_basepath(path, depth - 1)
+                parentobj = lnk[parentpath]
+                if "children" not in parentobj:
+                    parentobj["children"] = []
+                if parentobj.get("checkbox") is False:
+                    # disable selecting self and children if selecting parent
+                    newobj["checkbox"] = False
+                parentobj["children"].append(newobj)
+                flat_data.append(newobj)
+            lnk[path] = newobj
+        return tree_data
+
+    # tree_widget_data: [{"key":"path", "children": [{...}]}]
+    @classmethod
+    def process_treebeard_tree(
+        cls,
+        tree_widget_data,
+        treebeard_objs_by_path,
+        depth=1,
+        parent_path="",
+        path_base="",
+    ):
+        if not path_base:
+            path_base = ((cls.model.steplen - 1) * "0") + "1"
+        previous = None
+        objs_to_update = []
+        for tree_widget_node in tree_widget_data:
+            treebeard_obj = treebeard_objs_by_path.get(tree_widget_node["key"])
+            old_depth = treebeard_obj.depth
+            old_path = getattr(treebeard_obj, cls.path_field)
+            old_numchild = treebeard_obj.numchild
+            treebeard_obj.depth = depth
+            if not previous:
+                previous = treebeard_obj
+                setattr(treebeard_obj, cls.path_field, parent_path + path_base)
+            else:
+                setattr(treebeard_obj, cls.path_field, previous._inc_path())
+                previous = treebeard_obj
+            children = tree_widget_node.get("children", [])
+            treebeard_obj.numchild = len(children)
+            if (
+                treebeard_obj.depth != old_depth
+                or getattr(treebeard_obj, cls.path_field) != old_path
+                or treebeard_obj.numchild != old_numchild
+            ):
+                objs_to_update.append(treebeard_obj)
+            objs_to_update.extend(
+                cls.process_treebeard_tree(
+                    children,
+                    treebeard_objs_by_path,
+                    depth + 1,
+                    getattr(treebeard_obj, cls.path_field),
+                    path_base,
+                )
+            )
+        return objs_to_update
+
+
+class SBAdminTreeFilterWidget(SBAdminTreeWidgetMixin, AutocompleteFilterWidget):
+    template_name = "sb_admin/filter_widgets/tree_select_filter.html"

django_smartbase_admin/engine/menu_item.py

@@ -56,11 +56,14 @@ class SBAdminMenuItem(object):
         return self.label or self.view.get_menu_label()
 
     def get_url(self, request):
-        return (
-            self.url
-            or (self.view.get_menu_view_url(request) if self.view else None)
-            or ""
-        )
+        if callable(self.url):
+            return self.url(request)
+        elif self.url:
+            return self.url
+        elif self.view:
+            return self.view.get_menu_view_url(request)
+        else:
+            return ""
 
     def get_icon(self):
         return self.icon or getattr(self.view, "icon", None)