♻️(backend) fallback logic

I am adding a title_search with all the logic

Signed-off-by: charles <[email protected]>

Author: mascarpon3

src/backend/core/api/filters.py

@@ -52,7 +52,7 @@ class Meta:
         fields = ["title"]
 
 
-class ListDocumentFilter(django_filters.FilterSet):
+class ListDocumentFilter(DocumentFilter):
     """
     Custom filter for filtering documents.
     """
@@ -130,6 +130,35 @@ def filter_is_masked(self, queryset, name, value):
         return queryset_method(link_traces__user=user, link_traces__is_masked=True)
 
 
+class SubDocumentFilter(DocumentFilter):
+    """
+    Custom filter for filtering sub-documents by path and title.
+    Used when searching within a specific document subtree.
+    the parent document can be matched.
+
+    Example:
+        - /api/v1.0/documents/search/?path=0001&q=test
+            → Filters documents where path starts with "0001" and title contains "test"
+    """
+
+    path = django_filters.CharFilter(
+        required=True, method="filter_by_path", label=_("Path")
+    )
+
+    class Meta:
+        model = models.Document
+        fields = ["path", "title"]
+
+    # pylint: disable=unused-argument
+    def filter_by_path(self, queryset, name, value):
+        """
+        Filter documents whose path starts with the provided path.
+        """
+        return queryset.filter(
+            path__startswith=value, ancestors_deleted_at__isnull=True
+        )
+
+
 class UserSearchFilter(django_filters.FilterSet):
     """
     Custom filter for searching users.

src/backend/core/api/viewsets.py

@@ -10,6 +10,7 @@
 import uuid
 from collections import defaultdict
 from urllib.parse import unquote, urlencode, urlparse
+from urllib.request import Request
 
 from django.conf import settings
 from django.contrib.postgres.aggregates import ArrayAgg
@@ -64,7 +65,7 @@
 from core.utils import extract_attachments, filter_descendants
 
 from . import permissions, serializers, utils
-from .filters import DocumentFilter, ListDocumentFilter, UserSearchFilter
+from .filters import DocumentFilter, ListDocumentFilter, SubDocumentFilter, UserSearchFilter
 from .throttling import (
     DocumentThrottle,
     UserListThrottleBurst,
@@ -459,21 +460,21 @@ def list(self, request, *args, **kwargs):
         It performs early filtering on model fields, annotates user roles, and removes
         descendant documents to keep only the highest ancestors readable by the current user.
         """
-        user = self.request.user
+        user = request.user
 
         # Not calling filter_queryset. We do our own cooking.
         queryset = self.get_queryset()
 
         filterset = ListDocumentFilter(
-            self.request.GET, queryset=queryset, request=self.request
+            request.GET, queryset=queryset, request=request
         )
         if not filterset.is_valid():
             raise drf.exceptions.ValidationError(filterset.errors)
         filter_data = filterset.form.cleaned_data
 
         # Filter as early as possible on fields that are available on the model
-        field = "is_creator_me"
-        queryset = filterset.filters[field].filter(queryset, filter_data[field])
+        for field in ["is_creator_me", "title"]:
+            queryset = filterset.filters[field].filter(queryset, filter_data[field])
 
         queryset = queryset.annotate_user_roles(user)
 
@@ -956,27 +957,6 @@ def all(self, request, *args, **kwargs):
 
         return self.get_response_for_queryset(queryset)
 
-    @drf.decorators.action(
-        detail=True,
-        methods=["get"],
-        ordering=["path"],
-    )
-    def descendants(self, request, *args, **kwargs):
-        """Handle listing descendants of a document"""
-        # TODO: remove ? might be dead code
-        document = self.get_object()
-
-        queryset = document.get_descendants().filter(ancestors_deleted_at__isnull=True)
-        queryset = self.filter_queryset(queryset)
-
-        filterset = DocumentFilter(request.GET, queryset=queryset)
-        if not filterset.is_valid():
-            raise drf.exceptions.ValidationError(filterset.errors)
-
-        queryset = filterset.qs
-
-        return self.get_response_for_queryset(queryset)
-
     @drf.decorators.action(
         detail=True,
         methods=["get"],
@@ -1184,25 +1164,30 @@ def duplicate(self, request, *args, **kwargs):
             {"id": str(duplicated_document.id)}, status=status.HTTP_201_CREATED
         )
 
-    def _search_simple(self, request, text):
+
+    @drf.decorators.action(detail=False, methods=["get"], url_path="search")
+    @method_decorator(refresh_oidc_access_token)
+    def search(self, request, *args, **kwargs):
         """
-        Returns a queryset filtered by the content of the document title
+        Returns a DRF response containing the filtered, annotated and ordered document list.
+
+        Applies filtering based on request parameter 'q' from `SearchDocumentSerializer`.
+        Depending of the configuration it can be:
+         - A fulltext search through the opensearch indexation app "find" if the backend is
+           enabled (see SEARCH_INDEXER_CLASS)
+         - A filtering by the model field 'title'.
+
+        The ordering is always by the most recent first.
         """
-        # As the 'list' view we get a prefiltered queryset (deleted docs are excluded)
-        queryset = models.Document.objects.all()
-        filterset = DocumentFilter({"title": text}, queryset=queryset)
-        # TODO: make sure parent in included when searching in sub-docs
-        if not filterset.is_valid():
-            raise drf.exceptions.ValidationError(filterset.errors)
+        params = serializers.SearchDocumentSerializer(data=request.query_params)
+        params.is_valid(raise_exception=True)
 
-        queryset = filterset.filter_queryset(queryset)
+        indexer = get_document_indexer()
+        if indexer:
+            return self._search_with_indexer(indexer, request, params=params)
 
-        return self.get_response_for_queryset(
-            queryset.order_by("-updated_at"),
-            context={
-                "request": request,
-            },
-        )
+        # The indexer is not configured, we fallback on title search
+        return self.title_search(request, params.validated_data, *args, **kwargs)
 
     @staticmethod
     def _search_with_indexer(indexer, request, params):
@@ -1231,30 +1216,28 @@ def _search_with_indexer(indexer, request, params):
             }
         )
 
-    @drf.decorators.action(detail=False, methods=["get"], url_path="search")
-    @method_decorator(refresh_oidc_access_token)
-    def search(self, request, *args, **kwargs):
-        """
-        Returns a DRF response containing the filtered, annotated and ordered document list.
-
-        Applies filtering based on request parameter 'q' from `SearchDocumentSerializer`.
-        Depending of the configuration it can be:
-         - A fulltext search through the opensearch indexation app "find" if the backend is
-           enabled (see SEARCH_INDEXER_CLASS)
-         - A filtering by the model field 'title'.
+    def title_search(self, request, validated_data, *args, **kwargs):
+        request.GET = request.GET.copy()
+        request.GET['title'] = validated_data['q']
+        if not "path" in validated_data or not validated_data["path"]:
+            return self.list(request, *args, **kwargs)
+        else:
+            return self._list_sub_docs(request)
 
-        The ordering is always by the most recent first.
+    def _list_sub_docs(self, request):
         """
-        params = serializers.SearchDocumentSerializer(data=request.query_params)
-        params.is_valid(raise_exception=True)
+        List all documents whose path starts with the provided path parameter.
+        Used internally by the search endpoint when path filtering is requested.
+        """
+        queryset = self.get_queryset()
 
-        indexer = get_document_indexer()
-        if indexer:
-            return self._search_with_indexer(indexer, request, params=params)
+        filterset = SubDocumentFilter(request.GET, queryset=queryset)
+        if not filterset.is_valid():
+            raise drf.exceptions.ValidationError(filterset.errors)
+
+        queryset = filterset.qs
+        return self.get_response_for_queryset(queryset)
 
-        # The indexer is not configured, we fallback on a simple icontains filter by the
-        # model field 'title'.
-        return self._search_simple(request, text=params.validated_data["q"])
 
     @drf.decorators.action(detail=True, methods=["get"], url_path="versions")
     def versions_list(self, request, *args, **kwargs):