accrete 0.0.99__py3-none-any.whl → 0.0.109__py3-none-any.whl

accrete/contrib/ui/filter.py

@@ -1,17 +1,24 @@
+import json
 import logging
-from django.db.models.fields.related import ManyToOneRel, ManyToManyRel
-from django.core.cache import cache
+import datetime
+from decimal import Decimal
+
+from django.db.models import QuerySet
+from django.http.request import QueryDict
+from django.db.models.fields import Field
+from django.template.loader import render_to_string
 from django.utils.translation import gettext_lazy as _
 from django.utils.safestring import mark_safe
-from django.utils.translation import get_language
+from django.apps import apps
+from django.core import paginator
+from accrete.utils.models import get_related_model, get_related_field
+from accrete.utils import page_from_querystring, filter_from_querystring
 
 _logger = logging.getLogger(__name__)
 
 
 class Filter:
 
-    query_relation_depth = 4
-
     LABEL_EXACT = _('Equals')
     LABEL_EXACT_NOT = _('Equals Not')
     LABEL_ICONTAINS = _('Contains')
@@ -22,302 +29,324 @@ class Filter:
     LABEL_FALSE = _('False')
     LABEL_SET = _('Is Set')
     LABEL_NOT_SET = _('Is Not Set')
+    LABEL_AND = _('And')
+    LABEL_OR = _('Or')
+    LABEL_XOR = _('Not Or')
+
+    # EXCLUDE = ['tenant']
+
+    DATE_FORMAT = '%Y-%m-%d'
+
+    TYPES_INTEGER = [
+        'AutoField', 'BigAutoField', 'IntegerField', 'PositiveSmallIntegerField'
+    ]
+    TYPES_NUMBER = ['DecimalField', 'FloatField']
+    TYPES_CHAR = ['CharField', 'TextField']
+    TYPES_BOOL = ['BooleanField']
+    TYPES_DATETIME = ['DateTimeField']
+    TYPES_DATE = ['DateField']
+    TYPES_TIME = ['TimeField']
 
     def __init__(
-            self, model, query_relation_depth: int = 4,
-            default_exclude: list[str] = None, default_filter_term: str = None
+        self, model, query: QueryDict, default_lookup: str = None
     ):
         self.model = model
-        self.query_relation_depth = query_relation_depth
-        if default_exclude is None:
-            default_exclude = ['tenant', 'user']
-        self.default_exclude = default_exclude
-        self.default_filter_term = default_filter_term or ''
-        self.fields = []
-        self.field_paths = []
+        self.query = query
+        self.model_name = f'{self.model._meta.app_label}.{self.model._meta.model_name}'
+        seen_models = query.get('models', '').split(',')
+        self.seen_models = [
+            model for model in seen_models
+            if model and model != self.model_name
+        ] + [self.model_name]
+        self.default_lookup = default_lookup
+        self.exclude = []
+        if hasattr(self.model, 'exclude_from_filter'):
+            self.exclude.extend(self.model.exclude_from_filter())
 
-    @staticmethod
-    def cast_decimal_places_to_step(decimal_places):
-        if not decimal_places or decimal_places < 1:
-            return '1'
-        zero_count = decimal_places - 1
-        return f'0.{"0" * zero_count}1'
+    def get_page(self, select_related: list = None, prefetch_related: list = None) -> paginator.Page:
+        return page_from_querystring(
+            self.model,
+            self.query,
+            select_related=select_related,
+            prefetch_related=prefetch_related
+        )
 
-    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.extend(self.get_relation_fields(model_path, field_path))
-        return sorted(fields, key=lambda x: x['label'].lower())
+    def get_queryset(self) -> QuerySet:
+        return filter_from_querystring(self.model, self.query)
 
-    def get_relation_fields(self, model_path, field_path):
-        filter_exclude = getattr(model_path[-1], 'filter_exclude', [])
-        filter_exclude.extend(self.default_exclude)
+    def query_params(self):
         fields = filter(
-            lambda x: x.is_relation and x.name not in filter_exclude,
-            model_path[-1]._meta.get_fields()
+            lambda x: x.name not in self.exclude,
+            self.model._meta.get_fields()
         )
-        res = []
+        params = []
+        path = self.query.get('path', '')
         for field in fields:
-            if field.related_model in model_path:
-                continue
-            rel_path = f'{field_path}{"__" if field_path else ""}{field.name}'
-            model_path_copy = model_path.copy()
-            model_path_copy.append(field.related_model)
-            try:
-                label = field.verbose_name
-            except AttributeError:
-                label = field.related_model._meta.verbose_name
-            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):
-        filter_exclude = getattr(model, 'filter_exclude', [])
-        filter_exclude.extend(self.default_exclude)
-        fields = filter(
-            lambda x: not x.is_relation and x.name not in filter_exclude,
-            model._meta.get_fields()
+            field_params = self._get_field_params(field)
+            if not field.is_relation or field_params['model_name'] not in self.seen_models:
+                params.append(self._get_field_params(field))
+        has_previous = len(self.seen_models) > 1
+        ctx = dict(
+            params=sorted(params, key=lambda x: x['label'].lower()),
+            model_name=self.model_name,
+            seen_models=','.join(self.seen_models),
+            verbose_model_name=self.model._meta.verbose_name,
+            has_previous=has_previous,
         )
-        res = []
-        for field in fields:
-            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
-            })
-        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):
-        key = f'filter-{self.model.__module__}.{self.model.__name__}-{get_language()}'
-        html = cache.get(key)
-        if html:
-            return html
-        if not self.fields:
-            self.fields = self.get_fields([self.model], '')
-        html = ''
-        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', '')
+        if has_previous:
+            previous_model_name = self.seen_models[-2]
+            previous_path = '__'.join(path.split('__')[:-1])
+            ctx.update(
+                previous_model_name=previous_model_name,
+                previous_seen_models=','.join(
+                    self.seen_models[:-1] if has_previous else []
+                ),
+                previous_verbose_model_name=apps.get_model(
+                    *previous_model_name.split('.')
+                )._meta.verbose_name,
+                previous_path=previous_path
             )
-        }
-        cache.set(key, html, 60 * 15)
-        return {'params': html['params'], 'field_paths': html['field_paths']}
+        return render_to_string('ui/filter/query_params.html', ctx)
 
-    def field_params(self, field):
-        params = ''
-        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="{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>
-         """
-
-    def field_map(self):
-        return {
-            'CharField': self.char_param,
-            'TextField': self.char_param,
-            'DecimalField': self.float_param,
-            'FloatField': self.float_param,
-            'BooleanField': self.bool_param,
-            'IntegerField': self.int_param,
-            'AutoField': self.int_param,
-            'BigAutoField': self.int_param,
-            'PositiveSmallIntegerField': self.int_param,
-            'DateTimeField': self.date_time_param,
-            'DateField': self.date_param,
-            'ForeignKey': self.foreign_key_param,
-            'FileField': self.file_param,
-            'ImageField': self.file_param
+    def query_input(self, lookup: str = None):
+        lookup = lookup or self.default_lookup
+        if not lookup:
+            ctx = {
+                'verbose_lookup': str(_('Select an attribute')),
+                'query_dict': self.query,
+                'model_name': self.model_name
+            }
+            return render_to_string('ui/filter/query_input.html', ctx)
+        prefix = lookup.startswith('~') and '~' or ''
+        lookup = lookup.removeprefix('~')
+        lookup_parts = lookup.split('__')
+        lookup_operator = lookup_parts[-1]
+        rel_path = '__'.join(lookup_parts[:-2])
+        model, names = get_related_model(self.model, rel_path)
+        field = model._meta.get_field(lookup_parts[-2])
+        input_params = self._get_input_params(field, lookup_operator)
+        ctx = {
+            'verbose_lookup': ' > '.join(self._get_query_tag_lhs(prefix + lookup)),
+            'field': field,
+            'lookup': prefix + lookup,
+            'input': input_params,
+            'lookup_operator': lookup_operator,
+            'query_dict': self.query,
+            'model_name': self.model_name
         }
+        return render_to_string('ui/filter/query_input.html', ctx)
 
-    def parse_choices(self, choices):
-        return ''.join([
-            f'<option value="{choice[0]}">{choice[1]}</option>'
-            for choice in choices
-        ])
-
-    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,
-            options: str, invert: bool = True
-    ):
-
-        def get_label(inverted=False):
-            if param == 'exact':
-                return self.LABEL_EXACT_NOT if inverted else self.LABEL_EXACT
-            if param == 'icontains':
-                return self.LABEL_ICONTAINS_NOT if inverted else self.LABEL_ICONTAINS
-            if param == 'gte':
-                return self.LABEL_GTE
-            if param == 'lte':
-                return self.LABEL_LTE
-
-        def param_div(inverted=False):
-            return f"""
-                <div id="filter-id-{'~' if inverted else ''}{key}__{param}"
-                     class="query-param" tabindex="-1" data-type="{data_type}"
-                     data-step="{value.get('step', 1)}"
-                     data-param="{param}" data-param-label="{value.get("label")}"
-                >
-                    <p class="px-1 arrowless">{get_label(inverted)}</p>
-                    <div class="param-options is-hidden">
-                        {options if options else ''}
-                    </div>
-                </div>
-            """
-
-        html = param_div()
-        if invert:
-            html += param_div(inverted=True)
-        return html
-
-    def char_param(self, key, value):
-        if value.get('choices'):
-            return self.char_choice_param(key, value)
-        options = self.parse_choices(value.get('choices', ''))
-        html = self.param(key, value, 'icontains', 'text', options)
-        html += self.param(key, value, 'exact', 'text', options)
-        if value.get('null'):
-            html += self.null_param(key, value)
-        return html
-
-    def char_choice_param(self, key, value):
-        options = self.parse_choices(value.get('choices', []))
-        html = self.param(key, value, 'exact', 'selection', options)
-        if value.get('null'):
-            html += self.null_param(key, value)
-        return html
-
-    def float_param(self, key, value):
-        options = self.parse_choices(value.get('choices', ''))
-        html = self.param(key, value, 'exact', 'number', options)
-        html += self.param(key, value, 'gte', 'number', options, False)
-        html += self.param(key, value, 'lte', 'number', options, False)
-        if value.get('null'):
-            html += self.null_param(key, value)
-        return html
+    def query_tags(self, query: list | dict = None, operator: str = None):
+        if not query:
+            query = json.loads(self.query.get('q', '[]'))
+        if isinstance(query, dict):
+            query = [query]
+        operator = operator or '&'
+        html = '<div class="query-group-container">'
+        html += render_to_string(
+            'ui/filter/query_operator.html', {'operator': operator}
+        )
+        html += (
+            '<div class="query-group" '
+            'x-sort="applyQuery();" x-sort:group="query" '
+            'x-sort:config="{preventOnFilter: false}">'
+        )
+        for idx, item in enumerate(query):
+            if isinstance(item, str):
+                continue
+            operator = '&'
+            if idx > 0 and isinstance(query[idx - 1], str):
+                operator = query[idx - 1]
+            if isinstance(item, list):
+                html += self.query_tags(item, operator)
+            if isinstance(item, dict):
+                item_ctx = self._get_query_tag_context(item, operator)
+                html += render_to_string('ui/filter/query_tags.html', item_ctx)
+        html += '</div></div>'
+        return mark_safe(html)
 
-    def bool_param(self, key, value):
-        options = self.parse_choices([('true', _('True')), ('false', _('False'))])
-        html = self.param(key, value, 'exact', 'selection', options)
-        if value.get('null'):
-            html += self.null_param(key, value)
-        return html
+    def _get_input_params(self, field: Field, lookup_operator: str):
+        field_type = field.get_internal_type()
+        params = {
+            'field_type': field_type,
+            'data_type': self._internal_type_to_data_type(field_type, lookup_operator)
+        }
+        if lookup_operator == 'isnull':
+            params.update(
+                input_type='select',
+                choices=[('false', str(_('True'))), ('true', str(_('False')))],
+                data_type='bool'
+            )
+            return params
+        if field_type in self.TYPES_BOOL:
+            params.update(
+                input_type='select',
+                choices=[('true', str(_('True'))), ('false', str(_('False')))],
+                data_type='bool'
+            )
+            return params
+        elif field_type in self.TYPES_INTEGER:
+            if field.choices:
+                params.update(input_type='select', choices=field.choices)
+            else:
+                params.update(input_type='number', step=1)
+        elif field_type in self.TYPES_NUMBER:
+            step = (
+                hasattr(field, 'decimal_places')
+                and self._cast_decimal_places_to_step(field.decimal_places)
+                or 1
+            )
+            params.update(input_type='number', step=step)
+        elif field_type in self.TYPES_CHAR:
+            if field.choices:
+                params.update(input_type='select', choices=field.choices)
+            else:
+                params.update(input_type='text')
+        elif field_type in self.TYPES_DATETIME:
+            params.update(input_type='datetime-local', format=self.DATE_FORMAT)
+        elif field_type in self.TYPES_DATE:
+            params.update(input_type='date', format=self.DATE_FORMAT)
+        elif field_type in self.TYPES_TIME:
+            params.update(input_type='time')
+        return params
 
-    def int_param(self, key, value):
-        options = self.parse_choices(value.get('choices', ''))
-        html = self.param(key, value, 'exact', 'number', options)
-        html += self.param(key, value, 'gte', 'number', options, False)
-        html += self.param(key, value, 'lte', 'number', options, False)
-        if value.get('null'):
-            html += self.null_param(key, value)
-        return html
+    def _internal_type_to_data_type(self, internal_type, lookup: str):
+        if lookup == 'isnull' or internal_type in self.TYPES_BOOL:
+            return 'bool'
+        if internal_type in self.TYPES_INTEGER + self.TYPES_NUMBER:
+            return 'number'
+        return 'text'
 
-    def date_time_param(self, key, value):
-        options = self.parse_choices(value.get('choices', ''))
-        html = self.param(key, value, 'exact', 'datetime-local', options)
-        html += self.param(key, value, 'gte', 'datetime-local', options, False)
-        html += self.param(key, value, 'lte', 'datetime-local', options, False)
-        if value.get('null'):
-            html += self.null_param(key, value)
-        return html
+    def _get_query_tag_context(self, data: dict, operator: str):
+        ctx = {'tags': []}
+        first_operator = operator
+        operator = '&'
+        for key, value in data.items():
 
-    def date_param(self, key, value):
-        options = self.parse_choices(value.get('choices', ''))
-        html = self.param(key, value, 'exact', 'date', options)
-        html += self.param(key, value, 'gte', 'date', options, False)
-        html += self.param(key, value, 'lte', 'date', options, False)
-        if value.get('null'):
-            html += self.null_param(key, value)
-        return html
+            field_path = key.split('__')
+            field = get_related_field(
+                self.model, '__'.join(field_path[:-1]).removeprefix('~')
+            )
+            lookup = field_path[-1]
+            internal_type = field.get_internal_type()
+            data_type = self._internal_type_to_data_type(internal_type, lookup)
+            ctx['tags'].append({
+                'lhs': self._get_query_tag_lhs(key),
+                'rhs': self._get_query_tag_rhs(value, internal_type, lookup),
+                'lookup': key,
+                'value': value,
+                'operator': operator,
+                'data_type': data_type,
+                'model_name': self.model_name
+            })
+        if ctx['tags']:
+            ctx['tags'][0]['operator'] = first_operator
+        return ctx
 
-    def foreign_key_param(self, key, value):
-        if value.get('null'):
-            return self.null_param(key, value)
-        return ''
+    def _get_query_tag_lhs(self, lookup: str):
+        prefix = lookup.startswith('~') and '~' or ''
+        lookup = lookup.removeprefix('~')
+        parts = lookup.split('__')
+        assert len(parts) >= 2
+        related_parts = parts[:-2]
+        rel_model, names = get_related_model(
+            self.model, '__'.join(related_parts)
+        )
+        try:
+            names.extend([
+                str(rel_model._meta.get_field(parts[-2]).verbose_name),
+                str(self._get_lookup_label(f'{prefix}{parts[-1]}'))
+            ])
+        except AttributeError:
+            names.extend([
+                str(rel_model._meta.get_field(parts[-2]).field.verbose_name),
+                str(self._get_lookup_label(f'{prefix}{parts[-1]}'))
+            ])
+        return names[1:]
 
-    def file_param(self, key, value):
-        return self.null_param(key, value)
+    def _get_query_tag_rhs(self, value, internal_type, lookup):
+        if lookup == 'isnull':
+            return not value
+        if internal_type in self.TYPES_DATE:
+            return datetime.date.fromisoformat(value)
+        if internal_type in self.TYPES_DATETIME:
+            return datetime.datetime.fromisoformat(value)
+        if internal_type in self.TYPES_NUMBER:
+            return Decimal(value)
+        return value
 
-    def null_param(self, key, value):
-        options = self.parse_choices([
-            ('false', _('True')),
-            ('true', _('False'))
-        ])
-        return f"""
-            <div id="filter-id-{key}__isnull"
-                 class="query-param" tabindex="-1" data-type="selection"
-                 data-param-invert="false"
-                 data-param="isnull" data-param-label="{value.get("label")}"
-            >
-                <p class="px-1 arrowless">{self.LABEL_SET}</p>
-                <div class="param-options is-hidden">
-                    {options}
-                </div>
-            </div>
-        """
+    def _get_lookup_label(self, lookup: str):
+        labels = {
+            'exact': self.LABEL_EXACT,
+            '~exact': self.LABEL_EXACT_NOT,
+            'icontains': self.LABEL_ICONTAINS,
+            '~icontains': self.LABEL_ICONTAINS_NOT,
+            'gte': self.LABEL_GTE,
+            'lte': self.LABEL_LTE,
+            'isnull': self.LABEL_SET,
+            '~isnull': self.LABEL_NOT_SET
+        }
+        return str(labels[lookup])
 
-    def no_param(self, key, value):
-        return ''
+    def _get_field_params(self, field):
+        path = self.query.get('path', '')
+        label = ''
+        name = field.name
+        if path:
+            field_path = f'{path}__{name}'
+        else:
+            field_path = name
+        field_type = field.get_internal_type()
+        if field.concrete or not field.is_relation:
+            label = str(field.verbose_name)
+        if field.is_relation:
+            choices = None
+            step = None
+            model = ''
+            if field_type in ['ForeignKey', 'OneToOneField']:
+                model = (
+                    f'{field.related_model._meta.app_label}.'
+                    f'{field.related_model._meta.model_name}'
+                )
+                if not field.concrete:
+                    label = str(
+                        field.related_model._meta.verbose_name_plural
+                    )
+            elif field_type == 'ManyToManyField':
+                model = (
+                    f'{field.remote_field.model._meta.app_label}.'
+                    f'{field.remote_field.model._meta.model_name}'
+                )
+                if not field.concrete:
+                    label = (
+                        f'{field.remote_field.model._meta.verbose_name} / '
+                        f'{field.remote_field.verbose_name}'
+                    )
+        else:
+            step = (
+                hasattr(field, 'decimal_places')
+                and self._cast_decimal_places_to_step(field.decimal_places)
+                or 1
+            )
+            choices = field.choices or None
+            model = self.model_name
+        return {
+            'field': field,
+            'name': name,
+            'field_path': field_path,
+            'label': label,
+            'type': field_type,
+            'param_type': '',
+            'choices': choices,
+            'null': field.null,
+            'step': step,
+            'is_relation': field.is_relation,
+            'model_name': model,
+        }
 
-    def field_path_selection(self):
-        html = ''
-        filter_exclude = getattr(self.model, 'filter_exclude', [])
-        filter_exclude.extend(self.default_exclude)
-        fields = [(x.verbose_name, x.name) for x in filter(
-            lambda x:
-            x.name not in filter_exclude
-            and not isinstance(x, (ManyToOneRel, ManyToManyRel)),
-            self.model._meta.get_fields()
-        )]
-        if hasattr(self.model, 'get_annotations'):
-            fields.extend([
-                (x['annotation'].verbose_name, x['name'])
-                for x in self.model.get_annotations()
-            ])
-        sorted_fields = sorted(fields, key=lambda x: x[0].lower())
-        for field in sorted_fields:
-            html += f"""
-                <label class="checkbox is-unselectable my-1" style="width: 100%">
-                    <input type="checkbox" name="{field[1]}" data-label="{field[0].lower()}">
-                    <span>{field[0]}</span>
-                </label>
-            """
-        return html
+    @staticmethod
+    def _cast_decimal_places_to_step(decimal_places):
+        if not decimal_places or decimal_places < 1:
+            return '1'
+        zero_count = decimal_places - 1
+        return f'0.{"0" * zero_count}1'