refactor search suggestions

integreat_cms/cms/models/abstract_content_translation.py

@@ -3,7 +3,7 @@
 import logging
 from copy import deepcopy
 from html import escape
-from typing import TYPE_CHECKING
+from typing import ClassVar, TYPE_CHECKING
 
 from django.conf import settings
 from django.db import models, transaction
@@ -43,6 +43,9 @@ class AbstractContentTranslation(AbstractBaseModel):
     Data model representing a translation of some kind of content (e.g. pages or events)
     """
 
+    #: Field path for language filtering in search suggestions (see SearchSuggestMixin)
+    language_filter_field: ClassVar[str | None] = "language__slug"
+
     title = TruncatingCharField(max_length=1024, verbose_name=_("title"))
     slug = models.SlugField(
         max_length=1024,
@@ -497,6 +500,35 @@ def translation_state(self) -> str:
         # If the translation was edited after the source translation, we consider it up to date
         return translation_status.UP_TO_DATE
 
+    @classmethod
+    def get_suggest_queryset(
+        cls,
+        region: Region | None = None,
+        archived: bool = False,
+        language_slug: str | None = None,
+    ) -> QuerySet:
+        """
+        Restrict suggestion sources to the latest *published* translation per
+        (object, language) so that token suggestions reflect what list views
+        actually display, instead of mixing in tokens from outdated revisions or
+        unpublished drafts.
+        """
+        qs = super().get_suggest_queryset(
+            region=region, archived=archived, language_slug=language_slug
+        )
+        # Only published translations are shown in list views, so suggestions
+        # must not leak titles of drafts / pending revisions.
+        qs = qs.filter(status=status.PUBLIC)
+        foreign_id = f"{cls.foreign_field()}_id"
+        latest_ids = (
+            qs.order_by(foreign_id, "language_id", "-version")
+            .distinct(foreign_id, "language_id")
+            .values("id")
+        )
+        # Wrap in id__in so the icontains filter applied later in suggest_tokens
+        # runs against latest rows only — not all versions.
+        return cls.objects.filter(id__in=latest_ids)
+
     @classmethod
     def search(cls, region: Region, language_slug: str, query: str) -> QuerySet:
         """

integreat_cms/cms/models/contact/contact.py

@@ -18,9 +18,11 @@
 from django.utils.translation import gettext_lazy as _
 from linkcheck.models import Link
 
+from ...search.search_fields import CONTACT_SEARCH_FIELDS
 from ..abstract_base_model import AbstractBaseModel
 from ..events.event_translation import EventTranslation
 from ..fields.truncating_char_field import TruncatingCharField
+from ..mixins import SearchSuggestMixin
 from ..pages.page_translation import PageTranslation
 from ..pois.poi import POI
 from ..pois.poi_translation import POITranslation
@@ -48,12 +50,14 @@ def get_primary_contact(self) -> Contact | None:
         return self.filter(area_of_responsibility="").first()
 
 
-class Contact(AbstractBaseModel):
+class Contact(AbstractBaseModel, SearchSuggestMixin):
     """
     Data model representing a contact
     """
 
-    search_fields = ["name", "location__translations__title", "area_of_responsibility"]
+    search_fields = CONTACT_SEARCH_FIELDS
+    region_filter_field = "location__region"
+    archived_filter_field = "archived"
 
     area_of_responsibility = TruncatingCharField(
         max_length=200,

integreat_cms/cms/models/events/event_translation.py

@@ -23,8 +23,10 @@
     from ...models import Event, Region
 
 from ...constants import status
+from ...search.search_fields import EVENT_SEARCH_FIELDS
 from ..abstract_content_translation import AbstractContentTranslation
 from ..decorators import modify_fields
+from ..mixins import SearchSuggestMixin
 from ..utils import format_object_translation
 
 
@@ -33,11 +35,15 @@
     title={"verbose_name": _("title of the event")},
     content={"verbose_name": _("description")},
 )
-class EventTranslation(AbstractContentTranslation):
+class EventTranslation(AbstractContentTranslation, SearchSuggestMixin):
     """
     Data model representing an event translation
     """
 
+    search_fields = EVENT_SEARCH_FIELDS
+    region_filter_field = "event__region"
+    archived_filter_field = "event__archived"
+
     event = models.ForeignKey(
         "cms.Event",
         on_delete=models.CASCADE,

integreat_cms/cms/models/feedback/feedback.py

@@ -11,9 +11,11 @@
 from polymorphic.models import PolymorphicModel
 
 from ...constants import feedback_ratings
+from ...search.search_fields import FEEDBACK_SEARCH_FIELDS
 from ...utils.translation_utils import gettext_many_lazy as __
 from ..abstract_base_model import AbstractBaseModel
 from ..languages.language import Language
+from ..mixins import SearchSuggestMixin
 from ..regions.region import Region
 
 if TYPE_CHECKING:
@@ -52,12 +54,33 @@ class CascadeDeletePolymorphicManager(PolymorphicManager):
     queryset_class = CascadeDeletePolymorphicQuerySet
 
 
-class Feedback(PolymorphicModel, AbstractBaseModel):
+class Feedback(PolymorphicModel, AbstractBaseModel, SearchSuggestMixin):
     """
     Database model representing feedback from app-users.
     Do not directly create instances of this base model, but of the submodels (e.g. PageFeedback) instead.
     """
 
+    search_fields = FEEDBACK_SEARCH_FIELDS
+    region_filter_field = "region"
+    archived_filter_field = "archived"
+
+    @classmethod
+    def get_suggest_queryset(
+        cls,
+        region: Region | None = None,
+        archived: bool = False,
+        language_slug: str | None = None,
+    ) -> QuerySet:
+        """
+        Mirror :meth:`Feedback.search`: the admin (global) feedback list shows
+        only technical feedback, whereas a regional list shows only that region's
+        non-technical feedback. Suggestions must respect the same split.
+        """
+        qs = super().get_suggest_queryset(
+            region=region, archived=archived, language_slug=language_slug
+        )
+        return qs.filter(is_technical=region is None)
+
     objects = CascadeDeletePolymorphicManager()
 
     region = models.ForeignKey(

integreat_cms/cms/models/languages/language.py

@@ -18,17 +18,19 @@
 from django.utils.translation import gettext_lazy as _
 
 from ...constants import countries, language_color, text_directions
+from ...search.search_fields import LANGUAGE_SEARCH_FIELDS
 from ...utils.translation_utils import gettext_many_lazy as __
 from ..abstract_base_model import AbstractBaseModel
+from ..mixins import SearchSuggestMixin
 from ..regions.region import Region
 
 
-class Language(AbstractBaseModel):
+class Language(AbstractBaseModel, SearchSuggestMixin):
     """
     Data model representing a content language.
     """
 
-    search_fields = ["native_name", "english_name"]
+    search_fields = LANGUAGE_SEARCH_FIELDS
 
     slug = models.SlugField(
         max_length=8,

integreat_cms/cms/models/media/directory.py

@@ -8,7 +8,9 @@
 from django.utils.formats import localize
 from django.utils.translation import gettext_lazy as _
 
+from ...search.search_fields import DIRECTORY_SEARCH_FIELDS
 from ..abstract_base_model import AbstractBaseModel
+from ..mixins import SearchSuggestMixin
 from ..regions.region import Region
 
 if TYPE_CHECKING:
@@ -17,12 +19,36 @@
     from django.db.models.query import QuerySet
 
 
-class Directory(AbstractBaseModel):
+class Directory(AbstractBaseModel, SearchSuggestMixin):
     """
     Model representing a directory containing documents. This is only a virtual directory and does not necessarily
     exist on the actual file system. Each directory is tied to a region.
     """
 
+    search_fields = DIRECTORY_SEARCH_FIELDS
+    region_filter_field = "region"
+    archived_filter_field = None
+
+    @classmethod
+    def get_suggest_queryset(
+        cls,
+        region: Region | None = None,
+        archived: bool = False,  # noqa: ARG003
+        language_slug: str | None = None,
+    ) -> QuerySet[Any]:
+        """
+        Include both regional and global (non-hidden) directories,
+        matching the behavior of :meth:`Directory.search`.
+
+        :param region: The region to filter by (optional)
+        :param archived: Whether to include archived records (unused for directories)
+        :param language_slug: Unused; directories are not language-specific
+        :return: A filtered queryset
+        """
+        return cls.objects.filter(
+            Q(region=region) | Q(region__isnull=True, is_hidden=False)
+        )
+
     name = models.CharField(max_length=255, blank=False, verbose_name=_("name"))
     region = models.ForeignKey(
         Region,

integreat_cms/cms/models/media/media_file.py

@@ -25,7 +25,9 @@
 from linkcheck.models import Link, Url
 
 from ...constants import allowed_media
+from ...search.search_fields import MEDIA_FILE_SEARCH_FIELDS
 from ..abstract_base_model import AbstractBaseModel
+from ..mixins import SearchSuggestMixin
 from ..regions.region import Region
 from .directory import Directory
 
@@ -131,13 +133,17 @@ def filter_unused(self) -> MediaFileQuerySet:
         )
 
 
-class MediaFile(AbstractBaseModel):
+class MediaFile(AbstractBaseModel, SearchSuggestMixin):
     """
     The MediaFile model is used to store basic information about files which are uploaded to the CMS. This is only a
     virtual document and does not necessarily exist on the actual file system. Each document is tied to a region via its
     directory.
     """
 
+    search_fields = MEDIA_FILE_SEARCH_FIELDS
+    region_filter_field = "region"
+    archived_filter_field = None
+
     file = models.FileField(
         upload_to=upload_path,
         validators=[file_size_limit],
@@ -422,6 +428,65 @@ def suggest(cls, **kwargs: Any) -> list[dict[str, Any]]:
         )
         return results
 
+    @classmethod
+    def get_suggest_queryset(
+        cls,
+        region: Region | None = None,
+        archived: bool = False,  # noqa: ARG003
+        language_slug: str | None = None,
+    ) -> QuerySet[Any]:
+        """
+        Include both regional and global (non-hidden) media files,
+        matching the behavior of :meth:`MediaFile.search`.
+
+        :param region: The region to filter by (optional)
+        :param archived: Whether to include archived records (unused for media files)
+        :param language_slug: Unused; media files are not language-specific
+        :return: A filtered queryset
+        """
+        return cls.objects.filter(
+            Q(region=region) | Q(region__isnull=True, is_hidden=False)
+        )
+
+    @classmethod
+    def suggest_tokens(
+        cls,
+        query: str,
+        region: Region | None = None,
+        archived: bool = False,
+        language_slug: str | None = None,
+        **kwargs: Any,
+    ) -> dict[str, list[dict[str, Any]]]:
+        """
+        Generate search suggestions from both media files and directories.
+
+        :param query: The search query string
+        :param region: The region to filter by (optional)
+        :param archived: Whether to include archived records (default: False)
+        :param language_slug: Unused; media files are not language-specific
+        :param kwargs: Additional arguments (unused, for compatibility)
+        :return: Dict with "suggestions" key containing list of {suggestion, score} dicts
+        """
+        file_result = super().suggest_tokens(
+            query, region=region, archived=archived, language_slug=language_slug
+        )
+        dir_result = Directory.suggest_tokens(
+            query, region=region, archived=archived, language_slug=language_slug
+        )
+
+        # Merge suggestions, summing scores for duplicates
+        scores: dict[str, float] = {}
+        for item in file_result["suggestions"] + dir_result["suggestions"]:
+            scores[item["suggestion"]] = (
+                scores.get(item["suggestion"], 0) + item["score"]
+            )
+
+        return {
+            "suggestions": [
+                {"suggestion": token, "score": score} for token, score in scores.items()
+            ]
+        }
+
     def __str__(self) -> str:
         """
         This overwrites the default Django :meth:`~django.db.models.Model.__str__` method which would return ``MediaFile object (id)``.