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

django_smartbase_admin/engine/configuration.py

@@ -1,12 +1,20 @@
-from copy import deepcopy
-
 from django.contrib.auth import get_permission_codename
+from django.contrib.auth.views import LoginView
 from django.db.models import Q
 
 from django_smartbase_admin.admin.site import sb_admin_site
 from django_smartbase_admin.engine.actions import SBAdminCustomAction
-from django_smartbase_admin.engine.const import GLOBAL_FILTER_DATA_KEY, FilterVersions
-from django_smartbase_admin.utils import to_list
+from django_smartbase_admin.engine.const import (
+    GLOBAL_FILTER_DATA_KEY,
+    FilterVersions,
+    Action,
+)
+from django_smartbase_admin.models import (
+    ColorScheme,
+    SBAdminListViewConfiguration,
+    SBAdminUserConfiguration,
+)
+from django_smartbase_admin.utils import to_list, is_modal
 
 
 class SBAdminConfigurationBase(object):
@@ -19,6 +27,145 @@ class SBAdminConfigurationBase(object):
     def get_configuration_for_roles(self, user_roles):
         raise NotImplementedError
 
+    # User configuration hooks - override these methods to customize user identification
+    # (e.g., use email instead of user_id for OAuth/external auth scenarios)
+
+    @classmethod
+    def get_user_config(cls, request):
+        """
+        Get or create user configuration (e.g., color scheme preferences).
+
+        Override this method to customize user identification. Default uses user_id.
+
+        Example for email-based users::
+
+            @classmethod
+            def get_user_config(cls, request):
+                from myapp.models import MyUserConfig
+                email = getattr(request.user, "email", None)
+                if not email:
+                    return MyUserConfig(email="anonymous", color_scheme=ColorScheme.AUTO.value)
+                config, _ = MyUserConfig.objects.get_or_create(
+                    email=email,
+                    defaults={"color_scheme": request.request_data.configuration.default_color_scheme},
+                )
+                return config
+        """
+        if not request.user or request.user.is_anonymous:
+            return None
+        user_config, _ = SBAdminUserConfiguration.objects.get_or_create(
+            defaults={
+                "color_scheme": request.request_data.configuration.default_color_scheme
+            },
+            user_id=request.user.id,
+        )
+        return user_config
+
+    @classmethod
+    def get_saved_views(cls, request, view_id):
+        """
+        Get saved views for the current user and view.
+
+        Override this method to customize user identification. Default uses user_id.
+        Returns a list of dicts with keys: id, name, url_params, view (view_id).
+
+        Example for email-based users::
+
+            @classmethod
+            def get_saved_views(cls, request, view_id):
+                from myapp.models import MySavedView
+                email = getattr(request.user, "email", None)
+                if not email:
+                    return []
+                return list(
+                    MySavedView.objects.filter(email=email, view_id=view_id)
+                    .values("id", "name", "config", "view_id")
+                )
+        """
+        if not request.user or request.user.is_anonymous:
+            return []
+        return list(
+            SBAdminListViewConfiguration.objects.by_user_id(request.user.id)
+            .by_view_action_modifier(view=view_id)
+            .values()
+        )
+
+    @classmethod
+    def create_or_update_saved_view(
+        cls, request, view_id, config_id, config_name, url_params
+    ):
+        """
+        Create or update a saved view for the current user.
+
+        Override this method to customize user identification. Default uses user_id.
+        Returns the created/updated saved view object.
+
+        Example for email-based users::
+
+            @classmethod
+            def create_or_update_saved_view(cls, request, view_id, config_id, config_name, url_params):
+                from myapp.models import MySavedView
+                email = getattr(request.user, "email", None)
+                if not email:
+                    return None
+                config_params = {}
+                if config_id:
+                    config_params["id"] = config_id
+                if config_name:
+                    config_params["name"] = config_name
+                saved_view, _ = MySavedView.objects.update_or_create(
+                    email=email,
+                    **config_params,
+                    defaults={"config": {"url_params": url_params}, "view_id": view_id},
+                )
+                return saved_view
+        """
+        if not request.user or request.user.is_anonymous:
+            return None
+        config_params = {}
+        if config_id:
+            config_params["id"] = config_id
+        elif config_name:
+            config_params["name"] = config_name
+        if not config_params:
+            return None
+        saved_view, _ = SBAdminListViewConfiguration.objects.update_or_create(
+            user_id=request.user.id,
+            **config_params,
+            defaults={
+                "url_params": url_params,
+                "view": view_id,
+                "action": None,
+                "modifier": None,
+            },
+        )
+        return saved_view
+
+    @classmethod
+    def delete_saved_view(cls, request, view_id, config_id):
+        """
+        Delete a saved view for the current user.
+
+        Override this method to customize user identification. Default uses user_id.
+
+        Example for email-based users::
+
+            @classmethod
+            def delete_saved_view(cls, request, view_id, config_id):
+                from myapp.models import MySavedView
+                email = getattr(request.user, "email", None)
+                if not email or not config_id:
+                    return
+                MySavedView.objects.filter(
+                    email=email, id=config_id, view_id=view_id
+                ).delete()
+        """
+        if not request.user or request.user.is_anonymous or not config_id:
+            return
+        SBAdminListViewConfiguration.objects.by_user_id(request.user.id).by_id(
+            config_id
+        ).by_view_action_modifier(view=view_id).delete()
+
 
 class Singleton(type):
     _instances = {}
@@ -37,6 +184,8 @@ class SBAdminRoleConfiguration(metaclass=Singleton):
     menu_items = None
     global_filter_form = None
     filters_version = FilterVersions.FILTERS_VERSION_1
+    default_color_scheme = ColorScheme.AUTO
+    login_view_class = LoginView
 
     def __init__(
         self,
@@ -45,6 +194,8 @@ class SBAdminRoleConfiguration(metaclass=Singleton):
         menu_items=None,
         global_filter_form=None,
         filters_version=None,
+        default_color_scheme=None,
+        login_view_class=None,
     ) -> None:
         super().__init__()
         self.default_view = default_view or self.default_view or []
@@ -54,6 +205,8 @@ class SBAdminRoleConfiguration(metaclass=Singleton):
         self.init_configuration_static()
         self.autocomplete_map = {}
         self.filters_version = filters_version or self.filters_version
+        self.default_color_scheme = default_color_scheme or self.default_color_scheme
+        self.login_view_class = login_view_class or self.login_view_class
 
     def init_registered_views(self):
         registered_views = []
@@ -84,6 +237,18 @@ class SBAdminRoleConfiguration(metaclass=Singleton):
                 if hasattr(view, "get_id")
             }
         )
+        try:
+            from cms.plugin_pool import plugin_pool
+
+            for name, view in plugin_pool.plugins.items():
+                if hasattr(view, "get_id"):
+                    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
+                    )
+        except ImportError:
+            pass
 
     def init_model_admin_view_map(self):
         for model, admin_view in sb_admin_site._registry.items():
@@ -132,6 +297,8 @@ class SBAdminRoleConfiguration(metaclass=Singleton):
 
     def has_action_permission(self, request, request_data, view, model, obj, action):
         if model:
+            if action.action_id == Action.BULK_DELETE.value:
+                return view.has_delete_permission(request, obj)
             return self.has_permission(
                 request, request_data, view, model, obj, "view"
             ) or self.has_permission(request, request_data, view, model, obj, "change")
@@ -166,6 +333,9 @@ class SBAdminRoleConfiguration(metaclass=Singleton):
             form_field, model=model, multiselect=multiselect
         )
 
+    def get_filter_widget(self, field, default_widget):
+        return default_widget
+
     def get_form_field_widget_class(
         self, view, request, form_field, db_field, default_widget_class
     ):
@@ -204,3 +374,15 @@ class SBAdminRoleConfiguration(metaclass=Singleton):
             if global_filter_mapped_filter_key:
                 filter_query &= Q(**{f"{global_filter_mapped_filter_key}": field_value})
         return qs.filter(filter_query)
+
+    def process_global_filter_response(self, response, request):
+        return response
+
+    def autocomplete_show_related_buttons(
+        self,
+        related_model,
+        field_name,
+        current_view,
+        request,
+    ) -> bool:
+        return not is_modal(request)

django_smartbase_admin/engine/const.py

@@ -31,6 +31,7 @@ DEFAULT_PAGE_SIZE = 20
 PAGE_SIZE_OPTIONS = [10, 20, 50, 100]
 AUTOCOMPLETE_PAGE_SIZE = 20
 XLSX_PAGE_CHUNK_SIZE = 50000
+IGNORE_LIST_SELECTION = "__all__"
 NEW_OBJECT_ID = 0
 OBJECT_ID_PLACEHOLDER = -1
 ALL_MODEL_FIELDS = "__all__"
@@ -52,6 +53,9 @@ TABLE_PARAMS_PAGE_NAME = "page"
 TABLE_PARAMS_SORT_NAME = "sort"
 TABLE_PARAMS_FULL_TEXT_SEARCH = "sb_admin_full_search"
 TABLE_PARAMS_SELECTED_FILTER_TYPE = "sb_selected_filter_type"
+TABLE_TAB_ADVANCED_FITLERS = "tab_advanced_filters"
+TABLE_RELOAD_DATA_EVENT_NAME = "SBAdminReloadTableData"
+TABLE_UPDATE_ROW_DATA_EVENT_NAME = "SBAdminUpdateRowData"
 FILTER_DATA_NAME = "filterData"
 ADVANCED_FILTER_DATA_NAME = "advancedFilterData"
 BASE_PARAMS_NAME = "params"
@@ -69,3 +73,5 @@ DETAIL_STRUCTURE_RIGHT_CLASS = "detail-structure-right"
 TRANSLATIONS_SELECTED_LANGUAGES = "translation_selected_languages"
 OVERRIDE_CONTENT_OF_NOTIFICATION = "override_notification_content"
 FIELDSET_HIDE_HEADER_CLASS = "hide-header"
+ROW_CLASS_FIELD = "get_sbadmin_row_class"
+SUPPORTED_FILE_TYPE_ICONS = ["doc", "docx", "csv", "xls", "xlsx", "pdf", "ppt", "zip"]

django_smartbase_admin/engine/dashboard.py

@@ -1,7 +1,5 @@
-import pickle
-from copy import copy, deepcopy
+from copy import copy
 from datetime import timedelta
-
 from django.core.cache import cache
 from django.db import models
 from django.db.models import QuerySet
@@ -17,7 +15,6 @@ from django_smartbase_admin.engine.admin_view import SBAdminView
 from django_smartbase_admin.engine.const import OBJECT_ID_PLACEHOLDER
 from django_smartbase_admin.engine.field import SBAdminField
 from django_smartbase_admin.engine.filter_widgets import (
-    ChoiceFilterWidget,
     DateFilterWidget,
     RadioChoiceFilterWidget,
 )
@@ -85,6 +82,7 @@ class SBAdminDashboardWidget(SBAdminView):
     def get_widget_context_data(self, request):
         return {
             "widget_id": self.get_id(),
+            "widget_name": self.name,
             "ajax_url": self.get_ajax_url,
             "filters": self.get_filters(),
             "settings": self.get_settings(),
@@ -95,6 +93,12 @@ class SBAdminDashboardWidget(SBAdminView):
     def get_sub_widgets(self):
         return self.sub_widgets
 
+    def get_sub_views(self, configuration):
+        for idx, sub_widget_view in enumerate(self.sub_widgets):
+            sub_widget_view.widget_id = f"{self.get_id()}_{idx}"
+            sub_widget_view.init_widget_static(configuration)
+        return self.sub_widgets
+
     def get_template_name(self):
         return self.template_name
 
@@ -196,6 +200,12 @@ class SBAdminChartAggregateSubWidget(object):
     def render(self, request):
         return render_to_string(self.template_name, self.get_context_data(request))
 
+    def init_widget_static(self, configuration):
+        pass
+
+    def init_view_dynamic(self, request, request_data=None, **kwargs):
+        pass
+
 
 class SBAdminDashboardChartWidget(SBAdminDashboardWidget):
     template_name = "sb_admin/dashboard/chart_widget.html"
@@ -542,25 +552,28 @@ class SBAdminDashboardChartWidgetByDate(SBAdminDashboardChartWidget):
                     self.date_annotate_field
                 )
             )
-            date_range_compare = date_range
-            if compare == self.CompareOptions.COMPARE_PREVIOUS:
-                period_length = (date_range_compare[1] - date_range_compare[0]).days + 1
-                date_range_compare[0] = date_range_compare[0] - timedelta(
-                    days=period_length
-                )
-                date_range_compare[1] = date_range_compare[1] - timedelta(
-                    days=period_length
-                )
-            if compare == self.CompareOptions.COMPARE_PREVIOUS_YOY:
-                date_range_compare[0] = date_range_compare[0].replace(
-                    year=date_range_compare[0].year - 1
-                )
-                date_range_compare[1] = date_range_compare[1].replace(
-                    year=date_range_compare[1].year - 1
-                )
-            request_data_modified_date_filter.request_get[self.date_annotate_field] = (
-                DateFilterWidget.get_value_from_date_or_range(date_range_compare)
-            )
+            if date_range[0] and date_range[1]:
+                date_range_compare = date_range
+                if compare == self.CompareOptions.COMPARE_PREVIOUS:
+                    period_length = (
+                        date_range_compare[1] - date_range_compare[0]
+                    ).days + 1
+                    date_range_compare[0] = date_range_compare[0] - timedelta(
+                        days=period_length
+                    )
+                    date_range_compare[1] = date_range_compare[1] - timedelta(
+                        days=period_length
+                    )
+                if compare == self.CompareOptions.COMPARE_PREVIOUS_YOY:
+                    date_range_compare[0] = date_range_compare[0].replace(
+                        year=date_range_compare[0].year - 1
+                    )
+                    date_range_compare[1] = date_range_compare[1].replace(
+                        year=date_range_compare[1].year - 1
+                    )
+                request_data_modified_date_filter.request_get[
+                    self.date_annotate_field
+                ] = DateFilterWidget.get_value_from_date_or_range(date_range_compare)
             queryset_with_modified_date = self.get_data_queryset(request_copy)
 
             sub_widget_data = {}
@@ -666,5 +679,13 @@ class SBAdminDashboardListWidget(SBAdminBaseListView, SBAdminDashboardWidget):
             "viewsModule",
             "tableParamsModule",
             "detailViewModule",
+            "filterModule",
         ]
         return tabulator_definition
+
+
+class SbAdminCalendarWidget(SBAdminDashboardWidget):
+    template_name = "sb_admin/dashboard/calendar_widget.html"
+
+    def action_get_data(self, request, modifier):
+        return JsonResponse(data=self.get_cached_data(request), safe=False)

django_smartbase_admin/engine/fake_inline.py

@@ -3,7 +3,9 @@ from django.db import models
 from django.db.models import F
 from django.forms import BaseInlineFormSet
 
+from django_smartbase_admin.services.thread_local import SBAdminThreadLocalService
 from django_smartbase_admin.services.views import SBAdminViewService
+from django_smartbase_admin.utils import is_modal
 
 
 class FakeQueryset(models.QuerySet):
@@ -33,6 +35,14 @@ class SBAdminFakeInlineFormset(BaseInlineFormSet):
     original_model = None
     inline_instance = None
 
+    @classmethod
+    def get_default_prefix(cls):
+        prefix = super().get_default_prefix()
+        modal_prefix = (
+            "modal_" if is_modal(SBAdminThreadLocalService.get_request()) else ""
+        )
+        return f"{modal_prefix}{prefix}"
+
     def save_new(self, form, commit=True):
         return self.inline_instance.save_new_fake_inline_instance(
             form, self.inline_instance.parent_instance, commit
@@ -82,23 +92,17 @@ class SBAdminFakeInlineMixin:
         formset.inline_instance = self
         return formset
 
-    def has_add_permission(self, request, obj=None):
-        # don't allow adding new fake inline instances if parent instance is not saved yet
-        if not self.parent_instance.id:
-            return False
-        return super().has_add_permission(request, obj)
-
     def filter_fake_inline_identifier_by_parent_instance(
         self, inline_queryset, parent_instance
     ):
         # filter queryset by parent istance, in queryset there is annotated 'identifier' by get_fake_inline_identifier_annotate
         # example usage:
-        # qs = inline_queryset.filter(path_to_parent_instance__id: parent_instance.id)
+        # qs = inline_queryset.filter(path_to_parent_instance__id: parent_instance.pk)
         # return qs
         if not self.path_to_parent_instance_id:
             raise NotImplementedError
         qs = inline_queryset.filter(
-            **{self.path_to_parent_instance_id: parent_instance.id}
+            **{self.path_to_parent_instance_id: parent_instance.pk}
         )
         return qs
 
@@ -107,9 +111,9 @@ class SBAdminFakeInlineMixin:
         if not self.path_to_parent_instance_id:
             raise NotImplementedError
         fake_inline_object = form.save(commit=False)
-        if parent_instance.id:
+        if parent_instance.pk:
             setattr(
-                fake_inline_object, self.path_to_parent_instance_id, parent_instance.id
+                fake_inline_object, self.path_to_parent_instance_id, parent_instance.pk
             )
             fake_inline_object.save()
         return fake_inline_object
@@ -120,7 +124,7 @@ class SBAdminFakeInlineMixin:
         # result of this method is used in fake_inline_queryset.annotate(SBAdminFakeInlineMixin.fk_name='result')
         # example usage:
         # return F('some_model__relationship_to_parent')
-        return F("id")
+        return F("pk")
 
     def get_queryset(self, request):
         model = self.original_model

django_smartbase_admin/engine/field.py

@@ -1,5 +1,16 @@
+from collections.abc import Callable
+from typing import Any
+
 from django.core.exceptions import FieldDoesNotExist, FieldError, ImproperlyConfigured
-from django.db.models import Count, Value, CharField, F, DateTimeField, BooleanField
+from django.db.models import (
+    Count,
+    Value,
+    CharField,
+    F,
+    DateTimeField,
+    BooleanField,
+    FilteredRelation,
+)
 from django.db.models.functions import Concat
 
 from django_smartbase_admin.engine.const import ANNOTATE_KEY, Formatter
@@ -23,6 +34,7 @@ class TabulatorFieldOptions(JSONSerializableMixin):
     formatterParams = None
     frozen = False
     title = None
+    editorParams = None
 
     def __init__(
         self,
@@ -31,6 +43,7 @@ class TabulatorFieldOptions(JSONSerializableMixin):
         formatterParams=None,
         frozen=None,
         title=None,
+        editorParams=None,
     ) -> None:
         super().__init__()
         self.headerFilter = headerFilter
@@ -38,20 +51,27 @@ class TabulatorFieldOptions(JSONSerializableMixin):
         self.formatterParams = formatterParams
         self.frozen = frozen
         self.title = title
+        self.editorParams = editorParams
 
 
 class XLSXFieldOptions(JSONSerializableMixin):
-    title = None
-    field = None
-    formatter = None
+    title: str | None = None
+    field: str | None = None
+    formatter: Formatter | None = None
+    python_formatter: Callable[[int, Any], Any] | None = None
 
     def __init__(
-        self, title: str = None, field: str = None, formatter: Formatter = None
+        self,
+        title: str | None = None,
+        field: str | None = None,
+        formatter: Formatter | None = None,
+        python_formatter: Callable[[int, Any], Any] | None = None,
     ) -> None:
         super().__init__()
         self.title = title
         self.field = field
         self.formatter = formatter
+        self.python_formatter = python_formatter
 
 
 class SBAdminField(JSONSerializableMixin):
@@ -80,6 +100,7 @@ class SBAdminField(JSONSerializableMixin):
     python_formatter = None
     tabulator_options = None
     xlsx_options = None
+    initialized = False
 
     def __init__(
         self,
@@ -96,7 +117,7 @@ class SBAdminField(JSONSerializableMixin):
         list_visible=None,
         list_collapsed=None,
         auto_created=None,
-        formatter: Formatter = None,
+        formatter: Formatter = Formatter.HTML.value,
         tabulator_editor=None,
         python_formatter=None,
         tabulator_options: "TabulatorFieldOptions" = None,
@@ -118,6 +139,7 @@ class SBAdminField(JSONSerializableMixin):
             if (list_visible is not None)
             else (self.list_visible if self.list_visible is not None else True)
         )
+        self.list_visible_arg = list_visible
         self.list_collapsed = list_collapsed or self.list_collapsed or False
         self.auto_created = auto_created or self.auto_created or False
         self.formatter = formatter
@@ -139,6 +161,7 @@ class SBAdminField(JSONSerializableMixin):
             )
         if not filter_widget:
             filter_widget = StringFilterWidget()
+        filter_widget = configuration.get_filter_widget(self, filter_widget)
         if filter_widget:
             filter_widget.init_filter_widget_static(self, self.view, configuration)
             self.filter_widget = filter_widget
@@ -179,7 +202,6 @@ class SBAdminField(JSONSerializableMixin):
             if self.model_field and not self.annotate:
                 self.annotate = F(field_name)
             self.filter_field = self.filter_field or field_name
-            self.formatter = "html"
         if self.view.model and not self.model_field:
             self.model_field = self.get_model_field_from_model(self.name)
         if (
@@ -199,7 +221,9 @@ class SBAdminField(JSONSerializableMixin):
         if self.model_field:
             self.editable = self.model_field.editable
             if self.model_field.is_relation:
-                self.list_visible = False
+                self.list_visible = (
+                    False if self.list_visible_arg is None else self.list_visible_arg
+                )
             if self.model_field.auto_created:
                 self.detail_visible = False
             self.title = self.title or getattr(
@@ -217,10 +241,9 @@ class SBAdminField(JSONSerializableMixin):
                 self.python_formatter = datetime_formatter
             if isinstance(self.model_field, BooleanField):
                 self.python_formatter = boolean_formatter
-        if self.python_formatter and not self.formatter:
-            self.formatter = "html"
         self.filter_field = self.filter_field or self.field
         self.init_filter_for_field(configuration)
+        self.initialized = True
 
     def serialize_tabulator(self):
         data = {
@@ -252,6 +275,7 @@ class SBAdminField(JSONSerializableMixin):
 
     def get_field_annotates(self, values):
         field_annotates = {}
+        supporting_annotates = {}
         if self.annotate:
             field_annotates[self.field] = self.annotate
         if self.annotate_function:
@@ -261,5 +285,11 @@ class SBAdminField(JSONSerializableMixin):
             else:
                 field_annotates[self.field] = Value(None, output_field=CharField())
         if self.supporting_annotates:
-            field_annotates.update(self.supporting_annotates)
-        return field_annotates
+            for key, value in self.supporting_annotates.items():
+                # workaround for a django bug
+                # https://code.djangoproject.com/ticket/36442#ticket
+                if isinstance(value, FilteredRelation):
+                    supporting_annotates[key] = value.clone()
+                else:
+                    supporting_annotates[key] = value
+        return {**supporting_annotates, **field_annotates}

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
@@ -29,19 +39,21 @@ def datetime_formatter_with_format(date_format=None, time_format=None):
 
 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):
@@ -49,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>')