accrete 0.0.36__tar.gz → 0.0.38__tar.gz

{accrete-0.0.36 → accrete-0.0.38}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: accrete
-Version: 0.0.36
+Version: 0.0.38
 Summary: Django Shared Schema Multi Tenant
 Author-email: Benedikt Jilek <benedikt.jilek@pm.me>
 License: Copyright (c) 2023 Benedikt Jilek

accrete-0.0.38/accrete/annotation.py

@@ -0,0 +1,46 @@
+from django.db.models import Field, QuerySet
+from django.db.models.expressions import Func
+from django.db.models.aggregates import Aggregate
+
+
+class Annotation:
+
+    def __init__(
+            self,
+            verbose_name: str,
+            field: type[Field],
+            function: type[Func] | type[Aggregate],
+            help_text: str = '',
+            **kwargs
+    ):
+        self.verbose_name = verbose_name or self
+        self.field = field
+        self.function = function
+        self.help_text = help_text
+        self.__dict__.update(kwargs)
+
+
+class AnnotationModelMixin:
+
+    @classmethod
+    def get_annotations(cls) -> list[dict]:
+        return list({'name': a, 'annotation': getattr(cls, a)} for a in filter(
+            lambda a:
+            not a.startswith('__')
+            and isinstance(getattr(cls, a), Annotation),
+            cls.__dict__
+        ))
+
+
+class AnnotationManagerMixin:
+
+    @staticmethod
+    def add_annotations(queryset: QuerySet):
+        model = queryset.model
+        if not hasattr(model, 'get_annotations'):
+            return queryset
+        return queryset.annotate(**{
+            annotation['name']: annotation['annotation'].function
+            for annotation in model.get_annotations()
+        })
+

{accrete-0.0.36 → accrete-0.0.38}/accrete/contrib/ui/__init__.py

@@ -4,18 +4,15 @@ from .context import (
     TableContext,
     ListContext,
     FormContext,
-    default_form_actions,
-    Page,
-    ListContent,
-    DetailContent,
-    FormContent,
-    get_list_page,
-    get_detail_page,
+    form_actions,
+    list_page,
+    detail_page,
     cast_param,
     prepare_url_params,
     extract_url_params,
     exclude_params,
-    url_param_str
+    url_param_str,
+    get_table_fields
 )
 from .elements import (
     ClientAction,
@@ -26,7 +23,3 @@ from .elements import (
     TableFieldType,
     Icon
 )
-from .querystring import (
-    load_querystring,
-    build_querystring,
-)

accrete-0.0.38/accrete/contrib/ui/context.py

@@ -0,0 +1,238 @@
+import logging
+from dataclasses import dataclass, field
+from typing import TypedDict
+from django.utils.translation import gettext_lazy as _t
+from django.db import models
+from django.db.models import Model, QuerySet
+from django.core.paginator import Paginator
+from django.core import paginator
+from django.forms import Form, ModelForm
+from accrete.utils.models import get_related_model
+from accrete.annotation import Annotation
+from .elements import (
+    ClientAction, BreadCrumb, TableField, TableFieldType, TableFieldAlignment
+)
+from .filter import Filter
+
+
+_logger = logging.getLogger(__name__)
+
+DEFAULT_PAGINATE_BY = 40
+
+
+class DetailPagination(TypedDict):
+    previous_object_url: str
+    next_object_url: str
+    current_object_idx: int
+    total_objects: int
+
+
+@dataclass(kw_only=True)
+class Context:
+
+    title: str = ''
+    breadcrumbs: list[BreadCrumb] = field(default_factory=list)
+    actions: list[ClientAction] = field(default_factory=list)
+    kwargs: dict = field(default_factory=dict)
+
+    def __post_init__(self):
+        for key, value in self.kwargs.items():
+            setattr(self, key, value)
+
+    def dict(self):
+        return {
+            attr: getattr(self, attr, '') for attr
+            in filter(lambda x: not x.startswith('_'), self.__dict__)
+        }
+
+
+@dataclass
+class TableContext(Context):
+
+    object_label: str
+    fields: list[TableField]
+    list_page: paginator.Page
+    pagination_param_str: str
+    endless_scroll: bool
+    filter: Filter
+    object_param_str: str = field(default='', kw_only=True)
+
+
+@dataclass
+class ListContext(Context):
+
+    object_label: str
+    object_param_str: str
+    list_page: paginator.Page
+    pagination_param_str: str
+    filter: Filter
+    endless_scroll: bool = True
+    column_height: int = 4
+    column_width: int = 12
+
+    def __post_init__(self):
+        super().__post_init__()
+        if self.column_width not in range(1, 13):
+            _logger.warning(
+                'ListContext parameter column_width should be in range 1 - 12'
+            )
+
+
+class DetailContext(TypedDict, total=False):
+
+    title: str
+    object: Model
+    breadcrumbs: list[BreadCrumb]
+    detail_page: DetailPagination
+    pagination_param_str: str
+    actions: list[ClientAction]
+
+
+class FormContext(TypedDict, total=False):
+
+    title: str
+    breadcrumbs: list[BreadCrumb]
+    form: Form | ModelForm
+    form_id: str
+    actions: list[ClientAction]
+
+
+def cast_param(params: dict, param: str, cast_to: callable, default):
+    if param not in params:
+        return default
+    try:
+        return cast_to(params.get(param, default))
+    except Exception as e:
+        _logger.exception(e)
+        return default
+
+
+def prepare_url_params(get_params: dict) -> dict:
+    return {key: f'&{key}={value}' for key, value in get_params.items()}
+
+
+def url_param_str(params: dict, extract: list[str] = None) -> str:
+    """
+    Return a URL Querystring from the given parameters
+    If extract is supplied, extract the value from the dictionary and prepare
+    them, so that each value is formatted e.g. {'page': '&page=1'}
+    """
+    if extract:
+        params = prepare_url_params(extract_url_params(params, extract))
+    param_str = (
+        "".join(str(value) for value in params.values())
+        .replace('&&', '&')
+        .replace('?&', '?')
+        .strip('?&')
+    )
+    return f'?{param_str}'
+
+
+def extract_url_params(params: dict, keys: list[str]) -> dict:
+    return {key: params[key] for key in keys if key in params}
+
+
+def exclude_params(params: dict, keys: list[str]) -> dict:
+    return {key: val for key, val in params.items() if key not in keys}
+
+
+def list_page(queryset: QuerySet, paginate_by: int, page_number: int) -> paginator.Page:
+    pages = Paginator(queryset, per_page=paginate_by)
+    return pages.page(page_number <= pages.num_pages and page_number or pages.num_pages)
+
+
+def detail_page(queryset: QuerySet, obj: Model) -> dict:
+    if not hasattr(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 {}
+    idx = (*queryset,).index(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()
+    return {
+        'previous_object_url': previous_object_url,
+        'next_object_url': next_object_url,
+        'current_object_idx': idx + 1,
+        'total_objects': queryset.count()
+    }
+
+
+def form_actions(discard_url: str, form_id: str = 'form') -> list[ClientAction]:
+    return [
+        ClientAction(
+            name=_t('Save'),
+            submit=True,
+            class_list=['is-success'],
+            form_id=form_id,
+        ),
+        ClientAction(
+            name=_t('Discard'),
+            url=discard_url
+        )
+    ]
+
+
+def get_table_fields(
+        fields: list[str],
+        model: type[Model],
+        field_definition: dict[str | TableField] = None
+) -> list[TableField]:
+
+    def get_alignment(field_attr):
+        number_field_types = (
+            models.DecimalField, models.IntegerField, models.FloatField
+        )
+        if (
+                isinstance(field_attr, number_field_types)
+                or (
+                isinstance(field_attr, Annotation)
+                and field_attr.field in number_field_types
+        )):
+            return TableFieldAlignment.RIGHT
+        return TableFieldAlignment.LEFT
+
+
+    def get_field_definition(f_name: str) -> TableField:
+        if definition := field_definition.get(f_name):
+            return definition
+        parts = f_name.split('__')
+        if len(parts) == 1:
+            rel_model = model
+            names = [rel_model._meta.verbose_name]
+        else:
+            rel_model, names = get_related_model(model, f_name)
+        try:
+            return rel_model.table_field_definition[parts[-1]]
+        except (AttributeError, KeyError):
+            attr = getattr(rel_model, parts[-1])
+            if isinstance(attr, Annotation):
+                pass
+            elif hasattr(attr, 'field'):
+                attr = attr.field
+        names.append(attr.verbose_name)
+        return TableField(
+            label=' / '.join([str(name) for name in names[1:]]),
+            name=f_name,
+            header_info=str(attr.help_text),
+            truncate_after=50,
+            alignment=get_alignment(attr)
+        )
+
+    if field_definition is None:
+        field_definition = {}
+
+    table_fields = []
+    for field_name in fields:
+        try:
+            table_fields.append(get_field_definition(field_name))
+        except AttributeError as e:
+            print(e)
+            pass
+    return table_fields

{accrete-0.0.36 → accrete-0.0.38}/accrete/contrib/ui/filter.py

@@ -1,8 +1,12 @@
 import time
 import logging
+from django.db import models
 from django.core.cache import cache
 from django.utils.translation import gettext_lazy as _
 from django.utils.safestring import mark_safe
+from django.utils.translation import get_language
+
+from accrete.annotation import Annotation
 
 _logger = logging.getLogger(__name__)
 
@@ -30,7 +34,7 @@ class Filter:
         self.query_relation_depth = query_relation_depth
         self.default_exclude = default_exclude or ['tenant', 'user']
         self.default_filter_term = default_filter_term or ''
-        self.fields = {}
+        self.fields = []
         self.field_paths = []
 
     @staticmethod
@@ -43,8 +47,8 @@ class Filter:
     def get_fields(self, model_path: list, field_path: str):
         fields = self.get_local_fields(model_path[-1], field_path)
         if len(model_path) <= self.query_relation_depth:
-            fields.update(self.get_relation_fields(model_path, field_path))
-        return fields
+            fields.extend(self.get_relation_fields(model_path, field_path))
+        return sorted(fields, key=lambda x: x['label'].lower())
 
     def get_relation_fields(self, model_path, field_path):
         filter_exclude = getattr(model_path[-1], 'filter_exclude', [])
@@ -53,7 +57,7 @@ class Filter:
             lambda x: x.is_relation and x.name not in filter_exclude,
             model_path[-1]._meta.get_fields()
         )
-        res = {}
+        res = []
         for field in fields:
             if field.related_model in model_path:
                 continue
@@ -64,13 +68,14 @@ class Filter:
                 label = field.verbose_name
             except AttributeError:
                 label = field.related_model._meta.verbose_name
-            res[field.name] = {
-                'label': label,
+            res.append({
+                'name': f'{rel_path}',
+                'label': str(label),
                 'type': field.get_internal_type(),
                 'null': field.null,
                 'choices': [],
                 'fields': self.get_fields(model_path_copy, rel_path)
-            }
+            })
         return res
 
     def get_local_fields(self, model, path):
@@ -80,34 +85,39 @@ class Filter:
             lambda x: not x.is_relation and x.name not in filter_exclude,
             model._meta.get_fields()
         )
-        res = {}
+        res = []
         for field in fields:
-            res.update({
-                f'{path}{"__" if path else ""}{field.name}': {
-                    'label': field.verbose_name,
-                    'type': field.get_internal_type(),
-                    'choices': field.choices or [],
-                    'null': field.null,
-                    'step': hasattr(field, 'decimal_places')
-                            and self.cast_decimal_places_to_step(field.decimal_places)
-                            or 1
-                }
+            field_path = f'{path}{"__" if path else ""}{field.name}'
+            self.field_paths.append(field_path)
+            step = (hasattr(field, 'decimal_places')
+                    and self.cast_decimal_places_to_step(field.decimal_places)
+                    or 1)
+            res.append({
+                'name': field_path,
+                'label': str(field.verbose_name),
+                'type': field.get_internal_type(),
+                'choices': field.choices or [],
+                'null': field.null,
+                'step': step
             })
-        for annotation in getattr(model, 'annotations', []):
-            res.update({
-                f'{path}{"__" if path else ""}_a_{annotation["name"]}': {
-                    'label': annotation['label'],
-                    'type': annotation['type'].__name__,
-                    'choices': [],
-                    'null': False,
-                    'step': self.cast_decimal_places_to_step(annotation.get('decimal_places', 1))
-                }
+        if not hasattr(model, 'get_annotations'):
+            return res
+        for annotation in model.get_annotations():
+            field_path = f'{path}{"__" if path else ""}{annotation["name"]}'
+            self.field_paths.append(field_path)
+            res.append({
+                'name': field_path,
+                'label': str(annotation['annotation'].verbose_name),
+                'type': annotation['annotation'].field.__name__,
+                'choices': [],
+                'null': False,
+                'step': getattr(annotation['annotation'], 'step', '1')
             })
         return res
 
     def to_html(self):
         start = time.time()
-        key = f'filter-terms-{self.model.__module__}.{self.model.__name__}'
+        key = f'filter-{self.model.__module__}.{self.model.__name__}-{get_language()}'
         html = cache.get(key)
         if html:
             _logger.info(f'Fetching Filter-Terms from cache in {time.time() - start} seconds')
@@ -115,22 +125,27 @@ class Filter:
         if not self.fields:
             self.fields = self.get_fields([self.model], '')
         html = ''
-        for k, v in self.fields.items():
-            html += self.field_params(k, v)
-        html = mark_safe(html.strip().replace('\n', ''))
+        for f in self.fields:
+            html += self.field_params(f)
+        html = {
+            'params': mark_safe(html.strip().replace('\n', '')),
+            'field_paths': mark_safe(
+                self.field_path_selection().strip().replace('\n', '')
+            )
+        }
         cache.set(key, html, 60 * 15)
         _logger.info(f'Generated Filter-Terms in {time.time() - start} seconds')
-        return html
+        return {'params': html['params'], 'field_paths': html['field_paths']}
 
-    def field_params(self, key, value):
+    def field_params(self, field):
         params = ''
-        params += self.params(key, value)
-        for k, v in value.get('fields', {}).items():
-            params += self.field_params(k, v)
+        params += self.params(field)
+        for f in field.get('fields', []):
+            params += self.field_params(f)
         return f"""
-            <div class="query-param" tabindex="-1" data-param="{key}" data-param-label="{value['label']}">
-                <p class="px-1 arrow">{value['label']}</p>
-                <div class="query-params is-hidden" data-param="{key}">
+            <div class="query-param" tabindex="-1" data-param="{field['name']}" data-param-label="{field['label']}">
+                <p class="px-1 arrow">{field['label']}</p>
+                <div class="query-params is-hidden" data-param="{field['name']}">
                     {params}
                 </div>
             </div>
@@ -158,8 +173,8 @@ class Filter:
             for choice in choices
         ])
 
-    def params(self, key, value):
-        return self.field_map().get(value['type'], self.no_param)(key, value)
+    def params(self, field):
+        return self.field_map().get(field['type'], self.no_param)(field['name'], field)
 
     def param(
             self, key: str, value: dict, param: str, data_type: str,
@@ -195,7 +210,6 @@ class Filter:
             html += param_div(inverted=True)
         return html
 
-
     def char_param(self, key, value):
         if value.get('choices'):
             return self.char_choice_param(key, value)
@@ -262,7 +276,10 @@ class Filter:
         return ''
 
     def null_param(self, key, value):
-        options = self.parse_choices([('true', _('True')), ('false', _('False'))])
+        options = self.parse_choices([
+            ('true', _('True')),
+            ('false', _('False'))
+        ])
         return f"""
             <div id="filter-id-~{key}__isnull"
                  class="query-param" tabindex="-1" data-type="selection"
@@ -278,3 +295,48 @@ class Filter:
 
     def no_param(self, key, value):
         return ''
+
+    def field_path_selection(self):
+        html = ''
+        for field in sorted(self.field_paths, key=lambda f: (len(f.split('__')), f.lower())):
+            label = self.get_field_path_label(field)
+            if not label:
+                continue
+            html += f"""
+                <label class="checkbox my-1" style="width: 100%">
+                    <input type="checkbox" name="{field}">
+                    {label}
+                </label>
+            """
+        return html
+
+    def get_field_path_label(self, field_path):
+        label_parts = []
+        model = self.model
+        for field_part in field_path.split('__'):
+            if field_part.startswith('_a_'):
+                field_part = field_part.removeprefix('_a_')
+                annotations = {
+                    annotation['name']: annotation
+                    for annotation in getattr(model, 'annotations', [])
+                }
+                if annotations.get(field_part):
+                    label_parts.append(str(annotations[field_part]['label']))
+                    return ' / '.join(label_parts)
+                return False
+
+            field = getattr(model, field_part, False)
+
+            if not field:
+                return False
+
+            if isinstance(field.field, models.ForeignKey):
+                model = field.field.related_model
+                label_parts.append(str(model._meta.verbose_name))
+                continue
+
+            if not isinstance(field, Annotation):
+                field = field.field
+
+            label_parts.append(str(field.verbose_name))
+        return ' / '.join(label_parts)