accrete 0.0.143__py3-none-any.whl → 0.0.144__py3-none-any.whl

accrete/contrib/log/admin.py

@@ -44,4 +44,4 @@ class LogAdmin(admin.ModelAdmin):
 
 
 admin.site.register(models.LogConfig, LogConfigAdmin)
-admin.site.register(models.Log, LogAdmin)
+admin.site.register(models.Log, LogAdmin)

accrete/contrib/system_mail/tasks.py

@@ -36,8 +36,7 @@ def run_mail_queue():
                 _logger.error(f'Failed to send system mail\n{error_str}')
                 email.error = error_str
                 email.save()
-                continue
-
-            email.sent = True
-            email.error = None
-            email.save()
+            else:
+                email.sent = True
+                email.error = None
+                email.save()

accrete/contrib/ui/__init__.py

@@ -1,18 +1,19 @@
 from . import widgets
 from .filter import Filter
-from . context import (
-    Context,
-    ListContext,
-    ListUpdateContext,
-    TableContext,
-    TableRowContext,
-    ModalContext,
-    OobContext,
-    MessageContext
-)
-from .utils import (
-    modal_response,
-    detail_response,
+from .response import (
+    Response,
+    WindowResponse,
+    ListResponse,
+    ListEntryResponse,
+    TableResponse,
+    TableRowResponse,
+    DetailResponse,
+    ModalResponse,
+    OobResponse,
+    TriggerResponse,
+    ClientTrigger,
     search_select_response,
-    add_trigger
+    message_response,
+    add_trigger,
+    update
 )

accrete/contrib/ui/filter.py

@@ -46,12 +46,21 @@ class Filter:
     TYPES_TIME = ['TimeField']
 
     def __init__(
-        self, model, query: QueryDict, default_lookup: str = None
+        self,
+        model,
+        query_dict: QueryDict,
+        default_lookup: str = None,
+        query: Q = None,
+        select_related: list[str] = None,
+        prefetch_related: list[str] = None
     ):
         self.model = model
-        self.query = query
+        self.query_dict = query_dict
         self.model_name = f'{self.model._meta.app_label}.{self.model._meta.model_name}'
-        seen_models = query.get('models', '').split(',')
+        self.query = query or Q()
+        self.select_related = select_related
+        self.prefetch_related = prefetch_related
+        seen_models = query_dict.get('models', '').split(',')
         self.seen_models = [
             model for model in seen_models
             if model and model != self.model_name
@@ -67,14 +76,14 @@ class Filter:
     ) -> paginator.Page:
         return page_from_querystring(
             self.model,
-            self.query,
-            select_related=select_related,
-            prefetch_related=prefetch_related,
-            query=query
+            self.query_dict,
+            select_related=select_related or self.select_related,
+            prefetch_related=prefetch_related or self.prefetch_related,
+            query=query or self.query
         )
 
     def get_queryset(self) -> QuerySet:
-        return filter_from_querystring(self.model, self.query)
+        return filter_from_querystring(self.model, self.query_dict)
 
     def query_params(self):
         fields = filter(
@@ -82,7 +91,7 @@ class Filter:
             self.model._meta.get_fields()
         )
         params = []
-        path = self.query.get('path', '')
+        path = self.query_dict.get('path', '')
         for field in fields:
             field_params = self._get_field_params(field)
             if not field.is_relation or field_params['model_name'] not in self.seen_models:
@@ -115,7 +124,7 @@ class Filter:
         if not lookup:
             ctx = {
                 'verbose_lookup': str(_('Select an attribute')),
-                'query_dict': self.query,
+                'query_dict': self.query_dict,
                 'model_name': self.model_name
             }
             return render_to_string('ui/filter/query_input.html', ctx)
@@ -133,14 +142,14 @@ class Filter:
             'lookup': prefix + lookup,
             'input': input_params,
             'lookup_operator': lookup_operator,
-            'query_dict': self.query,
+            'query_dict': self.query_dict,
             'model_name': self.model_name
         }
         return render_to_string('ui/filter/query_input.html', ctx)
 
     def query_tags(self, query: list | dict = None, operator: str = None):
         if not query:
-            query = json.loads(self.query.get('q', '[]'))
+            query = json.loads(self.query_dict.get('q', '[]'))
         if isinstance(query, dict):
             query = [query]
         operator = operator or '&'
@@ -291,7 +300,7 @@ class Filter:
         return str(labels[lookup])
 
     def _get_field_params(self, field):
-        path = self.query.get('path', '')
+        path = self.query_dict.get('path', '')
         label = ''
         name = field.name
         if path:

accrete/contrib/ui/response.py

@@ -0,0 +1,540 @@
+import re
+import ast
+import json
+from dataclasses import dataclass
+
+from django.core import paginator
+from django.db.models import Model
+from django.http import HttpResponse
+from django.template.loader import render_to_string
+from django.utils.translation import gettext_lazy as _
+from accrete.contrib.ui import Filter
+
+
+class Response:
+
+    def __init__(self, *, template: str, context: dict):
+        self.template = template
+        self.context = context
+
+    @staticmethod
+    def add_trigger(response):
+        pass
+
+    def render(self, request) -> str:
+        return render_to_string(
+            template_name=self.template, context=self.context, request=request
+        )
+
+    def response(self, request, extra_content: str = None, replace_body: bool = False) -> HttpResponse:
+        extra_content = extra_content or ''
+        res = HttpResponse(content=(
+            self.render(request)
+            + render_to_string('ui/message.html', request=request)
+            + extra_content
+        ))
+        self.add_trigger(res)
+        if replace_body:
+            res.headers['HX-Retarget'] = 'body'
+            res.headers['HX-Reswap'] = 'innerHTML'
+            res.headers['HX-Push-Url'] = request.path
+        return res
+
+
+class OobResponse(Response):
+
+    oob_template = 'ui/oob.html'
+
+    def __init__(self, *, template: str, context: dict, swap: str, tag: str = 'div'):
+        super().__init__(template=self.oob_template, context=context)
+        self.context.update({'oob': {
+            'template': template,
+            'swap': swap,
+            'tag': tag
+        }})
+
+
+class WindowResponse(Response):
+
+    base_template = 'ui/layout.html'
+
+    def __init__(
+        self, *,
+        title: str,
+        context: dict,
+        overview_template: str = None,
+        header_template: str = None,
+        panel_template: str = None,
+        is_centered: bool = False
+    ):
+        super().__init__(template=self.base_template, context=context)
+        self.panel_template = panel_template
+        if 'has_panel' not in self.context.keys():
+            self.context.update(has_panel=self._has_panel())
+        self.context.update({
+            'title': title,
+            'overview_template': overview_template,
+            'header_template': header_template,
+            'panel_template': panel_template,
+            'is_centered': is_centered
+        })
+
+    def _has_panel(self):
+        return bool(self.panel_template)
+
+    def response(self, request, extra_content: str = None, replace_body: bool = True) -> HttpResponse:
+        return super().response(request, extra_content, replace_body)
+
+
+class ListResponse(WindowResponse):
+
+    def __init__(
+        self, *,
+        title: str,
+        context: dict,
+        list_entry_template: str = None,
+        page: paginator.Page = None,
+        ui_filter: Filter = None,
+        endless_scroll: bool = True,
+        header_template: str = None,
+        panel_template: str = None,
+        column_count: int = 1,
+        column_height: str = '150px',
+        overview_template: str = 'ui/list.html'
+    ):
+        assert page is not None or ui_filter is not None, _(
+            'Argument page or ui_filter must be supplied'
+        )
+        self.ui_filter = ui_filter
+        self.overview_template = overview_template
+        super().__init__(
+            title=title,
+            context=context,
+            overview_template=self.overview_template,
+            header_template=header_template,
+            panel_template=panel_template,
+        )
+        if ui_filter and not page:
+            page = ui_filter.get_page()
+        self.context.update({
+            'list_entry_template': list_entry_template,
+            'page': page,
+            'ui_filter': ui_filter,
+            'endless_scroll': endless_scroll,
+            'column_count': column_count,
+            'column_height': column_height
+        })
+
+    def _has_panel(self):
+        return bool(self.panel_template or self.ui_filter)
+
+    def response(self, request, extra_content: str = None, replace_body: bool = False) -> HttpResponse:
+        return super().response(request, extra_content, replace_body)
+
+
+class ListEntryResponse(Response):
+
+    base_template = 'ui/list_update.html'
+
+    def __init__(
+        self, *,
+        instance: Model,
+        list_entry_template: str,
+        context: dict = None,
+        page: paginator.Page,
+        is_new: bool,
+        column_count: int = 1,
+        column_height: str = '150px',
+    ):
+        self.page = page
+        super().__init__(template=self.base_template, context=context or {})
+        self.context.update({
+            'instance': instance,
+            'list_entry_template': list_entry_template,
+            'is_new': is_new,
+            'column_count': column_count,
+            'column_height': column_height
+        })
+
+    def render(self, request) -> str:
+        res = super().render(request)
+        if self.page:
+            pagination_update = OobResponse(
+                template='ui/layout.html#pagination',
+                swap='innerHTML:#pagination',
+                context=dict(page=self.page)
+            ).render(request)
+            res += pagination_update
+        return res
+
+
+class TableResponse(WindowResponse):
+
+    def __init__(
+        self, *,
+        title: str,
+        context: dict,
+        object_label: str,
+        fields: list[str],
+        footer: dict = None,
+        page: paginator.Page = None,
+        ui_filter: Filter = None,
+        endless_scroll: bool = True,
+        header_template: str = None,
+        panel_template: str = None,
+        overview_template: str = 'ui/table.html'
+    ):
+        assert page is not None or ui_filter is not None, _(
+            'Argument page or ui_filter must be supplied'
+        )
+        self.ui_filter = ui_filter
+        self.overview_template = overview_template
+        super().__init__(
+            title=title,
+            context=context,
+            overview_template=self.overview_template,
+            header_template=header_template,
+            panel_template=panel_template
+        )
+        if ui_filter and not page:
+            page = ui_filter.get_page()
+        self.context.update({
+            'page': page,
+            'ui_filter': ui_filter,
+            'endless_scroll': endless_scroll,
+            'fields': fields,
+            'object_label': object_label,
+            'footer': footer
+        })
+
+    def _has_panel(self):
+        return bool(self.panel_template or self.ui_filter)
+
+    def response(self, request, extra_content: str = None, replace_body: bool = False) -> HttpResponse:
+        return super().response(request, extra_content, replace_body)
+
+
+class TableRowResponse(Response):
+
+    base_template = 'ui/table_row_update.html'
+
+    def __init__(
+        self, *,
+        instance: Model,
+        fields: list[str],
+        footer: dict = None,
+        page: paginator.Page = None,
+    ):
+        self.page = page
+        context = {
+            'instance': instance,
+            'fields': fields,
+            'footer': footer,
+        }
+        super().__init__(template=self.base_template, context=context)
+
+    def render(self, request) -> str:
+        res = super().render(request)
+        if self.page:
+            pagination_update = OobResponse(
+                template='ui/layout.html#pagination',
+                swap='innerHTML:#pagination',
+                context=dict(page=self.page)
+            ).render(request)
+            res += pagination_update
+        return res
+
+
+class DetailResponse(Response):
+
+    base_template = 'ui/detail.html'
+
+    def __init__(
+        self, *,
+        context: dict,
+        detail_header_template: str = None,
+        detail_data_template: str = None
+    ):
+        super().__init__(template=self.base_template, context=context)
+        self.context.update({
+            'detail_header_template': detail_header_template,
+            'detail_data_template': detail_data_template
+        })
+
+    @staticmethod
+    def add_trigger(response):
+        add_trigger(response, 'activate-detail')
+
+
+class ModalResponse(Response):
+
+    def __init__(
+        self, *,
+        modal_id: str,
+        template: str,
+        context: dict,
+        title: str = None,
+        is_update: bool = False,
+        is_blocking: bool = False,
+        modal_width: str = None
+
+    ):
+        super().__init__(template=template, context=context)
+        self.context.update({
+            'title': title,
+            'modal_id': re.sub(r'[^A-Za-z-]+', '', modal_id).strip('-'),
+            'is_update': is_update,
+            'is_blocking': is_blocking,
+            'modal_width': modal_width
+        })
+
+
+@dataclass
+class ClientTrigger:
+
+    trigger: dict | str
+    header: str = 'HX-Trigger'
+
+
+class TriggerResponse:
+
+    def __init__(self, trigger: list[ClientTrigger]):
+        self.trigger = trigger
+
+    def response(self):
+        res = HttpResponse()
+        res.headers['HX-Reswap'] = 'None'
+        for trigger in self.trigger:
+            add_trigger(res, trigger.trigger, trigger.header)
+        return res
+
+
+# @dataclass(kw_only=True)
+# class Response:
+#
+#     template: str
+#     context: dict = field(default_factory=dict)
+#
+#     base_template = None
+#
+#     def __post_init__(self):
+#         for key, value in self.context.items():
+#             setattr(self, key, value)
+#         if self.base_template is None:
+#             self.base_template = self.template
+#
+#     def dict(self):
+#         return {
+#             attr: getattr(self, attr, None) for attr
+#             in filter(lambda x: not x.startswith('_'), self.__dict__)
+#         }
+#
+#     @staticmethod
+#     def add_trigger(response):
+#         pass
+#
+#     def render(self, request) -> str:
+#         return render_to_string(
+#             template_name=self.base_template, context=self.dict(), request=request
+#         )
+#
+#     def response(self, request, extra_content: str = None) -> HttpResponse:
+#         extra_content = extra_content or ''
+#         res = HttpResponse(content=(
+#             self.render(request)
+#             + render_to_string('ui/message.html', self.dict(), request)
+#             + extra_content
+#         ))
+#         self.add_trigger(res)
+#         return res
+#
+#
+# @dataclass(kw_only=True)
+# class OobResponse(Response):
+#
+#     swap: str
+#     tag: str = 'div'
+#     id: str = None
+#
+#     base_template = 'ui/oob.html'
+#
+#     def dict(self) -> dict:
+#         attributes = filter(
+#             lambda x: not x.startswith('_') and x not in ['template', 'swap', 'tag'],
+#             self.__dict__
+#         )
+#         res = {attr: getattr(self, attr, None) for attr in attributes}
+#         res.update({'oob': {
+#             'template': self.template,
+#             'id': self.id,
+#             'swap': self.swap,
+#             'tag': self.tag
+#         }})
+#         return res
+#
+#     # def render(self, request) -> str:
+#     #     return render_to_string(
+#     #         template_name='ui/oob.html', context=self.dict(), request=request
+#     #     )
+#
+#
+# @dataclass(kw_only=True)
+# class WindowResponse(Response):
+#
+#     title: str = ''
+#     panel_template: str = None
+#     overview_header_template: str = None
+#     overview_data_template: str = None
+#
+#     base_template = 'ui/layout.html'
+#
+#     def __post_init__(self):
+#         if 'has_panel' not in self.context.keys():
+#             self.context.update(has_panel=self._has_panel())
+#         super().__post_init__()
+#         if self.template:
+#             self.base_template = self.template
+#
+#     def _has_panel(self) -> bool:
+#         return bool(self.panel_template)
+#
+#
+# @dataclass(kw_only=True)
+# class PageResponse(WindowResponse):
+#
+#     page: paginator.Page = None
+#     ui_filter: Filter = None
+#     endless_scroll: bool = True
+#
+#     def __post_init__(self):
+#         assert self.page is not None or self.ui_filter is not None, _(
+#             'Argument page or ui_filter must be supplied'
+#         )
+#         if self.ui_filter and not self.page:
+#             self.page = self.ui_filter.get_page()
+#         super().__post_init__()
+#
+#     def _has_panel(self) -> bool:
+#         return bool(self.panel_template or self.ui_filter)
+#
+#
+# @dataclass(kw_only=True)
+# class ListResponse(PageResponse):
+#
+#     list_entry_template: str = None
+#     column_count: int = 1
+#     column_height: str = '150px'
+#     overview_data_template:str = 'ui/list.html'
+#
+#
+# @dataclass(kw_only=True)
+# class ListEntryResponse(Response):
+#
+#     object: Model
+#     list_entry_template: str
+#     page: paginator.Page = None
+#     new_entry: bool = False
+#     template: str = 'ui/list_update.html'
+#
+#     def render(self, request) -> str:
+#         res = super().render(request)
+#         if self.page:
+#             pagination_update = OobResponse(
+#                 template='ui/layout.html#pagination',
+#                 swap='innerHTML:#pagination',
+#                 context=dict(page=self.page)
+#             ).render(request)
+#             res += pagination_update
+#         return res
+#
+#
+# @dataclass(kw_only=True)
+# class TableResponse(PageResponse):
+#
+#     object_label: str
+#     fields: list[str]
+#     footer: dict = field(default_factory=dict)
+#     template = 'ui/table.html'
+#
+#
+# @dataclass(kw_only=True)
+# class TableRowResponse(Response):
+#
+#     object: Model
+#     fields: list[str]
+#     footer: dict = field(default_factory=dict)
+#     page: paginator.Page = None
+#
+#     base_template = 'ui/table_row_update.html'
+#
+#
+# @dataclass(kw_only=True)
+# class DetailResponse(Response):
+#
+#     detail_data_template: str = None
+#     detail_header_template: str = None
+#
+#     base_template = 'ui/detail.html'
+#
+#     @staticmethod
+#     def add_trigger(response):
+#         add_trigger(response, 'activate-detail')
+#
+#
+# @dataclass(kw_only=True)
+# class ModalResponse(Response):
+#
+#     title: str
+#     modal_id: str
+#     template: str
+#     modal_update: bool = False
+#     blocking: bool = False
+#     modal_width: str = None
+#
+#     def __post_init__(self):
+#         super().__post_init__()
+#         self.modal_id = re.sub(r'[^A-Za-z-]+', '', self.modal_id).strip('-')
+
+
+def search_select_response(queryset) -> HttpResponse:
+    return HttpResponse(render_to_string(
+        'ui/widgets/model_search_select_options.html',
+        {'options': queryset}
+    ))
+
+
+def message_response(request, persistent: bool = False):
+    return HttpResponse(content=(render_to_string(
+        'ui/message.html', context={'persistent': persistent}, request=request
+    )))
+
+
+def add_trigger(
+    response: HttpResponse,
+    trigger: dict | str,
+    header: str = 'HX-Trigger'
+) -> HttpResponse:
+    if isinstance(trigger, str):
+        trigger = {trigger: ''}
+    res_trigger = response.headers.get(header)
+    if not res_trigger:
+        response.headers[header] = json.dumps(trigger)
+        return response
+    try:
+        res_trigger = ast.literal_eval(response.headers.get(header, '{}'))
+    except SyntaxError:
+        res_trigger = {response.headers[header]: ''}
+    res_trigger.update(trigger)
+    response.headers[header] = json.dumps(res_trigger)
+    return response
+
+
+def update(request, ui_responses: list[Response]) -> HttpResponse:
+    response = HttpResponse()
+    content = ''
+    for res in ui_responses:
+        content += res.render(request)
+        res.add_trigger(response)
+    content += render_to_string('ui/message.html', request=request)
+    response.content = content
+    return response