Merge pull request #23 from cloudblue/feature/LITE-18940

LITE-18490 Added Django command for filter code generation

Author: maxipavlovic

.gitignore

@@ -13,4 +13,6 @@ dist/
 tests/reports/
 .coverage
 
-docs/_build
+docs/_build
+
+_generated_filters*.py

README.md

@@ -180,6 +180,55 @@ Notes
 3. Support for Choices() fields from [Django Model Utilities](https://django-model-utils.readthedocs.io/en/latest/utilities.html#choices) is added
 
 
+Helpers
+================================
+There is a Django command `generate_rql_class` to decrease development and integration efforts for filtering.
+This command automatically generates a filter class for a given model with all relations and all optimizations (!) to the specified depth.
+
+Example
+-------
+```commandline
+django-admin generate_rql_class --settings=tests.dj_rf.settings tests.dj_rf.models.Publisher --depth=1 --exclude=authors,fk2
+```
+This command for the model `Publisher` from tests package will produce the following output to stdout:
+```python
+from tests.dj_rf.models import Publisher
+
+from dj_rql.filter_cls import RQLFilterClass
+from dj_rql.qs import NPR, NSR
+
+
+class PublisherFilters(RQLFilterClass):
+    MODEL = Publisher
+    SELECT = True
+    EXCLUDE_FILTERS = ['authors', 'fk2']
+    FILTERS = [
+    {
+        "filter": "id",
+        "ordering": True,
+        "search": False
+    },
+    {
+        "filter": "name",
+        "ordering": True,
+        "search": True
+    },
+    {
+        "namespace": "fk1",
+        "filters": [
+            {
+                "filter": "id",
+                "ordering": True,
+                "search": False
+            }
+        ],
+        "qs": NSR('fk1')
+    }
+]
+
+```
+
+
 Django Rest Framework Extensions
 ================================
 1. Pagination (limit, offset)

dj_rql/filter_cls.py

@@ -28,11 +28,12 @@
 from dj_rql.exceptions import RQLFilterLookupError, RQLFilterParsingError, RQLFilterValueError
 from dj_rql.openapi import RQLFilterClassSpecification
 from dj_rql.parser import RQLParser
-from dj_rql.qs import Annotation
+from dj_rql.qs import Annotation, NPR, NSR
 from dj_rql.transformer import RQLToDjangoORMTransformer
 
-from django.db.models import Model, Q
+from django.db.models import ForeignKey, ManyToManyField, Model, OneToOneField, OneToOneRel, Q
 from django.utils.dateparse import parse_date, parse_datetime
+from django.utils.functional import cached_property
 
 from lark.exceptions import LarkError
 
@@ -1040,8 +1041,7 @@ class AutoRQLFilterClass(RQLFilterClass):
     """This class will collect all simple model fields except the ones in this field."""
 
     def _get_init_filters(self):
-        described_filters = tuple(self.FILTERS) if self.FILTERS else ()
-
+        described_filters = self._described_filters
         filters = tuple(
             {
                 'filter': f.name,
@@ -1057,3 +1057,111 @@ def _get_init_filters(self):
         )
 
         return described_filters + filters
+
+    @cached_property
+    def _described_filters(self):
+        return tuple(self.FILTERS) if self.FILTERS else ()
+
+
+class NestedAutoRQLFilterClass(AutoRQLFilterClass):
+    """
+    Filter class that automatically collects filters for all model fields with
+    specified depth for related models.
+    """
+    SELECT = True
+
+    DEPTH = 1
+    """
+    Specifies how deep model relations will be traversed.
+    If `DEPTH = 0` this class behaves as `AutoRQLFilterClass`.
+    """
+
+    def _get_init_filters(self):
+        if self.DEPTH == 0:
+            return super()._get_init_filters()
+
+        depth = 0
+        global_namespace = []
+        iterator = [(self.MODEL, global_namespace, None, None)]
+
+        while depth <= self.DEPTH and iterator:
+            iterator = self._iter_models_to_get_filters(depth, iterator)
+            depth += 1
+
+        return self._described_filters + tuple(global_namespace)
+
+    def _iter_models_to_get_filters(self, depth, iterator):
+        related_models = []
+
+        for model_data in iterator:
+            related_models.extend(self._iter_model_to_get_filters(depth, model_data))
+
+        return related_models
+
+    def _iter_model_to_get_filters(self, depth, model_data):
+        model, namespace, circular_related_name, prefix = model_data
+        through_models = set()
+        model_related_models = []
+
+        for field in model._meta.get_fields():
+            rel_f_name = self._get_relative_field_name(field, circular_related_name, prefix)
+            if not rel_f_name:
+                continue
+
+            if field.is_relation:
+                if self._is_through_field(field):
+                    through_models.add(field.through)
+
+                relation_data = self._add_relation_to_iterated_models(depth, field, namespace)
+                model_related_models.append(relation_data + (rel_f_name,))
+                continue
+
+            namespace.append({
+                'filter': field.name,
+                'ordering': True,
+                'search': FilterTypes.field_filter_type(field) == FilterTypes.STRING,
+            })
+
+        return [i for i in model_related_models if i[0] not in through_models]
+
+    def _add_relation_to_iterated_models(self, depth, field, namespace):
+        if isinstance(field, (ForeignKey, ManyToManyField)):
+            circular_related_name = field.remote_field.name
+        else:
+            circular_related_name = field.field.name
+
+        namespace_filters = []
+        if depth < self.DEPTH:
+            namespace.append({
+                'namespace': field.name,
+                'filters': namespace_filters,
+                'qs': self._get_field_optimization(field),
+            })
+
+        return field.related_model, namespace_filters, circular_related_name
+
+    def _get_relative_field_name(self, field, circular_related_name, prefix):
+        field_name = field.name
+        if circular_related_name and field_name == circular_related_name:
+            # This is needed to avoid circular dependencies
+            return
+
+        rel_f_name = '.'.join((prefix, field_name)) if prefix else field_name
+        if rel_f_name in self.EXCLUDE_FILTERS or rel_f_name in self._described_filters:
+            return
+
+        return rel_f_name
+
+    def _get_field_optimization(self, field):
+        if not self.SELECT:
+            return
+
+        if isinstance(field, (ForeignKey, OneToOneField, OneToOneRel)):
+            return NSR(field.name)
+
+        if not self._is_through_field(field):
+            return NPR(field.name)
+
+    @staticmethod
+    def _is_through_field(field):
+        return getattr(field, 'through', None)

dj_rql/management/__init__.py

@@ -0,0 +1,116 @@
+#
+#  Copyright © 2021 Ingram Micro Inc. All rights reserved.
+#
+
+import json
+import re
+
+from dj_rql.filter_cls import NestedAutoRQLFilterClass
+
+from django.core.management import BaseCommand
+from django.db.models import ForeignKey, OneToOneField, OneToOneRel
+from django.utils.module_loading import import_string
+
+
+TEMPLATE = """from {model_package} import {model_name}
+
+from dj_rql.filter_cls import RQLFilterClass
+{optimizations_import}
+
+class {model_name}Filters(RQLFilterClass):
+    MODEL = {model_name}
+    SELECT = {select_flag}
+    EXCLUDE_FILTERS = {exclusions}
+    FILTERS = {filters}
+"""
+
+
+class Command(BaseCommand):
+    help = (
+        'Automatically generates a filter class for a model '
+        'with all relations to the specified depth.'
+    )
+
+    def add_arguments(self, parser):
+        parser.add_argument(
+            'model',
+            nargs=1,
+            type=str,
+            help='Importable model location string.',
+        )
+        parser.add_argument(
+            '-d',
+            '--depth',
+            type=int,
+            default=1,
+            help='Max depth of traversed model relations.',
+        )
+        parser.add_argument(
+            '-s',
+            '--select',
+            action='store_true',
+            default=True,
+            help='Flag to include QuerySet optimizations: true by default.',
+        )
+        parser.add_argument(
+            '-e',
+            '--exclude',
+            type=str,
+            help='List of coma separated filter names or namespace to be excluded from generation.',
+        )
+
+    def handle(self, *args, **options):
+        model_import = options['model'][0]
+        model = import_string(model_import)
+        is_select = options['select']
+        exclusions = options['exclude'].split(',') if options['exclude'] else []
+
+        class Cls(NestedAutoRQLFilterClass):
+            MODEL = model
+            DEPTH = options['depth']
+            SELECT = is_select
+            EXCLUDE_FILTERS = exclusions
+
+            def _get_init_filters(self):
+                self.init_filters = super()._get_init_filters()
+
+                self.DEPTH = 0
+                self.SELECT = False
+                return super()._get_init_filters()
+
+            def _get_field_optimization(self, field):
+                if not self.SELECT:
+                    return
+
+                if isinstance(field, (ForeignKey, OneToOneField, OneToOneRel)):
+                    return "NSR('{0}')".format(field.name)
+
+                if not self._is_through_field(field):
+                    return "NPR('{0}')".format(field.name)
+
+        filters = Cls(model._default_manager.all()).init_filters
+        filters_str = json.dumps(filters, sort_keys=False, indent=4).replace(
+            '"ordering": true', '"ordering": True',
+        ).replace(
+            '"ordering": false', '"ordering": False',
+        ).replace(
+            '"search": true', '"search": True',
+        ).replace(
+            '"search": false', '"search": False',
+        ).replace(
+            '"qs": null', '"qs": None',
+        )
+
+        filters_str = re.sub(r"\"((NPR|NSR)\('\w+?'\))\"", r'\1', filters_str)
+
+        model_package, model_name = model_import.rsplit('.', 1)
+        code = TEMPLATE.format(
+            model_package=model_package,
+            model_name=model_name,
+            filters=filters_str,
+            select_flag='True' if is_select else 'False',
+            optimizations_import='from dj_rql.qs import NPR, NSR\n' if is_select else '',
+            exclusions=exclusions,
+        )
+
+        return code

dj_rql/management/commands/__init__.py

@@ -75,6 +75,10 @@ Filter classes
    :members:
 
 
+.. autoclass:: dj_rql.filter_cls.NestedAutoRQLFilterClass
+   :members:
+
+
 DB optimization
 ---------------
 

dj_rql/management/commands/generate_rql_class.py

@@ -2,11 +2,11 @@
 test = pytest
 
 [flake8]
-exclude = .idea,.git,venv*/,.eggs/,*.egg-info
+exclude = .idea,.git,venv*/,.eggs/,*.egg-info,_generated_filters*.py
 max-line-length = 100
 show-source = True
 ignore = W605
 
 [tool:pytest]
-addopts = --create-db --nomigrations --junitxml=tests/reports/out.xml --cov=dj_rql --cov-report xml:tests/reports/coverage.xml
+addopts = --show-capture=no --create-db --nomigrations --junitxml=tests/reports/out.xml --cov=dj_rql --cov-report xml:tests/reports/coverage.xml
 DJANGO_SETTINGS_MODULE = tests.dj_rf.settings