django-searchkit 0.1__py3-none-any.whl → 1.1__py3-none-any.whl

searchkit/forms/utils.py

@@ -1,8 +1,23 @@
+from modeltree import ModelTree as BaseModelTree
+from collections import OrderedDict
+from django.apps import apps
+from django.contrib import admin
+from django.contrib.contenttypes.models import ContentType
 from django.db import models
+from django.db.utils import OperationalError
 from django import forms
 from django.utils.translation import gettext_lazy as _
-from collections import OrderedDict
-from searchkit.forms import fields as searchkit_fields
+from ..filters import SearchkitFilter
+from . import fields as  searchkit_fields
+
+
+class ModelTree(BaseModelTree):
+    MAX_DEPTH = 3
+    FOLLOW_ACROSS_APPS = True
+    RELATION_TYPES = [
+        'one_to_one',
+        'many_to_one',
+    ]
 
 
 OPERATOR_DESCRIPTION = {
@@ -29,10 +44,6 @@ SUPPORTED_FIELDS = [
     models.DateField,
     models.DateTimeField,
 ]
-SUPPORTED_RELATIONS = [
-    models.ForeignKey,
-    models.OneToOneField,
-]
 
 
 FIELD_PLAN = OrderedDict((
@@ -132,18 +143,36 @@ FIELD_PLAN = OrderedDict((
 ))
 
 
-class CSS_CLASSES:
+class CssClassMixin:
     reload_on_change_css_class = "searchkit-reload-on-change"
     reload_on_click_css_class = "searchkit-reload-on-click"
 
 
-def get_filter_rules(formset):
+class MediaMixin:
+    class Media:
+        js = [
+            'admin/js/vendor/jquery/jquery.min.js',
+            'admin/js/jquery.init.js',
+            "searchkit/searchkit.js"
+        ]
+
+
+def is_searchable_model(model):
+    """
+    Check if the model is searchable by Searchkit.
+    """
+    return admin.site.is_registered(model) and SearchkitFilter in admin.site._registry[model].list_filter
+
+
+def get_searchable_models():
     """
-    Build filter rules out of the cleaned data of the formset.
-    :param formset: Formset to extract filter rules from.
-    :return: OrderedDict with filter rule pairs: field__operator: value
+    Return a queryset of searchable models.
     """
-    lookups = OrderedDict()
-    for data in formset.cleaned_data:
-        lookups[f'{data["field"]}__{data["operator"]}'] = data['value']
-    return lookups
+    # Before mirating the database we get an OperationalError when trying to
+    # access ContentType database table.
+    try:
+        models = [m for m in apps.get_models() if is_searchable_model(m)]
+        ids = [ContentType.objects.get_for_model(m).id for m in models]
+        return ContentType.objects.filter(pk__in=ids).order_by('app_label', 'model')
+    except OperationalError:
+        return ContentType.objects.all()

searchkit/migrations/0002_rename_searchkitsearch_search.py

@@ -0,0 +1,18 @@
+# Generated by Django 5.1.3 on 2025-06-07 05:46
+
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('contenttypes', '0002_remove_content_type_name'),
+        ('searchkit', '0001_initial'),
+    ]
+
+    operations = [
+        migrations.RenameModel(
+            old_name='SearchkitSearch',
+            new_name='Search',
+        ),
+    ]

searchkit/models.py

@@ -5,9 +5,7 @@ from django.contrib.contenttypes.models import ContentType
 from django.utils.translation import gettext_lazy as _
 
 
-# Create your models here.
-# TODO: Use pickled cleaned data with a char field.
-class SearchkitSearch(models.Model):
+class Search(models.Model):
     name = models.CharField(_('Search name'), max_length=255)
     contenttype = models.ForeignKey(ContentType, on_delete=models.CASCADE, verbose_name=_('Model'))
     data = PickledObjectField(_('Serialized filter rule data'))
@@ -16,8 +14,14 @@ class SearchkitSearch(models.Model):
     class Meta:
         unique_together = ('name', 'contenttype')
 
-    def get_filter_rules(self):
+    def as_lookups(self):
         lookups = OrderedDict()
         for data in self.data:
             lookups[f'{data["field"]}__{data["operator"]}'] = data['value']
         return lookups
+
+    def as_queryset(self):
+        """
+        Returns a filtered queryset for the model.
+        """
+        return self.contenttype.model_class().objects.filter(**self.as_lookups())

searchkit/templatetags/searchkit.py

@@ -1,36 +1,9 @@
 from django.template import Library
-from django.urls import reverse
 from django.contrib.admin.helpers import Fieldset
-from ..forms.utils import CSS_CLASSES
 
 
 register = Library()
 
-
-@register.simple_tag
-def searchkit_url(formset):
-    """
-    Return url to reload the formset.
-    """
-    app_label = formset.model._meta.app_label
-    model_name = formset.model._meta.model_name
-    url = reverse('searchkit_form', args=[app_label, model_name])
-    return url
-
-@register.simple_tag
-def on_change_class():
-    """
-    Return css class for on change handler.
-    """
-    return CSS_CLASSES.reload_on_change_css_class
-
-@register.simple_tag
-def on_click_class():
-    """
-    Return css class for on click handler.
-    """
-    return CSS_CLASSES.reload_on_click_css_class
-
 @register.inclusion_tag("admin/includes/fieldset.html")
 def as_fieldset(form, heading_level=2, prefix='', id_prefix=0, id_suffix='', **fieldset_kwargs):
     """

searchkit/tests.py

@@ -1,31 +1,44 @@
+from urllib.parse import urlencode
 from django.test import TestCase
-from django import forms
+from django.contrib.contenttypes.models import ContentType
+from django.contrib.auth.models import User
+from django.urls import reverse
 from example.models import ModelA
-from .searchkit import FIELD_PLAN
-from .searchkit import SearchkitForm
-from .searchkit import SearchkitFormSet
+from example.management.commands.createtestdata import Command as CreateTestData
+from searchkit.forms.utils import FIELD_PLAN
+from searchkit.forms.utils import SUPPORTED_FIELDS
+from searchkit.forms.utils import ModelTree
+from searchkit.forms import SearchForm
+from searchkit.forms import SearchkitModelForm
+from searchkit.forms import BaseSearchkitFormSet
+from searchkit.forms import searchkit_formset_factory
+from searchkit.models import Search
+from searchkit import __version__
+
+
+SearchkitFormSet = searchkit_formset_factory(model=ModelA)
+SearchkitForm = SearchkitFormSet.form
 
 
 INITIAL_DATA = [
     dict(
-        field='chars',
-        operator='exact',
+        field='model_b__chars',
+        operator='contains',
         value='anytext',
     ),
     dict(
         field='integer',
         operator='range',
-        value_0=1,
-        value_1=123,
+        value=[1, 123],
     ),
     dict(
         field='float',
-        operator='exact',
+        operator='gt',
         value='0.3',
     ),
     dict(
         field='decimal',
-        operator='exact',
+        operator='lte',
         value='1.23',
     ),
     dict(
@@ -40,18 +53,35 @@ INITIAL_DATA = [
     )
 ]
 
+add_prefix = lambda i: SearchkitFormSet().add_prefix(i)
+contenttype = ContentType.objects.get_for_model(ModelA)
 DEFAULT_PREFIX = SearchkitFormSet.get_default_prefix()
-FORM_DATA = {
-    f'{DEFAULT_PREFIX}-TOTAL_FORMS': '6',
-    f'{DEFAULT_PREFIX}-INITIAL_FORMS': '1'
-}
-for i, data in enumerate(INITIAL_DATA):
-    for key, value in data.items():
-        FORM_DATA.update({f'{DEFAULT_PREFIX}-{i}-{key}': value})
-
-
-class SearchkitFormTestCase(TestCase):
 
+def get_form_data(initial_data=INITIAL_DATA):
+    count = len(initial_data)
+    data = {
+        'name': 'test search',                  # The name of the search.
+        'searchkit_model': f'{contenttype.pk}',  # Data for the searchkit-model form.
+        f'{DEFAULT_PREFIX}-TOTAL_FORMS': f'{count}',   # Data for the managment form.
+        f'{DEFAULT_PREFIX}-INITIAL_FORMS': f'{count}', # Data for the managment form.
+    }
+    for i, d in enumerate(initial_data):
+        prefix = SearchkitFormSet().add_prefix(i)
+        for key, value in d.items():
+            if isinstance(value, list):
+                for i, v in enumerate(value):
+                    data.update({f'{prefix}-{key}_{i}': v})
+            else:
+                data.update({f'{prefix}-{key}': value})
+    return data
+
+FORM_DATA = get_form_data()
+
+
+class CheckFormMixin:
+    """
+    Mixin to check the form fields and their choices.
+    """
     def check_form(self, form):
         # Three fields should be generated on instantiation.
         self.assertIn('field', form.fields)
@@ -59,12 +89,19 @@ class SearchkitFormTestCase(TestCase):
         self.assertIn('value', form.fields)
         self.assertEqual(len(form.fields), 3)
 
-        # Check choices of the model_field.
+        # Check field choices for the model.
         form_model_field = form.fields['field']
         self.assertTrue(form_model_field.choices)
-        self.assertEqual(len(form_model_field.choices), len(ModelA._meta.fields))
-        for model_field in ModelA._meta.fields:
-            self.assertIn(model_field.name, [c[0] for c in form_model_field.choices])
+        options = [c[0] for c in form_model_field.choices]
+        tree = ModelTree(ModelA)
+        for node in tree.iterate():
+            for model_field in node.model._meta.fields:
+                if not any(isinstance(model_field, f) for f in SUPPORTED_FIELDS):
+                    continue
+                if node.is_root:
+                    self.assertIn(model_field.name, options)
+                else:
+                    self.assertIn(f'{node.field_path}__{model_field.name}', options)
 
         # Check the field_plan choosen based on the model_field.
         field_plan = next(iter([p for t, p in FIELD_PLAN.items() if t(form.model_field)]))
@@ -73,27 +110,26 @@ class SearchkitFormTestCase(TestCase):
         # Check choices of the operator field based on the field_plan.
         operator_field = form.fields['operator']
         self.assertTrue(operator_field.choices)
-        self.assertEqual(len(form_model_field.choices), len(form.field_plan))
+        self.assertEqual(len(operator_field.choices), len(form.field_plan))
         for operator in form.field_plan.keys():
             self.assertIn(operator, [c[0] for c in operator_field.choices])
 
 
+class SearchkitFormTestCase(CheckFormMixin, TestCase):
+
     def test_blank_searchkitform(self):
-        for index in range(3):
-            prefix = SearchkitFormSet(ModelA).add_prefix(index)
-            form = SearchkitForm(ModelA, prefix=prefix)
-            self.check_form(form)
+        form = SearchkitForm(prefix=add_prefix(0))
+        self.check_form(form)
 
-            # Form should not be bound or valid.
-            self.assertFalse(form.is_bound)
-            self.assertFalse(form.is_valid())
+        # Form should not be bound or valid.
+        self.assertFalse(form.is_bound)
+        self.assertFalse(form.is_valid())
 
     def test_searchkitform_with_invalid_model_field_data(self):
-        prefix = SearchkitFormSet(ModelA).add_prefix(0)
         data = {
-            f'{prefix}-field': 'foobar',
+            f'{add_prefix(0)}-field': 'foobar',
         }
-        form = SearchkitForm(ModelA, data, prefix=prefix)
+        form = SearchkitForm(data, prefix=add_prefix(0))
         self.check_form(form)
 
         # Form should be invalid.
@@ -101,26 +137,24 @@ class SearchkitFormTestCase(TestCase):
 
         # Check error message in html.
         errors = ['Select a valid choice. foobar is not one of the available choices.']
-        self.assertFormError(form, 'field', errors)
+        self.assertIn(errors, form.errors.values())
 
     def test_searchkitform_with_valid_model_field_data(self):
-        prefix = SearchkitFormSet(ModelA).add_prefix(0)
         data = {
-            f'{prefix}-field': 'integer',
+            f'{add_prefix(0)}-field': 'integer',
         }
-        form = SearchkitForm(ModelA, data, prefix=prefix)
+        form = SearchkitForm(data, prefix=add_prefix(0))
         self.check_form(form)
 
-        # Form should be invalid.
+        # Form should be invalid since no value data is provieded.
         self.assertFalse(form.is_valid())
 
     def test_searchkitform_with_invalid_operator_data(self):
-        prefix = SearchkitFormSet(ModelA).add_prefix(0)
         data = {
-            f'{prefix}-field': 'integer',
-            f'{prefix}-operator': 'foobar',
+            f'{add_prefix(0)}-field': 'integer',
+            f'{add_prefix(0)}-operator': 'foobar',
         }
-        form = SearchkitForm(ModelA, data, prefix=prefix)
+        form = SearchkitForm(data, prefix=add_prefix(0))
         self.check_form(form)
 
         # Form should be invalid.
@@ -128,45 +162,38 @@ class SearchkitFormTestCase(TestCase):
 
         # Check error message in html.
         errors = ['Select a valid choice. foobar is not one of the available choices.']
-        self.assertFormError(form, 'operator', errors)
+        self.assertIn(errors, form.errors.values())
 
     def test_searchkitform_with_valid_operator_data(self):
-        prefix = SearchkitFormSet(ModelA).add_prefix(0)
         data = {
-            f'{prefix}-field': 'integer',
-            f'{prefix}-operator': 'exact',
+            f'{add_prefix(0)}-field': 'integer',
+            f'{add_prefix(0)}-operator': 'exact',
         }
-        form = SearchkitForm(ModelA, data, prefix=prefix)
+        form = SearchkitForm(data, prefix=add_prefix(0))
         self.check_form(form)
 
-        # Form should be invalid.
+        # Form should be invalid since no value data is provieded.
         self.assertFalse(form.is_valid())
 
     def test_searchkitform_with_valid_data(self):
-        prefix = SearchkitFormSet(ModelA).add_prefix(0)
         data = {
-            f'{prefix}-field': 'integer',
-            f'{prefix}-operator': 'exact',
-            f'{prefix}-value': '123',
+            f'{add_prefix(0)}-field': 'integer',
+            f'{add_prefix(0)}-operator': 'exact',
+            f'{add_prefix(0)}-value': '123',
         }
-        form = SearchkitForm(ModelA, data, prefix=prefix)
+        form = SearchkitForm(data, prefix=add_prefix(0))
         self.check_form(form)
 
-        # Form should be valid, bound and complete
+        # Form should be valid.
         self.assertTrue(form.is_valid())
 
-        # Get filter rule and check if a lookup does not raises any error.
-        rule = form.get_filter_rule()
-        self.assertFalse(ModelA.objects.filter(**dict((rule,))))
-
     def test_searchkitform_with_invalid_data(self):
-        prefix = SearchkitFormSet(ModelA).add_prefix(0)
         data = {
-            f'{prefix}-field': 'integer',
-            f'{prefix}-operator': 'exact',
-            f'{prefix}-value': 'foobar',
+            f'{add_prefix(0)}-field': 'integer',
+            f'{add_prefix(0)}-operator': 'exact',
+            f'{add_prefix(0)}-value': 'foobar',
         }
-        form = SearchkitForm(ModelA, data, prefix=prefix)
+        form = SearchkitForm(data, prefix=add_prefix(0))
         self.check_form(form)
 
         # Form should be invalid.
@@ -174,24 +201,202 @@ class SearchkitFormTestCase(TestCase):
 
         # Check error message in html.
         errors = ['Enter a whole number.']
-        self.assertFormError(form, 'value', errors)
-
-        # get_filter_rule should raise an error.
-        with self.assertRaises(forms.ValidationError):
-            form.get_filter_rule()
+        self.assertIn(errors, form.errors.values())
 
 
-class SearchkitFormSetTestCase(TestCase):
+class SearchkitFormSetTestCase(CheckFormMixin, TestCase):
+    def test_blank_searchkitform(self):
+        # Instantiating the formset neither with a model instance nor with model
+        # related data or initial data should result in a formset without forms,
+        # that is invalid and unbound.
+        formset = SearchkitFormSet()
+        self.assertFalse(formset.is_bound)
+        self.assertFalse(formset.is_valid())
 
     def test_searchkit_formset_with_valid_data(self):
-        formset = SearchkitFormSet(ModelA, FORM_DATA)
+        formset = SearchkitFormSet(FORM_DATA)
         self.assertTrue(formset.is_valid())
 
-        # Just check if the filter rules are applicable. Result should be empty.
-        self.assertFalse(ModelA.objects.filter(**formset.get_filter_rules()))
-
-    def test_searchkit_formset_with_incomplete_data(self):
+    def test_searchkit_formset_with_invalid_data(self):
         data = FORM_DATA.copy()
-        del data[f'{DEFAULT_PREFIX}-0-value']
-        formset = SearchkitFormSet(ModelA, data)
+        del data[f'{add_prefix(0)}-value']
+        formset = SearchkitFormSet(data)
+        self.assertFalse(formset.is_valid())
+
+        # Check error message in html.
+        errors = ['This field is required.']
+        self.assertIn(errors, formset.forms[0].errors.values())
+
+    def test_searchkit_formset_with_initial_data(self):
+        formset_class = searchkit_formset_factory(model=ModelA, extra=0)
+        formset = formset_class(initial=INITIAL_DATA)
+        self.assertFalse(formset.is_bound)
         self.assertFalse(formset.is_valid())
+        self.assertEqual(len(formset.forms), len(INITIAL_DATA))
+        for i, form in enumerate(formset.forms):
+            self.assertEqual(form.initial, INITIAL_DATA[i])
+            self.check_form(form)
+
+
+class SearchkitSearchFormTestCase(TestCase):
+    def test_searchkit_search_form_without_data(self):
+        form = SearchForm()
+        self.assertFalse(form.is_bound)
+        self.assertFalse(form.is_valid())
+        self.assertIsInstance(form.formset, BaseSearchkitFormSet)
+        self.assertEqual(form.formset.model, None)
+
+    def test_searchkit_search_form_with_data(self):
+        form = SearchForm(FORM_DATA)
+        self.assertTrue(form.is_bound)
+        self.assertTrue(form.is_valid())
+        self.assertIsInstance(form.formset, BaseSearchkitFormSet)
+        self.assertEqual(form.formset.model, ModelA)
+        self.assertEqual(form.instance.data, form.formset.cleaned_data)
+
+        # Saving the instance works.
+        form.instance.save()
+        self.assertTrue(form.instance.pk)
+
+        # Using the instance data as filter rules works.
+        filter_rules = form.instance.as_lookups()
+        self.assertEqual(len(filter_rules), len(INITIAL_DATA))
+        for data in INITIAL_DATA:
+            self.assertIn(f"{data['field']}__{data['operator']}", filter_rules)
+        queryset = form.instance.as_queryset()
+        self.assertTrue(queryset.model == ModelA)
+
+
+class SearchkitModelFormTestCase(TestCase):
+    def test_searchkit_model_form_choices(self):
+        form = SearchkitModelForm()
+        labels = [c[1] for c in form.fields['searchkit_model'].choices]
+        self.assertEqual(len(labels), 3)
+        self.assertEqual('select a model', labels[0].lower())
+        self.assertEqual('example | model a', labels[1].lower())
+        self.assertEqual('example | model b', labels[2].lower())
+
+
+class AdminBackendTest(TestCase):
+    @classmethod
+    def setUpTestData(cls):
+        CreateTestData().handle()
+
+    def setUp(self):
+        admin = User.objects.get(username='admin')
+        self.client.force_login(admin)
+
+    def test_search_form(self):
+        url = reverse('admin:searchkit_search_add')
+        resp = self.client.get(url)
+        self.assertEqual(resp.status_code, 200)
+        select = b'<select name="searchkit_model" class="searchkit-reload-on-change" data-total-forms="1" required id="id_searchkit_model">'
+        for snippet in select.split(b' '):
+            self.assertIn(snippet, resp.content)
+
+    def test_search_form_with_initial(self):
+        url = reverse('admin:searchkit_search_add') + '?searchkit_model=1'
+        resp = self.client.get(url)
+        self.assertEqual(resp.status_code, 200)
+        select = '<select name="searchkit_model" class="searchkit-reload-on-change" data-total-forms="1" required id="id_searchkit_model">'
+        for snippet in select.split(' '):
+            self.assertIn(snippet, str(resp.content))
+        self.assertIn('<option value="1" selected>', str(resp.content))
+        self.assertIn('name="searchkit-example-modela-0-field"', str(resp.content))
+
+    def test_add_search(self):
+        # Create a search object via the admin backend.
+        url = reverse('admin:searchkit_search_add')
+        data = FORM_DATA.copy()
+        data['_save_and_apply'] = True
+        resp = self.client.post(url, data, follow=True)
+        self.assertEqual(resp.status_code, 200)
+        self.assertEqual(len(Search.objects.all()), 1)
+
+        # Change it via backend.
+        url = reverse('admin:searchkit_search_change', args=(1,))
+        data['name'] = 'Changed name'
+        data['searchkit-example-modela-0-field'] = 'boolean'
+        data['searchkit-example-modela-0-operator'] = 'exact'
+        data['searchkit-example-modela-0-value'] = 'true'
+        resp = self.client.post(url, data, follow=True)
+        self.assertEqual(resp.status_code, 200)
+        self.assertEqual(Search.objects.get(pk=1).name, data['name'])
+
+        # Will the search be listed in the admin filter?
+        url = reverse('admin:example_modela_changelist')
+        resp = self.client.get(url)
+        self.assertEqual(resp.status_code, 200)
+        self.assertIn('href="?search=1"', str(resp.content))
+        self.assertIn(data['name'], str(resp.content))
+
+
+class SearchViewTest(TestCase):
+
+    def setUp(self):
+        self.initial = [
+            dict(
+                field='integer',
+                operator='exact',
+                value=1,
+            )
+        ]
+        self.initial_range = [
+            dict(
+                field='integer',
+                operator='range',
+                value=[1,3],
+            )
+        ]
+
+    def test_search_view_invalid_data(self):
+        initial = self.initial.copy()
+        initial[0]['value'] = 'no integer'
+        data = get_form_data(initial)
+        url_params = urlencode(data)
+        base_url = reverse('searchkit_form')
+        url = f'{base_url}?{url_params}'
+        resp = self.client.get(url)
+        self.assertEqual(resp.status_code, 200)
+        html_error = '<li>Enter a whole number.</li>'
+        self.assertInHTML(html_error, str(resp.content))
+
+    def test_search_view_missing_data(self):
+        initial = self.initial.copy()
+        del(initial[0]['value'])
+        data = get_form_data(initial)
+        url_params = urlencode(data)
+        base_url = reverse('searchkit_form')
+        url = f'{base_url}?{url_params}'
+        resp = self.client.get(url)
+        self.assertEqual(resp.status_code, 200)
+        html_error = '<li>This field is required.</li>'
+        self.assertInHTML(html_error, str(resp.content))
+
+    def test_search_view_with_range_operator(self):
+        data = get_form_data(self.initial_range)
+        url_params = urlencode(data)
+        base_url = reverse('searchkit_form')
+        url = f'{base_url}?{url_params}'
+        resp = self.client.get(url)
+        self.assertEqual(resp.status_code, 200)
+        html = '<input type="number" name="searchkit-example-modela-0-value_1" value="3" id="id_searchkit-example-modela-0-value_1">'
+        self.assertInHTML(html, str(resp.content))
+
+    def test_search_view_with_model(self):
+        data = get_form_data(self.initial)
+        data['searchkit_model'] = ContentType.objects.get_for_model(ModelA).pk
+        url_params = urlencode(data)
+        base_url = reverse('searchkit_form')
+        url = f'{base_url}?{url_params}'
+        resp = self.client.get(url)
+        self.assertEqual(resp.status_code, 200)
+
+    def test_search_view_with_invalid_model(self):
+        data = get_form_data(self.initial)
+        data['searchkit_model'] = 9999  # Non-existing content type.
+        url_params = urlencode(data)
+        base_url = reverse('searchkit_form')
+        url = f'{base_url}?{url_params}'
+        resp = self.client.get(url)
+        self.assertEqual(resp.status_code, 400)

searchkit/urls.py

@@ -3,6 +3,5 @@ from .views import SearchkitAjaxView
 
 
 urlpatterns = [
-    path("searchkit/form/", SearchkitAjaxView.as_view(), name="searchkit_form"),
-    path("searchkit/form/<slug:app_label>/<slug:model_name>/", SearchkitAjaxView.as_view(), name="searchkit_form_model"),
+    path("searchkit/", SearchkitAjaxView.as_view(), name="searchkit_form"),
 ]