feat(aci): add GET DataCondition endpoint

Author: ameliahsu

src/sentry/workflow_engine/endpoints/organization_data_condition_index.py

@@ -0,0 +1,73 @@
+from drf_spectacular.utils import extend_schema
+from rest_framework import serializers, status
+from rest_framework.response import Response
+
+from sentry.api.api_owners import ApiOwner
+from sentry.api.api_publish_status import ApiPublishStatus
+from sentry.api.base import region_silo_endpoint
+from sentry.api.bases import OrganizationEndpoint
+from sentry.api.paginator import OffsetPaginator
+from sentry.api.serializers import serialize
+from sentry.apidocs.constants import (
+    RESPONSE_BAD_REQUEST,
+    RESPONSE_FORBIDDEN,
+    RESPONSE_NOT_FOUND,
+    RESPONSE_UNAUTHORIZED,
+)
+from sentry.apidocs.parameters import GlobalParams
+from sentry.workflow_engine.endpoints.serializers import DataConditionHandlerSerializer
+from sentry.workflow_engine.models.data_condition import IGNORED_CONDITIONS
+from sentry.workflow_engine.registry import condition_handler_registry
+from sentry.workflow_engine.types import DataConditionHandler
+
+
+class DataConditionRequestSerializer(serializers.Serializer):
+    type = serializers.ChoiceField(choices=DataConditionHandler.Type, required=False)
+
+
+@region_silo_endpoint
+class OrganizationDataConditionIndexEndpoint(OrganizationEndpoint):
+    publish_status = {
+        "GET": ApiPublishStatus.EXPERIMENTAL,
+    }
+    owner = ApiOwner.ISSUES
+
+    @extend_schema(
+        operation_id="Fetch Data Conditions",
+        parameters=[
+            GlobalParams.ORG_ID_OR_SLUG,
+        ],
+        responses={
+            201: DataConditionHandlerSerializer,
+            400: RESPONSE_BAD_REQUEST,
+            401: RESPONSE_UNAUTHORIZED,
+            403: RESPONSE_FORBIDDEN,
+            404: RESPONSE_NOT_FOUND,
+        },
+    )
+    def get(self, request, organization):
+        """
+        Returns a list of data conditions for a given org
+        """
+        serializer = DataConditionRequestSerializer(data=request.GET)
+        if not serializer.is_valid():
+            return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+        serialized = serializer.validated_data
+
+        type = serialized.get("type")
+
+        data_conditions = []
+
+        for condition, handler in condition_handler_registry.registrations.items():
+            if not type or (condition not in IGNORED_CONDITIONS and handler.type == type):
+                condition_json = {"condition_id": condition.value}
+                condition_json.update(
+                    serialize(handler, request.user, DataConditionHandlerSerializer())
+                )
+                data_conditions.append(condition_json)
+
+        return self.paginate(
+            request=request,
+            queryset=data_conditions,
+            paginator_cls=OffsetPaginator,
+        )

src/sentry/workflow_engine/endpoints/serializers.py

@@ -17,7 +17,7 @@
     WorkflowDataConditionGroup,
 )
 from sentry.workflow_engine.models.data_condition_group_action import DataConditionGroupAction
-from sentry.workflow_engine.types import DataSourceTypeHandler
+from sentry.workflow_engine.types import DataConditionHandler, DataSourceTypeHandler
 
 
 @register(Action)
@@ -122,6 +122,18 @@ def serialize(
         }
 
 
+@register(DataConditionHandler)
+class DataConditionHandlerSerializer(Serializer):
+    def serialize(self, obj: DataConditionHandler, *args, **kwargs) -> dict[str, Any]:
+        result = {
+            "type": obj.type.value,
+            "comparison_json_schema": obj.comparison_json_schema,
+        }
+        if hasattr(obj, "filter_group"):
+            result["filter_group"] = obj.filter_group.value
+        return result
+
+
 @register(Detector)
 class DetectorSerializer(Serializer):
     def get_attrs(

src/sentry/workflow_engine/endpoints/urls.py

@@ -1,5 +1,6 @@
 from django.urls import re_path
 
+from .organization_data_condition_index import OrganizationDataConditionIndexEndpoint
 from .organization_workflow_details import OrganizationWorkflowDetailsEndpoint
 from .organization_workflow_index import OrganizationWorkflowIndexEndpoint
 from .project_detector_details import ProjectDetectorDetailsEndpoint
@@ -40,4 +41,9 @@
         OrganizationWorkflowDetailsEndpoint.as_view(),
         name="sentry-api-0-organization-workflow-details",
     ),
+    re_path(
+        r"^(?P<organization_id_or_slug>[^\/]+)/data_conditions/$",
+        OrganizationDataConditionIndexEndpoint.as_view(),
+        name="sentry-api-0-organization-data-condition-index",
+    ),
 ]

src/sentry/workflow_engine/models/data_condition.py

@@ -82,6 +82,17 @@ class Condition(StrEnum):
     Condition.PERCENT_SESSIONS_COUNT,
 ] + PERCENT_CONDITIONS
 
+# Conditions that are not supported in the UI
+IGNORED_CONDITIONS = [
+    Condition.EVERY_EVENT,
+    Condition.EVENT_CREATED_BY_DETECTOR,
+    Condition.EVENT_SEEN_COUNT,
+    Condition.NEW_HIGH_PRIORITY_ISSUE,
+    Condition.EXISTING_HIGH_PRIORITY_ISSUE,
+    Condition.ISSUE_CATEGORY,
+    Condition.ISSUE_RESOLUTION_CHANGE,
+]
+
 
 T = TypeVar("T")
 

tests/sentry/workflow_engine/endpoints/test_organization_data_condition_index.py

@@ -0,0 +1,86 @@
+from dataclasses import dataclass
+from unittest.mock import patch
+
+from sentry.testutils.cases import APITestCase
+from sentry.testutils.silo import region_silo_test
+from sentry.utils.registry import Registry
+from sentry.workflow_engine.models.data_condition import Condition
+from sentry.workflow_engine.types import DataConditionHandler
+
+
+class OrganizationDataConditionAPITestCase(APITestCase):
+    endpoint = "sentry-api-0-organization-data-condition-index"
+
+    def setUp(self):
+        super().setUp()
+        self.login_as(user=self.user)
+        self.registry = Registry[DataConditionHandler](enable_reverse_lookup=False)
+        self.registry_patcher = patch(
+            "sentry.workflow_engine.registry.condition_handler_registry",
+            new=self.registry,
+        )
+        self.registry_patcher.__enter__()
+
+        @self.registry.register(Condition.REAPPEARED_EVENT)
+        @dataclass(frozen=True)
+        class TestWorkflowTrigger(DataConditionHandler):
+            type = DataConditionHandler.Type.WORKFLOW_TRIGGER
+            comparison_json_schema = {"type": "boolean"}
+
+        @self.registry.register(Condition.AGE_COMPARISON)
+        @dataclass(frozen=True)
+        class TestActionFilter(DataConditionHandler):
+            type = DataConditionHandler.Type.ACTION_FILTER
+            filter_group = DataConditionHandler.FilterGroup.ISSUE_ATTRIBUTES
+            comparison_json_schema = {
+                "type": "object",
+                "properties": {
+                    "value": {"type": "integer", "minimum": 0},
+                },
+                "required": ["value"],
+                "additionalProperties": False,
+            }
+
+    def tearDown(self) -> None:
+        super().tearDown()
+        self.registry_patcher.__exit__(None, None, None)
+
+
+@region_silo_test
+class OrganizationDataCondiitonIndexBaseTest(OrganizationDataConditionAPITestCase):
+    def test_simple(self):
+        response = self.get_success_response(self.organization.slug)
+        assert len(response.data) == 2
+
+    def test_type_filter(self):
+        response = self.get_success_response(
+            self.organization.slug, type=DataConditionHandler.Type.WORKFLOW_TRIGGER
+        )
+        assert len(response.data) == 1
+        assert response.data[0] == {
+            "condition_id": Condition.REAPPEARED_EVENT.value,
+            "type": DataConditionHandler.Type.WORKFLOW_TRIGGER.value,
+            "comparison_json_schema": {"type": "boolean"},
+        }
+
+        response = self.get_success_response(
+            self.organization.slug, type=DataConditionHandler.Type.ACTION_FILTER
+        )
+        assert len(response.data) == 1
+        assert response.data[0] == {
+            "condition_id": Condition.AGE_COMPARISON.value,
+            "type": DataConditionHandler.Type.ACTION_FILTER.value,
+            "filter_group": DataConditionHandler.FilterGroup.ISSUE_ATTRIBUTES.value,
+            "comparison_json_schema": {
+                "type": "object",
+                "properties": {
+                    "value": {"type": "integer", "minimum": 0},
+                },
+                "required": ["value"],
+                "additionalProperties": False,
+            },
+        }
+
+    def test_invalid_type(self):
+        response = self.get_error_response(self.organization.slug, type="invalid")
+        assert response.status_code == 400