accrete 0.0.21__py3-none-any.whl → 0.0.23__py3-none-any.whl

accrete/contrib/sequence/forms.py

@@ -1,8 +1,8 @@
-from tenant.forms import ModelForm
+from accrete.forms import TenantModelForm
 from .models import Sequence
 
 
-class SequenceCreateForm(ModelForm):
+class SequenceCreateForm(TenantModelForm):
     class Meta:
         model = Sequence
         fields = [

accrete/contrib/sequence/queries.py

@@ -1,13 +1,12 @@
-import logging
 from django.db import transaction
 from django.db.models import F
 
+from accrete.tenant import get_tenant
 from .models import Sequence
 
-_logger = logging.getLogger(__name__)
 
-
-def get_nextval(tenant, name, create_if_none=True):
+def get_nextval(name, create_if_none=True):
+    tenant = get_tenant()
     with transaction.atomic():
         seq = Sequence.objects.filter(
             tenant=tenant.id, name=name

accrete/contrib/ui/__init__.py

@@ -1,12 +1,17 @@
 from .filter import Filter
-from .helper import (
-    ClientAction,
+from .context import (
+    ListContext,
     DetailContext,
     FormContext,
-    ListContext,
+)
+from .components import (
+    ClientAction,
     BreadCrumb,
     TableField,
     TableFieldAlignment,
-    build_querystring,
-    queryset_from_querystring
+    TableFieldType
+)
+from .querystring import (
+    parse_querystring,
+    build_querystring
 )

accrete/contrib/ui/components.py

@@ -0,0 +1,49 @@
+from dataclasses import dataclass, field
+from enum import Enum
+
+
+class TableFieldAlignment(Enum):
+
+    LEFT = 'left'
+    CENTER = 'center'
+    RIGHT = 'right'
+
+
+class TableFieldType(Enum):
+
+    NONE = ''
+    STRING = '_string'
+    MONETARY = '_monetary'
+    FLOAT = '_float'
+
+
+@dataclass
+class TableField:
+
+    label: str
+    name: str
+    alignment: type[TableFieldAlignment] = TableFieldAlignment.LEFT
+    header_alignment: type[TableFieldAlignment] = None
+    field_type: type[TableFieldType] = TableFieldType.NONE
+    prefix: str = ''
+    suffix: str = ''
+    truncate_after: int = 0
+
+
+@dataclass
+class BreadCrumb:
+
+    name: str
+    url: str
+
+
+@dataclass
+class ClientAction:
+
+    name: str
+    url: str = ''
+    query_params: str = ''
+    attrs: list[str] = field(default_factory=list)
+    submit: bool = False
+    form_id: str = 'form'
+    class_list: list = field(default_factory=list)

accrete/contrib/ui/context.py

@@ -0,0 +1,284 @@
+import logging
+from dataclasses import dataclass, field
+
+from django.utils.translation import gettext_lazy as _
+from django.db.models import Model, QuerySet, Q
+from django.core.paginator import Paginator
+
+from .querystring import parse_querystring, build_querystring
+from .components import ClientAction, BreadCrumb, TableField
+from .filter import Filter
+
+_logger = logging.getLogger(__name__)
+
+DEFAULT_PAGINATE_BY = 40
+
+
+@dataclass
+class ListContext:
+
+    model: Model
+    get_params: dict
+    title: str = None
+    context: dict = field(default_factory=dict)
+    queryset: QuerySet = None
+    select_related: list[str] = field(default_factory=list)
+    prefetch_related: list[str] = field(default_factory=list)
+    annotate: dict = field(default_factory=dict)
+    paginate_by: int = DEFAULT_PAGINATE_BY
+    order_by: list[str] = field(default_factory=list)
+    filter_relation_depth: int = 4
+    default_filter_term: str = ''
+    actions: list[ClientAction] = field(default_factory=list)
+    breadcrumbs: list[BreadCrumb] = field(default_factory=list)
+    obj_label: str = None
+    fields: list[TableField] = field(default_factory=list)
+    unselect_button: bool = False
+
+    def get_queryset(self):
+        if self.queryset:
+            return self.queryset
+
+        order = self.order_by or self.model._meta.ordering
+
+        pks = self.model.objects.filter(
+            parse_querystring(self.model, self.get_params.get('q', '[]'))
+        ).distinct().values_list('pk', flat=True)
+
+        queryset = self.model.objects.select_related(
+            *self.select_related
+        ).prefetch_related(
+            *self.prefetch_related
+        ).filter(
+            Q(pk__in=pks)
+        ).annotate(
+            **self.get_annotations()
+        ).order_by(
+            *order
+        ).distinct()
+
+        return queryset
+
+    def get_annotations(self):
+        annotations = {
+            annotation['name']: annotation['func']
+            for annotation in getattr(self.model, 'annotations', [])
+        }
+        if self.annotate:
+            annotations.update(self.annotate)
+        return annotations
+
+    def get_page_number(self, paginator):
+        page_number = self.get_params.get('page', '1')
+
+        try:
+            page_number = int(page_number)
+        except ValueError:
+            page_number = 1
+
+        if page_number < 1:
+            page_number = 1
+        elif page_number > paginator.num_pages:
+            page_number = paginator.num_pages
+        return page_number
+
+    def get_paginate_by(self):
+        paginate_by = self.get_params.get('paginate_by', self.paginate_by)
+        try:
+            paginate_by = int(paginate_by)
+        except ValueError:
+            paginate_by = self.paginate_by
+        return paginate_by
+
+    def dict(self):
+        queryset = self.get_queryset()
+        paginate_by = self.get_paginate_by()
+        paginator = Paginator(queryset, paginate_by)
+        page = paginator.page(self.get_page_number(paginator))
+        context = {
+            'queryset': queryset,
+            'paginate_by': paginate_by,
+            'order_by': self.get_params.get('order_by', self.model._meta.ordering),
+            'paginator': paginator,
+            'page': page,
+            'list_pagination': True,
+            'title': self.title or self.model._meta.verbose_name_plural,
+            'filter_terms': Filter(self.model, self.filter_relation_depth).get_query_terms(),
+            'default_filter_term': self.default_filter_term,
+            'breadcrumbs': self.breadcrumbs,
+            'querystring': build_querystring(self.get_params),
+            'actions': self.actions,
+            'obj_label': self.obj_label or _('Name'),
+            'fields': self.fields
+        }
+        context.update(self.context)
+        return context
+
+
+@dataclass
+class DetailContext:
+
+    obj: Model
+    get_params: dict
+    order_by: str = None
+    paginate_by: int = DEFAULT_PAGINATE_BY
+    title: str = None
+    queryset: type[QuerySet] = None
+    select_related: list[str] = field(default_factory=list)
+    prefetch_related: list[str] = field(default_factory=list)
+    annotate: dict = field(default_factory=dict)
+    actions: list[ClientAction] = field(default_factory=list)
+    breadcrumbs: list[BreadCrumb] = field(default_factory=list)
+    context: dict = field(default_factory=dict)
+
+    def get_queryset(self):
+        if self.queryset:
+            return self.queryset
+
+        order = self.order_by or self.obj._meta.model._meta.ordering
+
+        pks = self.obj._meta.model.objects.filter(
+            parse_querystring(self.obj._meta.model, self.get_params.get('q', '[]'))
+        ).distinct().values_list('pk', flat=True)
+
+        queryset = self.obj._meta.model.objects.select_related(
+            *self.select_related
+        ).prefetch_related(
+            *self.prefetch_related
+        ).filter(
+            Q(pk__in=pks)
+        ).annotate(
+            **self.get_annotations()
+        ).order_by(
+            *order
+        ).distinct()
+
+        return queryset
+
+    def get_annotations(self):
+        annotations = {
+            annotation['name']: annotation['func']
+            for annotation in getattr(self.obj._meta.model, 'annotations', [])
+        }
+        if self.annotate:
+            annotations.update(self.annotate)
+        return annotations
+
+    def get_paginate_by(self):
+        paginate_by = self.get_params.get('paginate_by', self.paginate_by)
+        try:
+            paginate_by = int(paginate_by)
+        except ValueError:
+            paginate_by = self.paginate_by
+        return paginate_by
+
+    def get_pagination_context(self):
+        if not hasattr(self.obj, 'get_absolute_url'):
+            _logger.warning(
+                'Detail pagination disabled for models without the '
+                'get_absolute_url attribute. Set paginate_by to 0 to '
+                'deactivate pagination.'
+            )
+            return {}
+        queryset = self.get_queryset()
+        idx = (*queryset,).index(self.obj)
+        previous_object_url = (
+            queryset[idx - 1] if idx - 1 >= 0 else queryset.last()
+        ).get_absolute_url()
+        next_object_url = (
+            queryset[idx + 1] if idx + 1 <= queryset.count() - 1 else queryset.first()
+        ).get_absolute_url()
+        ctx = {
+            'previous_object_url': previous_object_url,
+            'next_object_url': next_object_url,
+            'current_object_idx': idx + 1,
+            'total_objects': queryset.count(),
+            'detail_pagination': True
+        }
+        return ctx
+
+    def dict(self):
+        paginate_by = self.get_paginate_by()
+        ctx = {
+            'object': self.obj,
+            'title': self.title or self.obj,
+            'order_by': self.get_params.get('order_by', self.obj._meta.model._meta.ordering),
+            'paginate_by': paginate_by,
+            'detail_pagination': False,
+            'view_type': 'detail',
+            'breadcrumbs': self.breadcrumbs,
+            'querystring': build_querystring(self.get_params, ['page']),
+            'actions': self.actions
+        }
+        if self.paginate_by > 0:
+            ctx.update(self.get_pagination_context())
+        ctx.update(self.context)
+        return ctx
+
+
+@dataclass
+class FormContext:
+
+    model: Model | type[Model]
+    get_params: dict
+    title: str = None
+    context: dict = field(default_factory=dict)
+    form_id: str = 'form'
+    add_default_actions: bool = True
+    discard_url: str = None
+    actions: list[ClientAction] = field(default_factory=list)
+
+    def get_default_form_actions(self):
+        actions = [
+            ClientAction(
+                name=_('Save'),
+                submit=True,
+                class_list=['is-success'],
+                form_id=self.form_id
+            )
+        ]
+        try:
+            url = self.discard_url or self.model.get_absolute_url()
+        except TypeError:
+            raise TypeError(
+                'Supply the discard_url parameter if FormContext is called '
+                'with a model class instead of an instance.'
+            )
+        except AttributeError as e:
+            _logger.error(
+                'Supply the discard_url parameter if FormContext is '
+                'called with a model instance that has the get_absolute_url '
+                'method not defined.'
+            )
+            raise e
+
+        actions.append(
+            ClientAction(
+                name=_('Discard'),
+                url=url,
+            )
+        )
+        return actions
+
+    def get_title(self):
+        if self.title:
+            return self.title
+        try:
+            int(self.model.pk)
+            return f'Edit {self.model}'
+        except TypeError:
+            return f'Add {self.model._meta.verbose_name}'
+
+    def dict(self):
+        ctx = {
+            'title': self.get_title(),
+            'view_type': 'form',
+            'form_id': self.form_id,
+            'querystring': build_querystring(self.get_params, ['page']),
+            'actions': []
+        }
+        if self.add_default_actions:
+            ctx.update({'actions': self.get_default_form_actions()})
+        ctx['actions'].extend(self.actions)
+        ctx.update(self.context)
+        return ctx

accrete/contrib/ui/filter.py

@@ -244,10 +244,11 @@ class Filter:
             }
         ]
 
-    def cast_decimal_places_to_step(self, descimal_places):
-        if not descimal_places or descimal_places < 1:
+    @staticmethod
+    def cast_decimal_places_to_step(decimal_places):
+        if not decimal_places or decimal_places < 1:
             return '1'
-        zero_count = descimal_places - 1
+        zero_count = decimal_places - 1
         return f'0.{"0" * zero_count}1'
 
     def get_query_term(self, field):
@@ -269,24 +270,22 @@ class Filter:
         elif internal_type in self.query_date_fields:
             return self.get_date_query_term(label, param)
 
-    def get_searchable_method_term(self, model, method):
-        method_name = method['name']
-        param = '_c_' + method_name
-        method_label = str(method.get('label', method_name.capitalize()))
-        func = getattr(model, method['name'])
-        return_type = func.__annotations__.get('return')
+    def get_annotation_term(self, model, annotation):
+        name = '_a_' + annotation['name']
+        label = annotation.get('label', name)
+        return_type = annotation['type']
         if return_type == str:
-            return self.get_char_query_term(method_label, param)
+            return self.get_char_query_term(label, name)
         elif return_type == int:
-            return self.get_int_query_term(method_label, param)
+            return self.get_int_query_term(label, name)
         elif return_type in [float, Decimal]:
-            return self.get_float_query_term(method_label, param, method.get('step', 0))
+            return self.get_float_query_term(label, name, annotation.get('step', 0))
         elif return_type == bool:
-            return self.get_boolean_query_term(method_label, param)
+            return self.get_boolean_query_term(label, name)
         elif return_type == datetime.datetime:
-            return self.get_datetime_query_term(method_label, param)
+            return self.get_datetime_query_term(label, name)
         elif return_type == datetime.date:
-            return self.get_date_query_term(method_label, param)
+            return self.get_date_query_term(label, name)
 
     def get_relation_query_terms(self, model, path):
         terms = []
@@ -328,8 +327,8 @@ class Filter:
                 term['params'].extend(self.get_null_params())
             if term is not None:
                 terms.append(term)
-        for searchable_method in searchable_methods:
-            terms.append(self.get_searchable_method_term(model, searchable_method))
+        for annotation in getattr(model, 'annotations', []):
+            terms.append(self.get_annotation_term(model, annotation))
         terms = sorted(terms, key=lambda x: x['label'])
         return terms
 

accrete/contrib/ui/querystring.py

@@ -0,0 +1,93 @@
+import json
+import logging
+import operator
+from django.db.models import Model, Q
+
+_logger = logging.getLogger(__name__)
+
+
+def parse_querystring(model: type[Model], query_string: str) -> Q:
+
+    def get_expression(term: str, value) -> Q:
+        invert = False
+        if term.startswith('~'):
+            invert = True
+            term = term[1:]
+
+        parts = term.split('_a_')
+        if len(parts) == 1:
+            expression = Q(**{term: value})
+            return ~expression if invert else expression
+
+        rel_path = parts[0].rstrip('__')
+        term = parts[1]
+        rel_model = get_related_model(rel_path) if rel_path else model
+        objects = rel_model.objects.annotate(**{
+            annotation['name']: annotation['func']
+            for annotation in rel_model.annotations
+        }).filter(Q(**{term: value}))
+        expression = Q(**{
+            f'{rel_path}{"__" if rel_path else ""}id__in': objects.values_list('id', flat=True)
+        })
+
+        return ~expression if invert else expression
+
+    def get_related_model(rel_path: str):
+        related_model = model
+        for part in rel_path.split('__'):
+            try:
+                related_model = related_model._meta.fields_map[part].related_model
+            except (AttributeError, KeyError):
+                try:
+                    related_model = getattr(related_model, part).field.related_model
+                except AttributeError:
+                    break
+        return related_model
+
+    def parse_query_block(sub_item) -> Q:
+        op = ops['&']
+        parsed_query = Q()
+        for item in sub_item:
+            if isinstance(item, list):
+                parsed_query = op(parsed_query, parse_query_block(item))
+            elif isinstance(item, dict):
+                dict_query = Q()
+                for term, value in item.items():
+                    dict_query = ops['&'](dict_query, get_expression(term, value))
+                parsed_query = op(parsed_query, dict_query)
+            elif isinstance(item, str):
+                try:
+                    op = ops[item]
+                except KeyError as e:
+                    _logger.exception(e)
+                    raise ValueError(
+                        f'Invalid operator in querystring: {item}.'
+                        f'Operator must be one of &, |, ^'
+                    )
+            else:
+                raise ValueError(
+                    f'Unsupported item in querystring: {item}'
+                )
+        return parsed_query
+
+    query_data = json.loads(query_string)
+    if isinstance(query_data, dict):
+        query_data = [query_data]
+
+    ops = {'&': operator.and_, '|': operator.or_, '^': operator.xor}
+    query = parse_query_block(query_data)
+    return query
+
+
+def build_querystring(get_params: dict, extra_params: list[str] = None) -> str:
+    querystring = f'?q={get_params.get("q", "[]")}'
+    if paginate_by := get_params.get('paginate_by', False):
+        querystring += f'&paginate_by={paginate_by}'
+    if order_by := get_params.get('order_by', False):
+        querystring += f'&order_by={order_by}'
+    if crumbs := get_params.get('crumbs', False):
+        querystring += f'&crumbs={crumbs}'
+    for param in extra_params or []:
+        if value := get_params.get(param, False):
+            querystring += f'&{param}={value}'
+    return querystring