def test(self):
type = AlertRuleTriggerAction.Type.EMAIL
target_type = AlertRuleTriggerAction.TargetType.TEAM
target_identifier = six.text_type(self.team.id)
update_alert_rule_trigger_action(
self.action, type=type, target_type=target_type, target_identifier=target_identifier
)
assert self.action.type == type.value
assert self.action.target_type == target_type.value
assert self.action.target_identifier == target_identifier
def update(self, instance, validated_data):
if "id" in validated_data:
validated_data.pop("id")
try:
return update_alert_rule_trigger_action(instance, **validated_data)
except InvalidTriggerActionError as e:
raise serializers.ValidationError(e.message)
def test_slack(self):
integration = Integration.objects.create(
external_id="1",
provider="slack",
metadata={"access_token": "xoxp-xxxxxxxxx-xxxxxxxxxx-xxxxxxxxxxxx"},
)
integration.add_organization(self.organization, self.user)
type = AlertRuleTriggerAction.Type.SLACK
target_type = AlertRuleTriggerAction.TargetType.SPECIFIC
channel_name = "#some_channel"
channel_id = "s_c"
responses.add(
method=responses.GET,
url="https://slack.com/api/channels.list",
status=200,
content_type="application/json",
body=json.dumps(
{"ok": "true", "channels": [{"name": channel_name[1:], "id": channel_id}]}
),
)
action = update_alert_rule_trigger_action(
self.action, type, target_type, target_identifier=channel_name, integration=integration
)
assert action.alert_rule_trigger == self.trigger
assert action.type == type.value
assert action.target_type == target_type.value
assert action.target_identifier == channel_id
assert action.target_display == channel_name
assert action.integration == integration
def update(self, instance, validated_data):
with transaction.atomic():
validated_data = self._remove_unchanged_fields(
instance, validated_data)
triggers_data = validated_data.pop("triggers")
alert_rule = update_alert_rule(instance, **validated_data)
# Delete triggers we don't have present in the updated data.
trigger_ids = [x["id"] for x in triggers_data]
AlertRuleTrigger.objects.filter(alert_rule=alert_rule).exclude(
id__in=trigger_ids).delete()
for trigger_data in triggers_data:
actions_data = trigger_data.pop("actions")
try:
if "id" in trigger_data:
trigger_instance = AlertRuleTrigger.objects.get(
alert_rule=alert_rule, id=trigger_data["id"])
trigger_data.pop("id")
trigger = update_alert_rule_trigger(
trigger_instance, **trigger_data)
else:
trigger = create_alert_rule_trigger(
alert_rule=alert_rule, **trigger_data)
except AlertRuleTriggerLabelAlreadyUsedError:
raise serializers.ValidationError(
"This trigger label is already in use for this alert rule"
)
# Delete actions we don't have present in the updated data.
action_ids = [x["id"] for x in actions_data]
AlertRuleTriggerAction.objects.filter(
alert_rule_trigger=trigger).exclude(
id__in=action_ids).delete()
for action_data in actions_data:
if "id" in action_data:
action_instance = AlertRuleTriggerAction.objects.get(
alert_rule_trigger=trigger, id=action_data["id"])
action_data.pop("id")
update_alert_rule_trigger_action(
action_instance, **action_data)
else:
create_alert_rule_trigger_action(trigger=trigger,
**action_data)
return alert_rule
def update(self, instance, validated_data):
if "id" in validated_data:
validated_data.pop("id")
try:
return update_alert_rule_trigger_action(instance, **validated_data)
except InvalidTriggerActionError as e:
raise serializers.ValidationError(force_text(e))
except ApiRateLimitedError as e:
raise serializers.ValidationError(force_text(e))
def update(self, instance, validated_data):
validated_data = self._remove_unchanged_fields(instance, validated_data)
return update_alert_rule_trigger_action(instance, **validated_data)
def update(self, instance, validated_data):
if "id" in validated_data:
validated_data.pop("id")
return update_alert_rule_trigger_action(instance, **validated_data)
