feat(ACI): Make ProjectRuleDetailsEndpoint PUT method backwards compatible

src/sentry/api/endpoints/project_rule_details.py

@@ -1,5 +1,7 @@
 from __future__ import annotations
 
+from typing import cast
+
 import sentry_sdk
 from django.db import router, transaction
 from drf_spectacular.utils import extend_schema
@@ -12,7 +14,11 @@
 from sentry.api.api_publish_status import ApiPublishStatus
 from sentry.api.base import region_silo_endpoint
 from sentry.api.bases.rule import WorkflowEngineRuleEndpoint
-from sentry.api.endpoints.project_rules import find_duplicate_rule
+from sentry.api.endpoints.project_rules import (
+    ProjectRulePostData,
+    find_duplicate_rule,
+    format_request_data,
+)
 from sentry.api.fields.actor import OwnerActorField
 from sentry.api.serializers import serialize
 from sentry.api.serializers.models.rule import RuleSerializer, WorkflowEngineRuleSerializer
@@ -39,8 +45,10 @@
 from sentry.sentry_apps.utils.errors import SentryAppBaseError
 from sentry.signals import alert_rule_edited
 from sentry.types.actor import Actor
+from sentry.workflow_engine.endpoints.validators.base.workflow import WorkflowValidator
 from sentry.workflow_engine.models.alertrule_workflow import AlertRuleWorkflow
 from sentry.workflow_engine.models.workflow import Workflow
+from sentry.workflow_engine.models.workflow_data_condition_group import WorkflowDataConditionGroup
 from sentry.workflow_engine.utils.legacy_metric_tracking import (
     report_used_legacy_models,
     track_alert_endpoint_execution,
@@ -131,12 +139,13 @@ def get(self, request: Request, project: Project, rule: Rule | Workflow) -> Resp
         - Actions - specify what should happen when the trigger conditions are met and the filters match.
         """
         if isinstance(rule, Workflow):
+            workflow = rule
             workflow_engine_rule_serializer = WorkflowEngineRuleSerializer(
                 expand=request.GET.getlist("expand", []),
                 prepare_component_fields=True,
                 project_slug=project.slug,
             )
-            serialized_rule = serialize(rule, request.user, workflow_engine_rule_serializer)
+            serialized_rule = serialize(workflow, request.user, workflow_engine_rule_serializer)
         else:
             # Serialize Rule object
             rule_serializer = RuleSerializer(
@@ -193,13 +202,45 @@ def put(self, request: Request, project: Project, rule: Rule | Workflow) -> Resp
         - Actions - specify what should happen when the trigger conditions are met and the filters match.
         """
         if isinstance(rule, Workflow):
-            return Response(
-                {
-                    "rule": [
-                        "Passing a workflow through this endpoint is not yet supported",
-                    ]
+            workflow = rule
+            organization = project.organization
+
+            data = request.data.copy()
+
+            if not data.get("filterMatch"):
+                # if filterMatch is not passed, don't overwrite it with default value, use the saved dcg type
+                wdcg = WorkflowDataConditionGroup.objects.filter(workflow=workflow).first()
+                if wdcg:
+                    data["filterMatch"] = wdcg.condition_group.logic_type
+
+            request_data = format_request_data(cast(ProjectRulePostData, data))
+            if not request_data.get("config", {}).get("frequency"):
+                request_data["config"] = workflow.config
+
+            validator = WorkflowValidator(
+                data=request_data,
+                context={
+                    "organization": organization,
+                    "request": request,
+                    "workflow": workflow,
                 },
-                status=status.HTTP_400_BAD_REQUEST,
+            )
+            validator.is_valid(raise_exception=True)
+
+            with transaction.atomic(router.db_for_write(Workflow)):
+                validator.update(workflow, validator.validated_data)
+                self.create_audit_entry(
+                    request=request,
+                    organization=organization,
+                    target_object=workflow.id,
+                    event=audit_log.get_event_id("WORKFLOW_EDIT"),
+                    data=workflow.get_audit_log_data(),
+                )
+
+            workflow.refresh_from_db()
+            return Response(
+                serialize(workflow, request.user, WorkflowEngineRuleSerializer()),
+                status=200,
             )
 
         rule_data_before = dict(rule.data)

src/sentry/api/endpoints/project_rules.py

@@ -8,6 +8,7 @@
 from django.dispatch import receiver
 from drf_spectacular.utils import extend_schema
 from rest_framework import serializers, status
+from rest_framework.exceptions import ValidationError
 from rest_framework.request import Request
 from rest_framework.response import Response
 
@@ -727,7 +728,7 @@ class ProjectRulePostData(TypedDict):
     conditions: list[ConditionsData]
     actions: list[dict[str, Any]]
     environment: NotRequired[str | None]
-    owner: NotRequired[str | None]
+    owner: NotRequired[str | int | None]
     filterMatch: NotRequired[Literal["all", "any", "none"]]
     filters: NotRequired[list[FiltersData]]
     status: NotRequired[str]
@@ -744,22 +745,33 @@ def format_request_data(
         "environment": data.get("environment"),
         "config": {"frequency": data.get("frequency")},
     }
-
     triggers: dict[str, Any] = {"logicType": "any-short", "conditions": []}
     translated_filter_list = []
     fake_dcg = DataConditionGroup()
     # XXX: In order to avoid making bigger changes to translate_to_data_condition in issue_alert_conditions.py
     # we pass in a dummy DCG and then pop it off since we just need the formatted data
 
     for condition in data.get("conditions", []):
-        translated_conditions = asdict(translate_to_data_condition_data(condition, fake_dcg))
+        try:
+            translated_conditions = asdict(translate_to_data_condition_data(condition, fake_dcg))
+        except KeyError:
+            raise ValidationError("Ensure all required fields are filled in.")
+        except ValueError:
+            raise ValidationError("Invalid condition data")
+
         translated_conditions.pop("condition_group")
         triggers["conditions"].append(translated_conditions)
 
     workflow_payload["triggers"] = triggers
 
     for filter_data in data.get("filters", []):
-        translated_filters = asdict(translate_to_data_condition_data(filter_data, fake_dcg))
+        try:
+            translated_filters = asdict(translate_to_data_condition_data(filter_data, fake_dcg))
+        except KeyError:
+            raise ValidationError("Ensure all required fields are filled in.")
+        except ValueError:
+            raise ValidationError("Invalid filter data")
+
         translated_filters.pop("condition_group")
         translated_filter_list.append(translated_filters)
 

src/sentry/api/serializers/models/rule.py

@@ -635,12 +635,27 @@ def get_attrs(self, item_list: Sequence[Workflow], user, **kwargs):
                 if action.data.get("notes") == "":
                     action_data.pop("notes", None)
 
+                # XXX: workspace needs to be returned as a string
+                if action_data.get("workspace"):
+                    action_data["workspace"] = str(action_data["workspace"])
+
                 serialized_actions.append(action_data)
 
             # Generate conditions and filters
             conditions, filters = self._generate_rule_conditions_filters(
                 workflow, result[workflow]["projects"][0], workflow_dcg
             )
+            for f in filters:
+                # IssueCategoryFilter stores numeric string choices and must stay as str
+                if (
+                    f.get("value")
+                    and f.get("id") != "sentry.rules.filters.issue_category.IssueCategoryFilter"
+                ):
+                    try:
+                        f["value"] = int(f["value"])
+                    except (ValueError, TypeError):
+                        continue
+
             result[workflow]["conditions"] = conditions
             result[workflow]["filters"] = filters