django-searchkit 1.2__py3-none-any.whl → 1.3__py3-none-any.whl

build/lib/build/lib/build/lib/build/lib/searchkit/tests.py

@@ -0,0 +1,400 @@
+from urllib.parse import urlencode
+from django.test import TestCase
+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 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='model_b__chars',
+        operator='contains',
+        value='anytext',
+    ),
+    dict(
+        field='integer',
+        operator='range',
+        value=[1, 123],
+    ),
+    dict(
+        field='float',
+        operator='gt',
+        value='0.3',
+    ),
+    dict(
+        field='decimal',
+        operator='lte',
+        value='1.23',
+    ),
+    dict(
+        field='date',
+        operator='exact',
+        value='2025-05-14',
+    ),
+    dict(
+        field='datetime',
+        operator='exact',
+        value=['2025-05-14', '08:45'],
+    )
+]
+
+add_prefix = lambda i: SearchkitFormSet().add_prefix(i)
+contenttype = ContentType.objects.get_for_model(ModelA)
+DEFAULT_PREFIX = SearchkitFormSet.get_default_prefix()
+
+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)
+        self.assertIn('operator', form.fields)
+        self.assertIn('value', form.fields)
+        self.assertEqual(len(form.fields), 3)
+
+        # Check field choices for the model.
+        form_model_field = form.fields['field']
+        self.assertTrue(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)]))
+        self.assertEqual(form.field_plan, field_plan)
+
+        # Check choices of the operator field based on the field_plan.
+        operator_field = form.fields['operator']
+        self.assertTrue(operator_field.choices)
+        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):
+        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())
+
+    def test_searchkitform_with_invalid_model_field_data(self):
+        data = {
+            f'{add_prefix(0)}-field': 'foobar',
+        }
+        form = SearchkitForm(data, prefix=add_prefix(0))
+        self.check_form(form)
+
+        # Form should be invalid.
+        self.assertFalse(form.is_valid())
+
+        # Check error message in html.
+        errors = ['Select a valid choice. foobar is not one of the available choices.']
+        self.assertIn(errors, form.errors.values())
+
+    def test_searchkitform_with_valid_model_field_data(self):
+        data = {
+            f'{add_prefix(0)}-field': 'integer',
+        }
+        form = SearchkitForm(data, prefix=add_prefix(0))
+        self.check_form(form)
+
+        # Form should be invalid since no value data is provieded.
+        self.assertFalse(form.is_valid())
+
+    def test_searchkitform_with_invalid_operator_data(self):
+        data = {
+            f'{add_prefix(0)}-field': 'integer',
+            f'{add_prefix(0)}-operator': 'foobar',
+        }
+        form = SearchkitForm(data, prefix=add_prefix(0))
+        self.check_form(form)
+
+        # Form should be invalid.
+        self.assertFalse(form.is_valid())
+
+        # Check error message in html.
+        errors = ['Select a valid choice. foobar is not one of the available choices.']
+        self.assertIn(errors, form.errors.values())
+
+    def test_searchkitform_with_valid_operator_data(self):
+        data = {
+            f'{add_prefix(0)}-field': 'integer',
+            f'{add_prefix(0)}-operator': 'exact',
+        }
+        form = SearchkitForm(data, prefix=add_prefix(0))
+        self.check_form(form)
+
+        # Form should be invalid since no value data is provieded.
+        self.assertFalse(form.is_valid())
+
+    def test_searchkitform_with_valid_data(self):
+        data = {
+            f'{add_prefix(0)}-field': 'integer',
+            f'{add_prefix(0)}-operator': 'exact',
+            f'{add_prefix(0)}-value': '123',
+        }
+        form = SearchkitForm(data, prefix=add_prefix(0))
+        self.check_form(form)
+
+        # Form should be valid.
+        self.assertTrue(form.is_valid())
+
+    def test_searchkitform_with_invalid_data(self):
+        data = {
+            f'{add_prefix(0)}-field': 'integer',
+            f'{add_prefix(0)}-operator': 'exact',
+            f'{add_prefix(0)}-value': 'foobar',
+        }
+        form = SearchkitForm(data, prefix=add_prefix(0))
+        self.check_form(form)
+
+        # Form should be invalid.
+        self.assertFalse(form.is_valid())
+
+        # Check error message in html.
+        errors = ['Enter a whole number.']
+        self.assertIn(errors, form.errors.values())
+
+
+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(FORM_DATA)
+        self.assertTrue(formset.is_valid())
+
+    def test_searchkit_formset_with_invalid_data(self):
+        data = FORM_DATA.copy()
+        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)
+
+
+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)

build/lib/build/lib/build/lib/build/lib/searchkit/urls.py

@@ -0,0 +1,7 @@
+from django.urls import path
+from .views import SearchkitAjaxView
+
+
+urlpatterns = [
+    path("searchkit/", SearchkitAjaxView.as_view(), name="searchkit_form"),
+]

build/lib/build/lib/build/lib/build/lib/searchkit/utils.py

@@ -0,0 +1,13 @@
+from django.contrib import admin
+
+
+def is_searchable_model(model):
+    """
+    Check if the model is searchable by Searchkit.
+    """
+    # We do not import SearchkitFilter to avoid circular imports. So we check
+    # the filter by its name.
+    return (
+        admin.site.is_registered(model)
+        and 'SearchkitFilter' in [getattr(f, '__name__', '') for f in admin.site._registry[model].list_filter]
+    )

build/lib/build/lib/build/lib/build/lib/searchkit/views.py

@@ -0,0 +1,23 @@
+from django.utils.translation import gettext_lazy as _
+from django.http import HttpResponse
+from django.http import Http404, HttpResponseBadRequest
+from django.apps import apps
+from django.contrib.contenttypes.models import ContentType
+from django.views.generic import View
+from .forms import SearchkitModelForm
+from .forms import searchkit_formset_factory
+
+
+# FIXME: Check permissions and authentication.
+class SearchkitAjaxView(View):
+    """
+    Reload the formset via ajax.
+    """
+    def get(self, request, **kwargs):
+        model_form = SearchkitModelForm(data=self.request.GET)
+        if model_form.is_valid():
+            model = model_form.cleaned_data['searchkit_model'].model_class()
+            formset = searchkit_formset_factory(model=model)(data=request.GET)
+            return HttpResponse(formset.render())
+        else:
+            return HttpResponseBadRequest(_('Invalid searchkit-model-form.'))

build/lib/build/lib/build/lib/searchkit/__version__.py

@@ -13,4 +13,4 @@ Version 0.x should be considered a development version with an unstable API,
 and backwards compatibility is not guaranteed for minor versions.
 """
 
-__version__ = "1.2"
+__version__ = "1.3"

build/lib/build/lib/build/lib/searchkit/admin.py

@@ -1,15 +1,18 @@
 from django.contrib import admin
 from django.http import HttpResponseRedirect
 from django.urls import reverse
+from django.utils.html import format_html
 from .models import Search
 from .forms import SearchForm
 from .filters import SearchkitFilter
+from .filters import SearchableModelFilter
 
 
 @admin.register(Search)
 class SearchkitSearchAdmin(admin.ModelAdmin):
     form = SearchForm
-    list_display = ('name', 'contenttype', 'created_date')
+    list_display = ('name', 'contenttype', 'created_date', 'apply_search_view')
+    list_filter = (('contenttype', SearchableModelFilter),)
 
     def get_url_for_applied_search(self, obj):
         app_label = obj.contenttype.app_label
@@ -28,3 +31,14 @@ class SearchkitSearchAdmin(admin.ModelAdmin):
             return HttpResponseRedirect(self.get_url_for_applied_search(obj))
         else:
             return super().response_change(request, obj, *args, **kwargs)
+
+    def apply_search_view(self, obj):
+        """
+        Returns a link to apply the search.
+        """
+        return format_html(
+            '<a href="{}" >Apply search "{}"</a>',
+            self.get_url_for_applied_search(obj),
+            obj.name
+        )
+    apply_search_view.short_description = 'Apply Search'

build/lib/build/lib/build/lib/searchkit/filters.py

@@ -1,9 +1,10 @@
-from django.contrib.admin import SimpleListFilter
+from django.contrib import admin
 from django.contrib.contenttypes.models import ContentType
 from .models import Search
+from .utils import is_searchable_model
 
 
-class SearchkitFilter(SimpleListFilter):
+class SearchkitFilter(admin.SimpleListFilter):
     title = 'Searchkit Filter'
     parameter_name = 'search'
     template = 'searchkit/searchkit_filter.html'
@@ -26,3 +27,10 @@ class SearchkitFilter(SimpleListFilter):
         if self.value():
             search = Search.objects.get(id=int(self.value()))
             return queryset.filter(**search.as_lookups())
+
+
+class SearchableModelFilter(admin.filters.RelatedFieldListFilter):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        contenttypes = ContentType.objects.order_by('app_label', 'model')
+        self.lookup_choices = [(m.id, m) for m in contenttypes if is_searchable_model(m.model_class())]

build/lib/build/lib/build/lib/searchkit/forms/fields.py

@@ -1,4 +1,5 @@
 from django import forms
+from django.contrib.admin import widgets
 from django.utils.translation import gettext_lazy as _
 
 
@@ -46,10 +47,10 @@ class IntegerRangeField(BaseRangeField):
 class DateRangeField(BaseRangeField):
     incomplete_message = _("Enter the first and the last date.")
     field_type = forms.DateField
-    widget_type = forms.DateInput
+    widget_type = widgets.AdminDateWidget
 
 
-class DateTimeRangeField(BaseRangeField):
+class DateTimeRangeField(DateRangeField):
     incomplete_message = _("Enter the first and the last datetime.")
-    field_type = forms.DateTimeField
-    widget_type = forms.DateTimeInput
+    field_type = forms.SplitDateTimeField
+    widget_type = widgets.AdminSplitDateTime

build/lib/build/lib/build/lib/searchkit/forms/search.py

@@ -1,6 +1,5 @@
 from django import forms
 from django.utils.functional import cached_property
-from django.contrib.contenttypes.models import ContentType
 from ..models import Search
 from .searchkit import SearchkitModelForm
 from .searchkit import searchkit_formset_factory

build/lib/build/lib/build/lib/searchkit/forms/searchkit.py

@@ -1,19 +1,30 @@
 from django import forms
+from django.apps import apps
+from django.contrib.admin import widgets
+from django.contrib.contenttypes.models import ContentType
 from django.utils.translation import gettext_lazy as _
 from django.utils.functional import cached_property
 from .utils import CssClassMixin, FIELD_PLAN, OPERATOR_DESCRIPTION
 from .utils import SUPPORTED_FIELDS
 from .utils import ModelTree
 from .utils import MediaMixin
-from .utils import get_searchable_models
+from .fields import DateRangeField
+from ..utils import is_searchable_model
 
 
 class SearchkitModelForm(forms.Form):
     """
     Form to select a content type.
     """
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        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]
+        queryset = self.fields['searchkit_model'].queryset.filter(pk__in=ids)
+        self.fields['searchkit_model'].queryset = queryset
+
     searchkit_model = forms.ModelChoiceField(
-        queryset=get_searchable_models(),
+        queryset=ContentType.objects.all().order_by('app_label', 'model'),
         label=_('Model'),
         empty_label=_('Select a Model'),
         widget=forms.Select(attrs={
@@ -105,27 +116,19 @@ class BaseSearchkitForm(MediaMixin, CssClassMixin, forms.Form):
         return choices
 
     def _add_field_name_field(self):
-        initial = self.initial.get('field')
         choices = self._get_model_field_choices()
-        field = forms.ChoiceField(label=_('Model field'), choices=choices, initial=initial)
+        field = forms.ChoiceField(label=_('Model field'), choices=choices)
         field.widget.attrs.update({"class": self.reload_on_change_css_class})
         self.fields['field'] = field
 
     def _add_operator_field(self):
-        initial = self.initial.get('operator')
         choices = [(o, OPERATOR_DESCRIPTION[o]) for o in self.field_plan.keys()]
-        field = forms.ChoiceField(label=_('Operator'), choices=choices, initial=initial)
+        field = forms.ChoiceField(label=_('Operator'), choices=choices)
         field.widget.attrs.update({"class": self.reload_on_change_css_class})
         self.fields['operator'] = field
 
     def _add_value_field(self):
-        initial = self.initial.get('value')
-        field_class = self.field_plan[self.operator][0]
-        if getattr(field_class, 'choices', None) and getattr(self.model_field, 'choices', None):
-            field = field_class(choices=self.model_field.choices, initial=initial)
-        else:
-            field = field_class()
-        self.fields['value'] = field
+        self.fields['value'] = self.field_plan[self.operator](self.model_field)
 
 
 class BaseSearchkitFormSet(CssClassMixin, forms.BaseFormSet):
@@ -143,6 +146,26 @@ class BaseSearchkitFormSet(CssClassMixin, forms.BaseFormSet):
     def get_default_prefix(self):
         return "searchkit"
 
+    @cached_property
+    def uses_date_widget(self):
+        """
+        Check if the form uses a date widget.
+        """
+        for form in self.forms:
+            for field in form.fields.values():
+                if isinstance(field.widget, (widgets.AdminDateWidget, widgets.AdminSplitDateTime)):
+                    return True
+                elif isinstance(field, DateRangeField):
+                    return True
+        return False
+
+    @cached_property
+    def forms(self):
+        if self.model:
+            return super().forms
+        else:
+            return []
+
 
 def searchkit_formset_factory(model, **kwargs):
     form = type('SearchkitForm', (BaseSearchkitForm,), dict(model=model))