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

django_smartbase_admin/actions/admin_action_list.py

@@ -1,12 +1,14 @@
+from __future__ import annotations
 import json
 import math
+from typing import Any, TYPE_CHECKING
 
-from django.core.paginator import Paginator
 from django.db.models import Q
 from django.utils import timezone
+from django.utils.html import escape
+from django.utils.safestring import SafeString
 from django.utils.text import smart_split, unescape_string_literal
 
-from django_smartbase_admin.engine.actions import SBAdminAction
 from django_smartbase_admin.engine.const import (
     XLSX_PAGE_CHUNK_SIZE,
     SELECTED_ROWS_KWARG_NAME,
@@ -32,8 +34,8 @@ from django_smartbase_admin.engine.const import (
     CONFIG_NAME,
     TABLE_PARAMS_FULL_TEXT_SEARCH,
     TABLE_PARAMS_SELECTED_FILTER_TYPE,
-    FilterVersions,
     ADVANCED_FILTER_DATA_NAME,
+    IGNORE_LIST_SELECTION,
 )
 from django_smartbase_admin.services.views import SBAdminViewService
 from django_smartbase_admin.utils import import_with_injection
@@ -42,6 +44,19 @@ QueryBuilderService = import_with_injection(
     "django_smartbase_admin.actions.advanced_filters", "QueryBuilderService"
 )
 
+if TYPE_CHECKING:
+    from django_smartbase_admin.engine.field import SBAdminField
+
+
+class SBAdminAction(object):
+    view = None
+    threadsafe_request = None
+
+    def __init__(self, view, request) -> None:
+        super().__init__()
+        self.view = view
+        self.threadsafe_request = request
+
 
 class SBAdminListAction(SBAdminAction):
     def __init__(
@@ -58,19 +73,12 @@ class SBAdminListAction(SBAdminAction):
             self.all_params = json.loads(
                 request.request_data.request_get.get(BASE_PARAMS_NAME, "{}")
             )
-            if request.request_data.request_method == "GET":
-                source_data = request.request_data.request_get.get(
-                    BASE_PARAMS_NAME, "{}"
-                )
-            elif request.request_data.request_method == "POST":
-                if request.headers.get("X-TabulatorRequest", None) == "true":
-                    source_data = request.body
-                else:
-                    source_data = request.request_data.request_post.get(
-                        BASE_PARAMS_NAME, "{}"
-                    )
-            else:
-                source_data = "{}"
+            source_data = request.request_data.request_get.get(BASE_PARAMS_NAME, "{}")
+            if (
+                request.request_data.request_method == "POST"
+                and request.headers.get("X-TabulatorRequest", None) == "true"
+            ):
+                source_data = request.body
             try:
                 self.all_params = json.loads(source_data)
             except json.JSONDecodeError:
@@ -90,7 +98,7 @@ class SBAdminListAction(SBAdminAction):
         )
         self.deselected_rows = self.selection_data.get(DESELECTED_ROWS_KWARG_NAME, [])
         self.page_size = page_size or self.table_params.get(
-            TABLE_PARAMS_SIZE_NAME, self.view.get_list_per_page()
+            TABLE_PARAMS_SIZE_NAME, self.view.get_list_per_page(request)
         )
         self.init_column_fields()
         self.tabulator_definition = tabulator_definition
@@ -139,11 +147,6 @@ class SBAdminListAction(SBAdminAction):
             if field.field in values
         ]
 
-    def is_jquery_required(self, request):
-        return (
-            self.view.get_filters_version(request) == FilterVersions.FILTERS_VERSION_2
-        )
-
     def get_template_data(self):
         context_data = self.view.get_context_data(self.threadsafe_request)
         constants = {
@@ -182,7 +185,9 @@ class SBAdminListAction(SBAdminAction):
         tabulator_definition["tableIdColumnName"] = id_column_name
         tabulator_definition["constants"] = constants
 
-        list_actions = self.list_actions or self.view._get_sbadmin_list_actions()
+        list_actions = self.list_actions or self.view._get_sbadmin_list_actions(
+            self.threadsafe_request
+        )
 
         context_data.update(
             {
@@ -190,7 +195,6 @@ class SBAdminListAction(SBAdminAction):
                 "tabulator_definition": tabulator_definition,
                 "id_column_name": id_column_name,
                 "filters": self.get_filters(),
-                "is_jquery_required": self.is_jquery_required(self.threadsafe_request),
                 "advanced_filters_data": QueryBuilderService.get_advanced_filters_context_data(
                     self
                 ),
@@ -201,16 +205,18 @@ class SBAdminListAction(SBAdminAction):
                     self.threadsafe_request
                 ),
                 "search_fields": self.view.get_search_fields(self.threadsafe_request),
-                "search_field_placeholder": self.view.get_search_field_placeholder(),
-                "list_actions": self.view.process_actions_permissions(
+                "search_field_placeholder": self.view.get_search_field_placeholder(
+                    self.threadsafe_request
+                ),
+                "list_actions": self.view.process_actions(
                     self.threadsafe_request, list_actions
                 ),
                 "list_selection_actions": self.view.get_sbadmin_list_selection_actions_grouped(
                     self.threadsafe_request
                 ),
-                "config_url": self.view.get_config_url(),
+                "config_url": self.view.get_config_url(self.threadsafe_request),
                 "new_url": (
-                    self.view.get_new_url()
+                    self.view.get_new_url(self.threadsafe_request)
                     if self.view.has_add_permission(self.threadsafe_request)
                     else None
                 ),
@@ -224,9 +230,23 @@ class SBAdminListAction(SBAdminAction):
         for sort in self.table_params.get("sort", []):
             order_by.append(f"{'-' if sort['dir'] == 'desc' else ''}{sort['field']}")
         if len(order_by) == 0:
-            order_by = self.view.get_list_ordering() or [self.get_pk_field().name]
+            order_by = self.view.get_list_ordering(self.threadsafe_request) or [
+                self.get_pk_field().name
+            ]
         return order_by
 
+    def get_order_by_fields_from_request(self):
+        order_by = self.get_order_by_from_request()
+        order_by_fields = []
+        order_by_fields_names = set()
+        for field in order_by:
+            field_name = field[1:] if field.startswith("-") else field
+            order_by_fields_names.add(field_name)
+        for field in self.column_fields:
+            if field.name in order_by_fields_names:
+                order_by_fields.append(field)
+        return order_by_fields
+
     def get_filter_from_request(self):
         base_filters = SBAdminViewService.get_filter_from_request(
             self.threadsafe_request, self.column_fields, self.filter_data
@@ -253,6 +273,7 @@ class SBAdminListAction(SBAdminAction):
         filter_fields.extend(
             QueryBuilderService.get_filters_fields_for_list_action(self)
         )
+        filter_fields.extend(self.get_order_by_fields_from_request())
         if self.is_search_query():
             search_fields = self.get_search_fields(self.threadsafe_request)
             filter_fields.extend(search_fields)
@@ -271,7 +292,7 @@ class SBAdminListAction(SBAdminAction):
             **self.get_annotates(visible_fields)
         )
 
-    def get_visible_column_fields(self):
+    def get_visible_column_fields(self) -> list[SBAdminField]:
         columns_data_dict = self.columns_data.get(COLUMNS_DATA_COLUMNS_NAME, {})
         return [
             field
@@ -288,8 +309,15 @@ class SBAdminListAction(SBAdminAction):
         values = [self.get_pk_field().name]
         visible_column_fields = self.get_visible_column_fields()
         values.extend([field.field for field in visible_column_fields])
+        # Include supporting_annotates keys for visible columns
+        for field in visible_column_fields:
+            if field.supporting_annotates:
+                values.extend(field.supporting_annotates.keys())
         if self.view.sbadmin_list_display_data:
             values.extend(self.view.sbadmin_list_display_data)
+        values.extend(
+            [field.field for field in self.get_order_by_fields_from_request()]
+        )
         return values
 
     def get_search_results(self, request, queryset, search_term):
@@ -386,32 +414,28 @@ class SBAdminListAction(SBAdminAction):
             "last_row": total_count,
         }
 
-    def process_final_data(self, final_data):
+    def process_final_data(self, final_data: list[dict[str, Any]]) -> None:
         visible_columns = self.get_visible_column_fields()
-        fields_with_methods_to_call = [
-            field
-            for field in visible_columns
-            if field.view_method or field.python_formatter
-        ]
+        field_key_field_map: dict[str, SBAdminField] = {
+            field.field: field for field in visible_columns
+        }
         for row in final_data:
+            obj_id = row.get(self.get_pk_field().name, None)
             additional_data = {}
             if self.view.sbadmin_list_display_data:
                 additional_data = {
                     data: row.get(data, None)
                     for data in self.view.sbadmin_list_display_data
                 }
-            for field in fields_with_methods_to_call:
-                object_id = row.get(self.get_pk_field().name, None)
-                value = row.get(field.field, None)
-                processed_value = value
-                if field.view_method:
-                    processed_value = field.view_method(
-                        object_id, value, **additional_data
+            for field_key, value in row.items():
+                if field_key in field_key_field_map:
+                    field = field_key_field_map[field_key]
+                    value = self.view.process_field_data(
+                        self.threadsafe_request, field, obj_id, value, additional_data
                     )
-                formatted_value = processed_value
-                if field.python_formatter:
-                    formatted_value = field.python_formatter(object_id, processed_value)
-                row[field.field] = formatted_value
+                if isinstance(value, str) and not isinstance(value, SafeString):
+                    value = escape(value)
+                row[field_key] = value
 
     def get_json_data(self):
         return self.get_data()
@@ -426,6 +450,9 @@ class SBAdminListAction(SBAdminAction):
         return final_data
 
     def get_selection_queryset(self):
+        if not self.selection_data:
+            # don't run with no selection data as it will result in querying all records
+            return Q(id__in=[])
         additional_filter = None
         if self.selected_rows and self.selected_rows != SELECT_ALL_KEYWORD:
             additional_filter = Q(id__in=self.selected_rows)
@@ -434,13 +461,15 @@ class SBAdminListAction(SBAdminAction):
             additional_filter = ~Q(id__in=self.deselected_rows)
         return additional_filter
 
-    def get_xlsx_data(self):
+    def get_xlsx_data(self, request):
         page_size = XLSX_PAGE_CHUNK_SIZE
         file_name = (
             f'{self.view.get_menu_label()}__{timezone.now().strftime("%Y-%m-%d")}.xlsx'
         )
         columns = self.get_excel_columns()
-        additional_filter = self.get_selection_queryset()
+        additional_filter = Q()
+        if request.request_data.modifier != IGNORE_LIST_SELECTION:
+            additional_filter = self.get_selection_queryset()
         data_list = []
         report_data = self.get_data(
             page_size=page_size,
@@ -457,8 +486,8 @@ class SBAdminListAction(SBAdminAction):
                 )["data"]
             )
         options = (
-            self.view.get_sbadmin_xlsx_options().to_json()
-            if self.view.get_sbadmin_xlsx_options()
+            self.view.get_sbadmin_xlsx_options(request).to_json()
+            if self.view.get_sbadmin_xlsx_options(request)
             else {}
         )
         return [file_name, data_list, columns, options]

django_smartbase_admin/actions/advanced_filters.py

@@ -5,7 +5,7 @@ from dataclasses import field as dataclass_field
 from typing import List, Optional, TYPE_CHECKING
 
 from django.db import models
-from django.db.models import Q
+from django.db.models import Q, Count
 from django.template.loader import render_to_string
 from django.utils.translation import gettext_lazy as _
 
@@ -45,8 +45,15 @@ class AllOperators(models.TextChoices):
     IS_NOT_NULL = "is_not_null", _("Is not null")
     BEFORE = "before", _("Before")
     AFTER = "after", _("After")
+    IN_THE_LAST = "in_the_last", _("In the last")
+    IN_THE_NEXT = "in_the_next", _("In the next")
 
 
+NULL_ATTRIBUTES = [
+    AllOperators.IS_NULL,
+    AllOperators.IS_NOT_NULL,
+]
+
 DATE_ATTRIBUTES = [
     AllOperators.BETWEEN,
     AllOperators.NOT_BETWEEN,
@@ -54,6 +61,8 @@ DATE_ATTRIBUTES = [
     AllOperators.AFTER,
     AllOperators.IS_NULL,
     AllOperators.IS_NOT_NULL,
+    AllOperators.IN_THE_LAST,
+    AllOperators.IN_THE_NEXT,
 ]
 
 NUMBER_ATTRIBUTES = [
@@ -96,12 +105,16 @@ class QueryBuilderFilter:
         filter_widget_for_context.input_id = QB_JS_PREFIX
         filter_widget_for_context.input_name = QB_JS_PREFIX
         operators = filter_widget.get_advanced_filter_operators()
-        operators = [operator.value for operator in operators]
+        operators_values = []
+        for operator in operators:
+            if filter_widget.exclude_null_operators and operator in NULL_ATTRIBUTES:
+                continue
+            operators_values.append(operator.value)
         return cls(
             id=filter_widget.input_id,
             field=filter_widget.field.field,
             label=filter_widget.field.title,
-            operators=operators,
+            operators=operators_values,
             input=render_to_string(
                 template_name=filter_widget.template_name.replace(
                     "filter_widgets/", "filter_widgets/advanced_filters/"
@@ -148,6 +161,8 @@ class QueryBuilderService:
         AllOperators.IS_NOT_NULL.value: "__isnull",
         AllOperators.BEFORE.value: "__lt",
         AllOperators.AFTER.value: "__gte",
+        AllOperators.IN_THE_LAST.value: "__range",
+        AllOperators.IN_THE_NEXT.value: "__range",
     }
 
     ZERO_INPUTS_OPERATORS = {
@@ -236,36 +251,56 @@ class QueryBuilderService:
                 if field is None:
                     continue
 
-                value = field.filter_widget.parse_value_from_input(
-                    request, rule["value"]
-                )
-                if operator not in cls.LIST_OPERATORS and isinstance(value, list):
-                    value = value[0]
-
                 if operator in cls.ZERO_INPUTS_OPERATORS:
+                    value = None
                     filter_value = (
                         True
                         if operator in [AllOperators.IS_NULL, AllOperators.IS_NOT_NULL]
                         else ""
                     )
+                    if field.annotate and isinstance(field.annotate, Count):
+                        filter_value = 0
                     q = Q(
                         **{
                             f"{field.filter_field}{cls.OPERATOR_MAP[operator]}": filter_value,
                         }
                     )
-                elif operator in [
-                    AllOperators.BETWEEN.value,
-                    AllOperators.NOT_BETWEEN.value,
-                ]:
-                    q = Q()
-                    if value[0] is not None:
-                        q &= Q(**{f"{field.filter_field}__gte": value[0]})
-                    if value[1] is not None:
-                        q &= Q(**{f"{field.filter_field}__lte": value[1]})
+                    from django_smartbase_admin.engine.filter_widgets import (
+                        StringFilterWidget,
+                    )
+
+                    if isinstance(
+                        field.filter_widget, StringFilterWidget
+                    ) and operator in [
+                        AllOperators.IS_EMPTY,
+                        AllOperators.IS_NOT_EMPTY,
+                    ]:
+                        q = q | Q(
+                            **{
+                                f"{field.filter_field}{cls.OPERATOR_MAP[AllOperators.IS_NULL]}": True
+                            }
+                        )
                 else:
-                    q = Q(
-                        **{f"{field.filter_field}{cls.OPERATOR_MAP[operator]}": value}
+                    value = field.filter_widget.parse_value_from_input(
+                        request, rule["value"]
                     )
+                    if operator not in cls.LIST_OPERATORS and isinstance(value, list):
+                        value = value[0]
+                    if operator in [
+                        AllOperators.BETWEEN.value,
+                        AllOperators.NOT_BETWEEN.value,
+                    ]:
+                        q = Q()
+                        if value[0] is not None:
+                            q &= Q(**{f"{field.filter_field}__gte": value[0]})
+                        if value[1] is not None:
+                            q &= Q(**{f"{field.filter_field}__lte": value[1]})
+                    else:
+                        q = Q(
+                            **{
+                                f"{field.filter_field}{cls.OPERATOR_MAP[operator]}": value
+                            }
+                        )
 
                 if operator in cls.NEGATIVE_OPERATORS:
                     q = ~q