makeplane
diff --git a/‎apps/api/plane/app/views/search/base.py‎
Lines changed: 150 additions & 61 deletions b/‎apps/api/plane/app/views/search/base.py‎
Lines changed: 150 additions & 61 deletions
@@ -43,22 +43,25 @@ class GlobalSearchEndpoint(BaseAPIView):
     also show related workspace if found
     """
 
-    def filter_workspaces(self, query, slug, project_id, workspace_search):
+    def filter_workspaces(self, query, _slug, _project_id, _workspace_search):
         fields = ["name"]
         q = Q()
-        for field in fields:
-            q |= Q(**{f"{field}__icontains": query})
+        if query:
+            for field in fields:
+                q |= Q(**{f"{field}__icontains": query})
         return (
             Workspace.objects.filter(q, workspace_member__member=self.request.user)
+            .order_by("-created_at")
             .distinct()
             .values("name", "id", "slug")
         )
 
-    def filter_projects(self, query, slug, project_id, workspace_search):
+    def filter_projects(self, query, slug, _project_id, _workspace_search):
         fields = ["name", "identifier"]
         q = Q()
-        for field in fields:
-            q |= Q(**{f"{field}__icontains": query})
+        if query:
+            for field in fields:
+                q |= Q(**{f"{field}__icontains": query})
         return (
             Project.objects.filter(
                 q,
@@ -67,21 +70,23 @@ def filter_projects(self, query, slug, project_id, workspace_search):
                 archived_at__isnull=True,
                 workspace__slug=slug,
             )
+            .order_by("-created_at")
             .distinct()
             .values("name", "id", "identifier", "workspace__slug")
         )
 
     def filter_issues(self, query, slug, project_id, workspace_search):
         fields = ["name", "sequence_id", "project__identifier"]
         q = Q()
-        for field in fields:
-            if field == "sequence_id":
-                # Match whole integers only (exclude decimal numbers)
-                sequences = re.findall(r"\b\d+\b", query)
-                for sequence_id in sequences:
-                    q |= Q(**{"sequence_id": sequence_id})
-            else:
-                q |= Q(**{f"{field}__icontains": query})
+        if query:
+            for field in fields:
+                if field == "sequence_id":
+                    # Match whole integers only (exclude decimal numbers)
+                    sequences = re.findall(r"\b\d+\b", query)
+                    for sequence_id in sequences:
+                        q |= Q(**{"sequence_id": sequence_id})
+                else:
+                    q |= Q(**{f"{field}__icontains": query})
 
         issues = Issue.issue_objects.filter(
             q,
@@ -106,8 +111,9 @@ def filter_issues(self, query, slug, project_id, workspace_search):
     def filter_cycles(self, query, slug, project_id, workspace_search):
         fields = ["name"]
         q = Q()
-        for field in fields:
-            q |= Q(**{f"{field}__icontains": query})
+        if query:
+            for field in fields:
+                q |= Q(**{f"{field}__icontains": query})
 
         cycles = Cycle.objects.filter(
             q,
@@ -120,13 +126,20 @@ def filter_cycles(self, query, slug, project_id, workspace_search):
         if workspace_search == "false" and project_id:
             cycles = cycles.filter(project_id=project_id)
 
-        return cycles.distinct().values("name", "id", "project_id", "project__identifier", "workspace__slug")
+        return (
+            cycles.order_by("-created_at")
+            .distinct()
+            .values(
+                "name", "id", "project_id", "project__identifier", "workspace__slug"
+            )
+        )
 
     def filter_modules(self, query, slug, project_id, workspace_search):
         fields = ["name"]
         q = Q()
-        for field in fields:
-            q |= Q(**{f"{field}__icontains": query})
+        if query:
+            for field in fields:
+                q |= Q(**{f"{field}__icontains": query})
 
         modules = Module.objects.filter(
             q,
@@ -139,13 +152,20 @@ def filter_modules(self, query, slug, project_id, workspace_search):
         if workspace_search == "false" and project_id:
             modules = modules.filter(project_id=project_id)
 
-        return modules.distinct().values("name", "id", "project_id", "project__identifier", "workspace__slug")
+        return (
+            modules.order_by("-created_at")
+            .distinct()
+            .values(
+                "name", "id", "project_id", "project__identifier", "workspace__slug"
+            )
+        )
 
     def filter_pages(self, query, slug, project_id, workspace_search):
         fields = ["name"]
         q = Q()
-        for field in fields:
-            q |= Q(**{f"{field}__icontains": query})
+        if query:
+            for field in fields:
+                q |= Q(**{f"{field}__icontains": query})
 
         pages = (
             Page.objects.filter(
@@ -157,7 +177,9 @@ def filter_pages(self, query, slug, project_id, workspace_search):
             )
             .annotate(
                 project_ids=Coalesce(
-                    ArrayAgg("projects__id", distinct=True, filter=~Q(projects__id=True)),
+                    ArrayAgg(
+                        "projects__id", distinct=True, filter=~Q(projects__id=True)
+                    ),
                     Value([], output_field=ArrayField(UUIDField())),
                 )
             )
@@ -174,19 +196,28 @@ def filter_pages(self, query, slug, project_id, workspace_search):
         )
 
         if workspace_search == "false" and project_id:
-            project_subquery = ProjectPage.objects.filter(page_id=OuterRef("id"), project_id=project_id).values_list(
-                "project_id", flat=True
-            )[:1]
+            project_subquery = ProjectPage.objects.filter(
+                page_id=OuterRef("id"), project_id=project_id
+            ).values_list("project_id", flat=True)[:1]
 
-            pages = pages.annotate(project_id=Subquery(project_subquery)).filter(project_id=project_id)
+            pages = pages.annotate(project_id=Subquery(project_subquery)).filter(
+                project_id=project_id
+            )
 
-        return pages.distinct().values("name", "id", "project_ids", "project_identifiers", "workspace__slug")
+        return (
+            pages.order_by("-created_at")
+            .distinct()
+            .values(
+                "name", "id", "project_ids", "project_identifiers", "workspace__slug"
+            )
+        )
 
     def filter_views(self, query, slug, project_id, workspace_search):
         fields = ["name"]
         q = Q()
-        for field in fields:
-            q |= Q(**{f"{field}__icontains": query})
+        if query:
+            for field in fields:
+                q |= Q(**{f"{field}__icontains": query})
 
         issue_views = IssueView.objects.filter(
             q,
@@ -199,29 +230,57 @@ def filter_views(self, query, slug, project_id, workspace_search):
         if workspace_search == "false" and project_id:
             issue_views = issue_views.filter(project_id=project_id)
 
-        return issue_views.distinct().values("name", "id", "project_id", "project__identifier", "workspace__slug")
+        return (
+            issue_views.order_by("-created_at")
+            .distinct()
+            .values(
+                "name", "id", "project_id", "project__identifier", "workspace__slug"
+            )
+        )
+
+    def filter_intakes(self, query, slug, project_id, workspace_search):
+        fields = ["name", "sequence_id", "project__identifier"]
+        q = Q()
+        if query:
+            for field in fields:
+                if field == "sequence_id":
+                    # Match whole integers only (exclude decimal numbers)
+                    sequences = re.findall(r"\b\d+\b", query)
+                    for sequence_id in sequences:
+                        q |= Q(**{"sequence_id": sequence_id})
+                else:
+                    q |= Q(**{f"{field}__icontains": query})
+
+        issues = Issue.objects.filter(
+            q,
+            project__project_projectmember__member=self.request.user,
+            project__project_projectmember__is_active=True,
+            project__archived_at__isnull=True,
+            workspace__slug=slug,
+        ).filter(models.Q(issue_intake__status=0) | models.Q(issue_intake__status=-2))
+
+        if workspace_search == "false" and project_id:
+            issues = issues.filter(project_id=project_id)
+
+        return (
+            issues.order_by("-created_at")
+            .distinct()
+            .values(
+                "name",
+                "id",
+                "sequence_id",
+                "project__identifier",
+                "project_id",
+                "workspace__slug",
+            )[:100]
+        )
 
     def get(self, request, slug):
         query = request.query_params.get("search", False)
+        entities_param = request.query_params.get("entities")
         workspace_search = request.query_params.get("workspace_search", "false")
         project_id = request.query_params.get("project_id", False)
 
-        if not query:
-            return Response(
-                {
-                    "results": {
-                        "workspace": [],
-                        "project": [],
-                        "issue": [],
-                        "cycle": [],
-                        "module": [],
-                        "issue_view": [],
-                        "page": [],
-                    }
-                },
-                status=status.HTTP_200_OK,
-            )
-
         MODELS_MAPPER = {
             "workspace": self.filter_workspaces,
             "project": self.filter_projects,
@@ -230,13 +289,27 @@ def get(self, request, slug):
             "module": self.filter_modules,
             "issue_view": self.filter_views,
             "page": self.filter_pages,
+            "intake": self.filter_intakes,
         }
 
+        # Determine which entities to search
+        if entities_param:
+            requested_entities = [
+                e.strip() for e in entities_param.split(",") if e.strip()
+            ]
+            requested_entities = [e for e in requested_entities if e in MODELS_MAPPER]
+        else:
+            requested_entities = list(MODELS_MAPPER.keys())
+
         results = {}
 
-        for model in MODELS_MAPPER.keys():
-            func = MODELS_MAPPER.get(model, None)
-            results[model] = func(query, slug, project_id, workspace_search)
+        for entity in requested_entities:
+            func = MODELS_MAPPER.get(entity)
+            if func:
+                results[entity] = func(
+                    query or None, slug, project_id, workspace_search
+                )
+
         return Response({"results": results}, status=status.HTTP_200_OK)
 
 
@@ -316,12 +389,15 @@ def get(self, request, slug):
                     projects = (
                         Project.objects.filter(
                             q,
-                            Q(project_projectmember__member=self.request.user) | Q(network=2),
+                            Q(project_projectmember__member=self.request.user)
+                            | Q(network=2),
                             workspace__slug=slug,
                         )
                         .order_by("-created_at")
                         .distinct()
-                        .values("name", "id", "identifier", "logo_props", "workspace__slug")[:count]
+                        .values(
+                            "name", "id", "identifier", "logo_props", "workspace__slug"
+                        )[:count]
                     )
                     response_data["project"] = list(projects)
 
@@ -380,16 +456,20 @@ def get(self, request, slug):
                         .annotate(
                             status=Case(
                                 When(
-                                    Q(start_date__lte=timezone.now()) & Q(end_date__gte=timezone.now()),
+                                    Q(start_date__lte=timezone.now())
+                                    & Q(end_date__gte=timezone.now()),
                                     then=Value("CURRENT"),
                                 ),
                                 When(
                                     start_date__gt=timezone.now(),
                                     then=Value("UPCOMING"),
                                 ),
-                                When(end_date__lt=timezone.now(), then=Value("COMPLETED")),
                                 When(
-                                    Q(start_date__isnull=True) & Q(end_date__isnull=True),
+                                    end_date__lt=timezone.now(), then=Value("COMPLETED")
+                                ),
+                                When(
+                                    Q(start_date__isnull=True)
+                                    & Q(end_date__isnull=True),
                                     then=Value("DRAFT"),
                                 ),
                                 default=Value("DRAFT"),
@@ -507,7 +587,9 @@ def get(self, request, slug):
                             )
                         )
                         .order_by("-created_at")
-                        .values("member__avatar_url", "member__display_name", "member__id")[:count]
+                        .values(
+                            "member__avatar_url", "member__display_name", "member__id"
+                        )[:count]
                     )
                     response_data["user_mention"] = list(users)
 
@@ -521,12 +603,15 @@ def get(self, request, slug):
                     projects = (
                         Project.objects.filter(
                             q,
-                            Q(project_projectmember__member=self.request.user) | Q(network=2),
+                            Q(project_projectmember__member=self.request.user)
+                            | Q(network=2),
                             workspace__slug=slug,
                         )
                         .order_by("-created_at")
                         .distinct()
-                        .values("name", "id", "identifier", "logo_props", "workspace__slug")[:count]
+                        .values(
+                            "name", "id", "identifier", "logo_props", "workspace__slug"
+                        )[:count]
                     )
                     response_data["project"] = list(projects)
 
@@ -583,16 +668,20 @@ def get(self, request, slug):
                         .annotate(
                             status=Case(
                                 When(
-                                    Q(start_date__lte=timezone.now()) & Q(end_date__gte=timezone.now()),
+                                    Q(start_date__lte=timezone.now())
+                                    & Q(end_date__gte=timezone.now()),
                                     then=Value("CURRENT"),
                                 ),
                                 When(
                                     start_date__gt=timezone.now(),
                                     then=Value("UPCOMING"),
                                 ),
-                                When(end_date__lt=timezone.now(), then=Value("COMPLETED")),
                                 When(
-                                    Q(start_date__isnull=True) & Q(end_date__isnull=True),
+                                    end_date__lt=timezone.now(), then=Value("COMPLETED")
+                                ),
+                                When(
+                                    Q(start_date__isnull=True)
+                                    & Q(end_date__isnull=True),
                                     then=Value("DRAFT"),
                                 ),
                                 default=Value("DRAFT"),