WIP

src/sentry/notifications/types.py

@@ -196,6 +196,7 @@ class ActionTargetType(Enum):
     ISSUE_OWNERS = "IssueOwners"
     TEAM = "Team"
     MEMBER = "Member"
+    POLICY = "Policy"
 
 
 ACTION_CHOICES = [

src/sentry/rules/actions/escalation.py

@@ -1,16 +1,22 @@
 from collections.abc import Callable, Generator, Sequence
 
-from django.db.models import Q
-
 from sentry.escalation_policies import EscalationPolicy, trigger_escalation_policy
 from sentry.eventstore.models import GroupEvent
 from sentry.mail.actions import NotifyEmailTarget
 from sentry.mail.forms.notify_email import NotifyEmailForm
+from sentry.notifications.types import ActionTargetType, FallthroughChoiceType
 from sentry.rules.actions.base import EventAction
 from sentry.rules.base import CallbackFuture
-from sentry.types.actor import ActorType
 from sentry.types.rules import RuleFuture
 
+FALLTHROUGH_CHOICES = [
+    (FallthroughChoiceType.NO_ONE.value, "No One"),
+]
+
+ACTION_CHOICES = [
+    (ActionTargetType.POLICY.value, "Escalation Policy"),
+]
+
 
 class NotifyEscalationAction(EventAction):
     """Used for triggering a messages according to escalation policies."""
@@ -21,6 +27,13 @@ class NotifyEscalationAction(EventAction):
 
     form_cls = NotifyEmailForm
 
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.form_fields = {
+            "targetType": {"type": "escalationAction", "choices": ACTION_CHOICES},
+            "fallthroughType": {"type": "choice", "choices": FALLTHROUGH_CHOICES},
+        }
+
     @staticmethod
     def _create_trigger_escalation_callback(
         policy: EscalationPolicy,
@@ -33,16 +46,17 @@ def callback(event: GroupEvent, futures: Sequence[RuleFuture]) -> None:
     def after(
         self, event: GroupEvent, notification_uuid: str | None = None
     ) -> Generator[CallbackFuture]:
-        user_ids: list[int] = []
-        team_ids: list[int] = []
         target = NotifyEmailTarget.unpack(self)
-        for recipient in target.get_eligible_recipients(event):
-            if recipient.actor_type == ActorType.USER:
-                user_ids.append(recipient.id)
-            if recipient.actor_type == ActorType.TEAM:
-                team_ids.append(recipient.id)
-
-        query = EscalationPolicy.objects.filter(organization_id=event.group.organization.id)
-        query = query.filter(Q(user_id__in=user_ids) | Q(team_id__in=team_ids))
-        for policy in query:
-            yield self.future(self._create_trigger_escalation_callback(policy))
+        # plz figure out the general form for notification targets that can account for
+        # dynamic, lazy, targets.
+        assert target.target_type == ActionTargetType.POLICY, "OMG REFACTOR THIS LATER"
+
+        # Figure out healthy, secure scoping
+        policy = EscalationPolicy.objects.filter(
+            organization_id=event.organization.id, id=target.target_identifier
+        ).first()
+
+        if policy is None:
+            return
+
+        yield self.future(self._create_trigger_escalation_callback(policy))

static/app/components/policySelector.tsx

@@ -0,0 +1,126 @@
+import {useCallback, useMemo, useRef} from 'react';
+import {createFilter} from 'react-select';
+import type {Theme} from '@emotion/react';
+
+import type {
+  ControlProps,
+  GeneralSelectValue,
+  StylesConfig,
+} from 'sentry/components/forms/controls/selectControl';
+import SelectControl from 'sentry/components/forms/controls/selectControl';
+import {space} from 'sentry/styles/space';
+import type {Organization} from 'sentry/types/organization';
+import {
+  type EscalationPolicy,
+  useFetchEscalationPolicies,
+} from 'sentry/views/escalationPolicies/queries/useFetchEscalationPolicies';
+
+const optionFilter = createFilter({
+  stringify: option => `${option.label} ${option.value}`,
+});
+
+const filterOption = (canditate, input) =>
+  canditate.data.value === optionFilter(canditate, input);
+
+const getOptionValue = (option: PolicyOption) => option.value;
+
+const placeholderSelectStyles: StylesConfig = {
+  input: (provided, state) => {
+    // XXX: The `state.theme` is an emotion theme object, but it is not typed
+    // as the emotion theme object in react-select
+    const theme = state.theme as unknown as Theme;
+
+    return {
+      ...provided,
+      display: 'grid',
+      gridTemplateColumns: 'max-content 1fr',
+      alignItems: 'center',
+      gridGap: space(1),
+      ':before': {
+        backgroundColor: theme.backgroundSecondary,
+        height: 24,
+        width: 24,
+        borderRadius: 3,
+        content: '""',
+        display: 'block',
+      },
+    };
+  },
+  placeholder: provided => ({
+    ...provided,
+    paddingLeft: 32,
+  }),
+};
+
+type Props = {
+  // onChange: (value: any) => any;
+  /**
+   * Received via withOrganization
+   * Note: withOrganization collects it from the context, this is not type safe
+   */
+  organization: Organization;
+} & ControlProps;
+
+type PolicyOption = GeneralSelectValue & {};
+
+function PolicySelector(props: Props) {
+  const {organization, onChange, ...extraProps} = props;
+  const {multiple} = props;
+
+  const {isFetching, data: policies} = useFetchEscalationPolicies({
+    orgSlug: organization.slug,
+  });
+  // TODO(ts) This type could be improved when react-select types are better.
+  const selectRef = useRef<any>(null);
+
+  const createOption = useCallback(
+    (policy: EscalationPolicy): PolicyOption => ({
+      value: policy.id + '',
+      label: policy.name,
+      // leadingItems: <IdBadge team={team} hideName />,
+      // searchKey: team.slug,
+    }),
+    []
+  );
+
+  const handleChange = useCallback(
+    (newValue: PolicyOption | PolicyOption[]) => {
+      if (multiple) {
+        const options = newValue as PolicyOption[];
+        onChange?.(options);
+        return;
+      }
+
+      const option = newValue as PolicyOption;
+      onChange?.(option);
+    },
+    [multiple, onChange]
+  );
+
+  const options = useMemo(() => {
+    if (policies) return policies.map(createOption);
+    return [];
+  }, [createOption, policies]);
+
+  const styles = useMemo(
+    () => ({
+      ...(multiple ? {} : placeholderSelectStyles),
+    }),
+    [multiple]
+  );
+
+  return (
+    <SelectControl
+      ref={selectRef}
+      options={options}
+      getOptionValue={getOptionValue}
+      filterOption={filterOption}
+      styles={styles}
+      isLoading={isFetching}
+      onChange={handleChange}
+      {...extraProps}
+    />
+  );
+}
+
+export default PolicySelector;

static/app/types/alerts.tsx

@@ -5,6 +5,7 @@ import type {IssueConfigField} from './integrations';
 export const enum IssueAlertActionType {
   SLACK = 'sentry.integrations.slack.notify_action.SlackNotifyServiceAction',
   NOTIFY_EMAIL = 'sentry.mail.actions.NotifyEmailAction',
+  NOTIFY_ESCALATION = 'sentry.mail.actions.NotifyEscalationAction',
   DISCORD = 'sentry.integrations.discord.notify_action.DiscordNotifyServiceAction',
   SENTRY_APP = 'sentry.rules.actions.notify_event_sentry_app.NotifyEventSentryAppAction',
   MS_TEAMS = 'sentry.integrations.msteams.notify_action.MsTeamsNotifyServiceAction',
@@ -101,6 +102,7 @@ interface IssueAlertGenericActionConfig extends IssueAlertConfigBase {
   id:
     | `${IssueAlertActionType.SLACK}`
     | `${IssueAlertActionType.NOTIFY_EMAIL}`
+    | `${IssueAlertActionType.NOTIFY_ESCALATION}`
     | `${IssueAlertActionType.DISCORD}`
     | `${IssueAlertActionType.SENTRY_APP}`
     | `${IssueAlertActionType.MS_TEAMS}`
@@ -264,6 +266,7 @@ export enum MailActionTargetType {
   TEAM = 'Team',
   MEMBER = 'Member',
   RELEASE_MEMBERS = 'ReleaseMembers',
+  POLICY = 'Policy',
 }
 
 export enum AssigneeTargetType {

static/app/views/alerts/rules/issue/memberTeamFields.tsx

@@ -3,6 +3,7 @@ import styled from '@emotion/styled';
 
 import SelectControl from 'sentry/components/forms/controls/selectControl';
 import PanelItem from 'sentry/components/panels/panelItem';
+import PolicySelector from 'sentry/components/policySelector';
 import SelectMembers from 'sentry/components/selectMembers';
 import TeamSelector from 'sentry/components/teamSelector';
 import {space} from 'sentry/styles/space';
@@ -25,6 +26,7 @@ type Props = {
   project: Project;
   ruleData: IssueAlertRuleAction | IssueAlertRuleCondition;
   teamValue: string | number;
+  policyValue?: string | number;
 };
 
 class MemberTeamFields extends Component<Props> {
@@ -64,11 +66,14 @@ class MemberTeamFields extends Component<Props> {
       ruleData,
       memberValue,
       teamValue,
+      policyValue,
       options,
     } = this.props;
 
     const teamSelected = ruleData.targetType === teamValue;
     const memberSelected = ruleData.targetType === memberValue;
+    const policySelected = ruleData.targetType === policyValue;
+    console.log({policySelected});
 
     const selectControlStyles = {
       control: provided => ({
@@ -90,7 +95,7 @@ class MemberTeamFields extends Component<Props> {
             onChange={this.handleChangeActorType}
           />
         </SelectWrapper>
-        {(teamSelected || memberSelected) && (
+        {(teamSelected || memberSelected || policySelected) && (
           <SelectWrapper>
             {teamSelected ? (
               <TeamSelector
@@ -113,6 +118,14 @@ class MemberTeamFields extends Component<Props> {
                 styles={selectControlStyles}
                 onChange={this.handleChangeActorId}
               />
+            ) : policySelected ? (
+              <PolicySelector
+                onChange={this.handleChangeActorId}
+                organization={organization}
+                key={policyValue}
+                value={`${ruleData.targetIdentifier}`}
+                styles={selectControlStyles}
+              />
             ) : null}
           </SelectWrapper>
         )}

static/app/views/alerts/rules/issue/ruleNode.tsx

@@ -13,7 +13,7 @@ import {releaseHealth} from 'sentry/data/platformCategories';
 import {IconDelete, IconSettings} from 'sentry/icons';
 import {t, tct} from 'sentry/locale';
 import {space} from 'sentry/styles/space';
-import type {Choices, Organization, Project} from 'sentry/types';
+import type {Choices} from 'sentry/types';
 import type {
   IssueAlertConfiguration,
   IssueAlertRuleAction,
@@ -26,6 +26,8 @@ import {
   IssueAlertFilterType,
   MailActionTargetType,
 } from 'sentry/types/alerts';
+import type {Organization} from 'sentry/types/organization';
+import type {Project} from 'sentry/types/project';
 import MemberTeamFields from 'sentry/views/alerts/rules/issue/memberTeamFields';
 import SentryAppRuleModal from 'sentry/views/alerts/rules/issue/sentryAppRuleModal';
 import TicketRuleModal from 'sentry/views/alerts/rules/issue/ticketRuleModal';
@@ -129,8 +131,33 @@ function MailActionFields({
         {value: MailActionTargetType.TEAM, label: t('Team')},
         {value: MailActionTargetType.MEMBER, label: t('Member')},
       ]}
+      teamValue={MailActionTargetType.TEAM}
+      memberValue={MailActionTargetType.MEMBER}
+      policyValue={MailActionTargetType.POLICY}
+    />
+  );
+}
+
+function EscalationActionFields({
+  data,
+  organization,
+  project,
+  disabled,
+  onMemberTeamChange,
+}: FieldProps) {
+  const isInitialized = data.targetType !== undefined && `${data.targetType}`.length > 0;
+  return (
+    <MemberTeamFields
+      disabled={disabled}
+      project={project}
+      organization={organization}
+      loading={!isInitialized}
+      ruleData={data as IssueAlertRuleAction}
+      onChange={onMemberTeamChange}
+      options={[{value: MailActionTargetType.POLICY, label: t('Schedule')}]}
       memberValue={MailActionTargetType.MEMBER}
       teamValue={MailActionTargetType.TEAM}
+      policyValue={MailActionTargetType.POLICY}
     />
   );
 }
@@ -283,6 +310,7 @@ function RuleNode({
       );
     }
 
+    console.log(fieldConfig);
     switch (fieldConfig.type) {
       case 'choice':
         return <ChoiceField {...fieldProps} />;
@@ -294,6 +322,8 @@ function RuleNode({
         return <MailActionFields {...fieldProps} />;
       case 'assignee':
         return <AssigneeFilterFields {...fieldProps} />;
+      case 'escalationAction':
+        return <EscalationActionFields {...fieldProps} />;
       default:
         return null;
     }