feat(aci): Allow user to filter monitors by assignee

Author: leedongwei

src/sentry/workflow_engine/endpoints/organization_detector_index.py

@@ -29,6 +29,7 @@
 from sentry.issues import grouptype
 from sentry.models.organization import Organization
 from sentry.models.project import Project
+from sentry.search.utils import parse_actor_or_none_value
 from sentry.workflow_engine.endpoints.serializers import DetectorSerializer
 from sentry.workflow_engine.endpoints.utils.filters import apply_filter
 from sentry.workflow_engine.endpoints.utils.sortby import SortByParam
@@ -39,12 +40,40 @@
 detector_search_config = SearchConfig.create_from(
     default_config,
     text_operator_keys={"name", "type"},
-    allowed_keys={"name", "type"},
+    allowed_keys={"name", "type", "assignee"},
     allow_boolean=False,
     free_text_key="query",
 )
 parse_detector_query = partial(base_parse_search_query, config=detector_search_config)
 
+
+def convert_assignee_value(value: str, projects: list[Project], user) -> Q:
+    """
+    Convert an assignee search value to a Django Q object for filtering detectors.
+    """
+    if value == "me":
+        # Handle "me" keyword to search for current user
+        return Q(owner_user_id=user.id)
+    elif value == "unassigned":
+        # Handle "unassigned" keyword
+        return Q(owner_user_id__isnull=True, owner_team__isnull=True)
+    else:
+        # Parse actor (user or team) and create appropriate Q object
+        actor = parse_actor_or_none_value(projects, value, user)
+        if actor is None:
+            # If we can't parse the actor, return a query that matches nothing
+            return Q(pk__isnull=True)
+        elif hasattr(actor, "id") and hasattr(actor, "_meta") and actor._meta.model_name == "user":
+            # It's a user
+            return Q(owner_user_id=actor.id)
+        elif hasattr(actor, "id") and hasattr(actor, "_meta") and actor._meta.model_name == "team":
+            # It's a team
+            return Q(owner_team_id=actor.id)
+        else:
+            # Unknown actor type, return a query that matches nothing
+            return Q(pk__isnull=True)
+
+
 # Maps API field name to database field name, with synthetic aggregate fields keeping
 # to our field naming scheme for consistency.
 SORT_ATTRS = {
@@ -134,6 +163,24 @@ def get(self, request: Request, organization: Organization) -> Response:
                         queryset = apply_filter(queryset, filter, "name")
                     case SearchFilter(key=SearchKey("type"), operator=("=" | "IN" | "!=")):
                         queryset = apply_filter(queryset, filter, "type")
+                    case SearchFilter(key=SearchKey("assignee"), operator=("=" | "IN" | "!=")):
+                        breakpoint()
+                        # Handle assignee filtering with support for users, teams, "me", and "unassigned"
+                        if isinstance(filter.value.value, list):
+                            # Handle multiple values (IN operator)
+                            assignee_q = Q()
+                            for value in filter.value.value:
+                                assignee_q |= convert_assignee_value(value, projects, request.user)
+                        else:
+                            # Handle single value
+                            assignee_q = convert_assignee_value(
+                                filter.value.value, projects, request.user
+                            )
+
+                        if filter.operator == "!=":
+                            queryset = queryset.exclude(assignee_q)
+                        else:
+                            queryset = queryset.filter(assignee_q)
                     case SearchFilter(key=SearchKey("query"), operator="="):
                         # 'query' is our free text key; all free text gets returned here
                         # as '=', and we search any relevant fields for it.

static/app/views/detectors/components/detectorSearch.tsx

@@ -1,8 +1,9 @@
 import {SearchQueryBuilder} from 'sentry/components/searchQueryBuilder';
 import {t} from 'sentry/locale';
-import type {TagCollection} from 'sentry/types/group';
+import type {Tag, TagCollection} from 'sentry/types/group';
 import type {FieldDefinition} from 'sentry/utils/fields';
 import {FieldKind} from 'sentry/utils/fields';
+import useAssignedSearchValues from 'sentry/utils/membersAndTeams/useAssignedSearchValues';
 import {useLocation} from 'sentry/utils/useLocation';
 import {useNavigate} from 'sentry/utils/useNavigate';
 import {DETECTOR_FILTER_KEYS} from 'sentry/views/detectors/constants';
@@ -23,27 +24,68 @@ function getDetectorFilterKeyDefinition(filterKey: string): FieldDefinition | nu
   return null;
 }
 
-const FILTER_KEYS: TagCollection = Object.fromEntries(
-  Object.keys(DETECTOR_FILTER_KEYS).map(key => {
-    const {values} = DETECTOR_FILTER_KEYS[key] ?? {};
-
-    return [
-      key,
-      {
-        key,
-        name: key,
-        predefined: values !== undefined,
-        values,
-      },
-    ];
-  })
-);
-
 export function DetectorSearch() {
   const location = useLocation();
   const navigate = useNavigate();
+  const assignedValues = useAssignedSearchValues();
   const query = typeof location.query.query === 'string' ? location.query.query : '';
 
+  const filterKeys: TagCollection = Object.fromEntries(
+    Object.keys(DETECTOR_FILTER_KEYS).map(key => {
+      const {values} = DETECTOR_FILTER_KEYS[key] ?? {};
+
+      // Special handling for assignee field to provide user/team values
+      if (key === 'assignee') {
+        return [
+          key,
+          {
+            key,
+            name: key,
+            predefined: true,
+            values: assignedValues,
+          },
+        ];
+      }
+
+      return [
+        key,
+        {
+          key,
+          name: key,
+          predefined: values !== undefined,
+          values,
+        },
+      ];
+    })
+  );
+
+  const getTagValues = (tag: Tag, _query: string): string[] => {
+    // For assignee field, return the assigned values filtered by query
+    if (tag.key === 'assignee') {
+      const allAssigneeValues: string[] = [];
+      assignedValues.forEach(group => {
+        if (Array.isArray(group.children)) {
+          group.children.forEach(child => {
+            if (typeof child.value === 'string') {
+              allAssigneeValues.push(child.value);
+            }
+          });
+        }
+      });
+
+      // Filter by query if provided
+      if (_query) {
+        return allAssigneeValues.filter(value =>
+          value.toLowerCase().includes(query.toLowerCase())
+        );
+      }
+      return allAssigneeValues;
+    }
+
+    // For other fields, return empty array (no dynamic values)
+    return [];
+  };
+
   return (
     <SearchQueryBuilder
       initialQuery={query}
@@ -57,8 +99,8 @@ export function DetectorSearch() {
           },
         });
       }}
-      filterKeys={FILTER_KEYS}
-      getTagValues={() => Promise.resolve([])}
+      filterKeys={filterKeys}
+      getTagValues={getTagValues}
       searchSource="detectors-list"
       fieldDefinitionGetter={getDetectorFilterKeyDefinition}
       disallowUnsupportedFilters

static/app/views/detectors/constants.tsx

@@ -36,4 +36,9 @@ export const DETECTOR_FILTER_KEYS: Record<
     ] satisfies DetectorType[],
     keywords: ['type'],
   },
+  assignee: {
+    description: 'User or team assigned to the detector',
+    valueType: FieldValueType.STRING,
+    keywords: ['assigned', 'owner'],
+  },
 };