accrete 0.0.36__py3-none-any.whl → 0.0.38__py3-none-any.whl

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)