From 1734bfb84864bf514739e81a36ef7c421fe1e0d9 Mon Sep 17 00:00:00 2001 From: "ci.datadog-api-spec" Date: Mon, 6 Oct 2025 14:47:47 +0000 Subject: [PATCH] Regenerate client from commit 627a896 of spec repo --- .generator/schemas/v2/openapi.yaml | 38 ++++ ...ateMonitorNotificationRule_1181818787.java | 56 +++++ ...ateMonitorNotificationRule_1400905713.java | 61 ++++++ .../MonitorNotificationRuleAttributes.java | 49 ++++- .../MonitorNotificationRuleCondition.java | 183 ++++++++++++++++ ...NotificationRuleConditionalRecipients.java | 203 ++++++++++++++++++ ...torNotificationRuleResponseAttributes.java | 39 +++- ...onal_recipients_returns_OK_response.freeze | 1 + ...tional_recipients_returns_OK_response.json | 57 +++++ ...onal_recipients_returns_OK_response.freeze | 1 + ...tional_recipients_returns_OK_response.json | 87 ++++++++ .../api/client/v2/api/monitors.feature | 18 ++ 12 files changed, 784 insertions(+), 9 deletions(-) create mode 100644 examples/v2/monitors/CreateMonitorNotificationRule_1181818787.java create mode 100644 examples/v2/monitors/UpdateMonitorNotificationRule_1400905713.java create mode 100644 src/main/java/com/datadog/api/client/v2/model/MonitorNotificationRuleCondition.java create mode 100644 src/main/java/com/datadog/api/client/v2/model/MonitorNotificationRuleConditionalRecipients.java create mode 100644 src/test/resources/cassettes/features/v2/Create_a_monitor_notification_rule_with_conditional_recipients_returns_OK_response.freeze create mode 100644 src/test/resources/cassettes/features/v2/Create_a_monitor_notification_rule_with_conditional_recipients_returns_OK_response.json create mode 100644 src/test/resources/cassettes/features/v2/Update_a_monitor_notification_rule_with_conditional_recipients_returns_OK_response.freeze create mode 100644 src/test/resources/cassettes/features/v2/Update_a_monitor_notification_rule_with_conditional_recipients_returns_OK_response.json diff --git a/.generator/schemas/v2/openapi.yaml b/.generator/schemas/v2/openapi.yaml index 17509b56882..a0d18121678 100644 --- a/.generator/schemas/v2/openapi.yaml +++ b/.generator/schemas/v2/openapi.yaml @@ -29565,6 +29565,8 @@ components: additionalProperties: false description: Attributes of the monitor notification rule. properties: + conditional_recipients: + $ref: '#/components/schemas/MonitorNotificationRuleConditionalRecipients' filter: $ref: '#/components/schemas/MonitorNotificationRuleFilter' name: @@ -29573,8 +29575,36 @@ components: $ref: '#/components/schemas/MonitorNotificationRuleRecipients' required: - name + type: object + MonitorNotificationRuleCondition: + description: Conditions for `conditional_recipients`. + properties: + recipients: + $ref: '#/components/schemas/MonitorNotificationRuleRecipients' + scope: + $ref: '#/components/schemas/MonitorNotificationRuleScope' + required: + - scope - recipients type: object + MonitorNotificationRuleConditionalRecipients: + description: Use conditional recipients to define different recipients for different + situations. + properties: + conditions: + description: Conditions of the notification rule. + items: + $ref: '#/components/schemas/MonitorNotificationRuleCondition' + maxItems: 10 + minItems: 1 + type: array + fallback_recipients: + $ref: '#/components/schemas/MonitorNotificationRuleRecipients' + description: If none of the `conditions` applied, `fallback_recipients` + will get notified. + required: + - conditions + type: object MonitorNotificationRuleCreateRequest: description: Request for creating a monitor notification rule. properties: @@ -29714,6 +29744,8 @@ components: additionalProperties: {} description: Attributes of the monitor notification rule. properties: + conditional_recipients: + $ref: '#/components/schemas/MonitorNotificationRuleConditionalRecipients' created: description: Creation time of the monitor notification rule. example: 2020-01-02 03:04:00+00:00 @@ -29735,6 +29767,12 @@ components: description: An object related to a monitor notification rule. oneOf: - $ref: '#/components/schemas/User' + MonitorNotificationRuleScope: + description: The scope to which the monitor applied. + example: transition_type:alert + maxLength: 3000 + minLength: 1 + type: string MonitorNotificationRuleUpdateRequest: description: Request for updating a monitor notification rule. properties: diff --git a/examples/v2/monitors/CreateMonitorNotificationRule_1181818787.java b/examples/v2/monitors/CreateMonitorNotificationRule_1181818787.java new file mode 100644 index 00000000000..4d8cb8adfbd --- /dev/null +++ b/examples/v2/monitors/CreateMonitorNotificationRule_1181818787.java @@ -0,0 +1,56 @@ +// Create a monitor notification rule with conditional recipients returns "OK" response + +import com.datadog.api.client.ApiClient; +import com.datadog.api.client.ApiException; +import com.datadog.api.client.v2.api.MonitorsApi; +import com.datadog.api.client.v2.model.MonitorNotificationRuleAttributes; +import com.datadog.api.client.v2.model.MonitorNotificationRuleCondition; +import com.datadog.api.client.v2.model.MonitorNotificationRuleConditionalRecipients; +import com.datadog.api.client.v2.model.MonitorNotificationRuleCreateRequest; +import com.datadog.api.client.v2.model.MonitorNotificationRuleCreateRequestData; +import com.datadog.api.client.v2.model.MonitorNotificationRuleFilter; +import com.datadog.api.client.v2.model.MonitorNotificationRuleFilterTags; +import com.datadog.api.client.v2.model.MonitorNotificationRuleResourceType; +import com.datadog.api.client.v2.model.MonitorNotificationRuleResponse; +import java.util.Arrays; +import java.util.Collections; + +public class Example { + public static void main(String[] args) { + ApiClient defaultClient = ApiClient.getDefaultApiClient(); + MonitorsApi apiInstance = new MonitorsApi(defaultClient); + + MonitorNotificationRuleCreateRequest body = + new MonitorNotificationRuleCreateRequest() + .data( + new MonitorNotificationRuleCreateRequestData() + .attributes( + new MonitorNotificationRuleAttributes() + .filter( + new MonitorNotificationRuleFilter( + new MonitorNotificationRuleFilterTags() + .tags(Collections.singletonList("test:example-monitor")))) + .name("test rule") + .conditionalRecipients( + new MonitorNotificationRuleConditionalRecipients() + .conditions( + Collections.singletonList( + new MonitorNotificationRuleCondition() + .scope("transition_type:is_alert") + .recipients( + Arrays.asList( + "slack-test-channel", "jira-test")))))) + .type(MonitorNotificationRuleResourceType.MONITOR_NOTIFICATION_RULE)); + + try { + MonitorNotificationRuleResponse result = apiInstance.createMonitorNotificationRule(body); + System.out.println(result); + } catch (ApiException e) { + System.err.println("Exception when calling MonitorsApi#createMonitorNotificationRule"); + System.err.println("Status code: " + e.getCode()); + System.err.println("Reason: " + e.getResponseBody()); + System.err.println("Response headers: " + e.getResponseHeaders()); + e.printStackTrace(); + } + } +} diff --git a/examples/v2/monitors/UpdateMonitorNotificationRule_1400905713.java b/examples/v2/monitors/UpdateMonitorNotificationRule_1400905713.java new file mode 100644 index 00000000000..52838217567 --- /dev/null +++ b/examples/v2/monitors/UpdateMonitorNotificationRule_1400905713.java @@ -0,0 +1,61 @@ +// Update a monitor notification rule with conditional_recipients returns "OK" response + +import com.datadog.api.client.ApiClient; +import com.datadog.api.client.ApiException; +import com.datadog.api.client.v2.api.MonitorsApi; +import com.datadog.api.client.v2.model.MonitorNotificationRuleAttributes; +import com.datadog.api.client.v2.model.MonitorNotificationRuleCondition; +import com.datadog.api.client.v2.model.MonitorNotificationRuleConditionalRecipients; +import com.datadog.api.client.v2.model.MonitorNotificationRuleFilter; +import com.datadog.api.client.v2.model.MonitorNotificationRuleFilterTags; +import com.datadog.api.client.v2.model.MonitorNotificationRuleResourceType; +import com.datadog.api.client.v2.model.MonitorNotificationRuleResponse; +import com.datadog.api.client.v2.model.MonitorNotificationRuleUpdateRequest; +import com.datadog.api.client.v2.model.MonitorNotificationRuleUpdateRequestData; +import java.util.Arrays; +import java.util.Collections; + +public class Example { + public static void main(String[] args) { + ApiClient defaultClient = ApiClient.getDefaultApiClient(); + MonitorsApi apiInstance = new MonitorsApi(defaultClient); + + // there is a valid "monitor_notification_rule" in the system + String MONITOR_NOTIFICATION_RULE_DATA_ID = System.getenv("MONITOR_NOTIFICATION_RULE_DATA_ID"); + + MonitorNotificationRuleUpdateRequest body = + new MonitorNotificationRuleUpdateRequest() + .data( + new MonitorNotificationRuleUpdateRequestData() + .attributes( + new MonitorNotificationRuleAttributes() + .filter( + new MonitorNotificationRuleFilter( + new MonitorNotificationRuleFilterTags() + .tags(Arrays.asList("test:example-monitor", "host:abc")))) + .name("updated rule") + .conditionalRecipients( + new MonitorNotificationRuleConditionalRecipients() + .conditions( + Collections.singletonList( + new MonitorNotificationRuleCondition() + .scope("transition_type:is_alert") + .recipients( + Arrays.asList( + "slack-test-channel", "jira-test")))))) + .id(MONITOR_NOTIFICATION_RULE_DATA_ID) + .type(MonitorNotificationRuleResourceType.MONITOR_NOTIFICATION_RULE)); + + try { + MonitorNotificationRuleResponse result = + apiInstance.updateMonitorNotificationRule(MONITOR_NOTIFICATION_RULE_DATA_ID, body); + System.out.println(result); + } catch (ApiException e) { + System.err.println("Exception when calling MonitorsApi#updateMonitorNotificationRule"); + System.err.println("Status code: " + e.getCode()); + System.err.println("Reason: " + e.getResponseBody()); + System.err.println("Response headers: " + e.getResponseHeaders()); + e.printStackTrace(); + } + } +} diff --git a/src/main/java/com/datadog/api/client/v2/model/MonitorNotificationRuleAttributes.java b/src/main/java/com/datadog/api/client/v2/model/MonitorNotificationRuleAttributes.java index e791064cd5d..fc6d0c14cab 100644 --- a/src/main/java/com/datadog/api/client/v2/model/MonitorNotificationRuleAttributes.java +++ b/src/main/java/com/datadog/api/client/v2/model/MonitorNotificationRuleAttributes.java @@ -17,6 +17,7 @@ /** Attributes of the monitor notification rule. */ @JsonPropertyOrder({ + MonitorNotificationRuleAttributes.JSON_PROPERTY_CONDITIONAL_RECIPIENTS, MonitorNotificationRuleAttributes.JSON_PROPERTY_FILTER, MonitorNotificationRuleAttributes.JSON_PROPERTY_NAME, MonitorNotificationRuleAttributes.JSON_PROPERTY_RECIPIENTS @@ -25,6 +26,9 @@ value = "https://github.com/DataDog/datadog-api-client-java/blob/master/.generator") public class MonitorNotificationRuleAttributes { @JsonIgnore public boolean unparsed = false; + public static final String JSON_PROPERTY_CONDITIONAL_RECIPIENTS = "conditional_recipients"; + private MonitorNotificationRuleConditionalRecipients conditionalRecipients; + public static final String JSON_PROPERTY_FILTER = "filter"; private MonitorNotificationRuleFilter filter; @@ -32,16 +36,38 @@ public class MonitorNotificationRuleAttributes { private String name; public static final String JSON_PROPERTY_RECIPIENTS = "recipients"; - private List recipients = new ArrayList<>(); + private List recipients = null; public MonitorNotificationRuleAttributes() {} @JsonCreator public MonitorNotificationRuleAttributes( - @JsonProperty(required = true, value = JSON_PROPERTY_NAME) String name, - @JsonProperty(required = true, value = JSON_PROPERTY_RECIPIENTS) List recipients) { + @JsonProperty(required = true, value = JSON_PROPERTY_NAME) String name) { this.name = name; - this.recipients = recipients; + } + + public MonitorNotificationRuleAttributes conditionalRecipients( + MonitorNotificationRuleConditionalRecipients conditionalRecipients) { + this.conditionalRecipients = conditionalRecipients; + this.unparsed |= conditionalRecipients.unparsed; + return this; + } + + /** + * Use conditional recipients to define different recipients for different situations. + * + * @return conditionalRecipients + */ + @jakarta.annotation.Nullable + @JsonProperty(JSON_PROPERTY_CONDITIONAL_RECIPIENTS) + @JsonInclude(value = JsonInclude.Include.USE_DEFAULTS) + public MonitorNotificationRuleConditionalRecipients getConditionalRecipients() { + return conditionalRecipients; + } + + public void setConditionalRecipients( + MonitorNotificationRuleConditionalRecipients conditionalRecipients) { + this.conditionalRecipients = conditionalRecipients; } public MonitorNotificationRuleAttributes filter(MonitorNotificationRuleFilter filter) { @@ -92,6 +118,9 @@ public MonitorNotificationRuleAttributes recipients(List recipients) { } public MonitorNotificationRuleAttributes addRecipientsItem(String recipientsItem) { + if (this.recipients == null) { + this.recipients = new ArrayList<>(); + } this.recipients.add(recipientsItem); return this; } @@ -102,8 +131,9 @@ public MonitorNotificationRuleAttributes addRecipientsItem(String recipientsItem * * @return recipients */ + @jakarta.annotation.Nullable @JsonProperty(JSON_PROPERTY_RECIPIENTS) - @JsonInclude(value = JsonInclude.Include.ALWAYS) + @JsonInclude(value = JsonInclude.Include.USE_DEFAULTS) public List getRecipients() { return recipients; } @@ -123,20 +153,25 @@ public boolean equals(Object o) { } MonitorNotificationRuleAttributes monitorNotificationRuleAttributes = (MonitorNotificationRuleAttributes) o; - return Objects.equals(this.filter, monitorNotificationRuleAttributes.filter) + return Objects.equals( + this.conditionalRecipients, monitorNotificationRuleAttributes.conditionalRecipients) + && Objects.equals(this.filter, monitorNotificationRuleAttributes.filter) && Objects.equals(this.name, monitorNotificationRuleAttributes.name) && Objects.equals(this.recipients, monitorNotificationRuleAttributes.recipients); } @Override public int hashCode() { - return Objects.hash(filter, name, recipients); + return Objects.hash(conditionalRecipients, filter, name, recipients); } @Override public String toString() { StringBuilder sb = new StringBuilder(); sb.append("class MonitorNotificationRuleAttributes {\n"); + sb.append(" conditionalRecipients: ") + .append(toIndentedString(conditionalRecipients)) + .append("\n"); sb.append(" filter: ").append(toIndentedString(filter)).append("\n"); sb.append(" name: ").append(toIndentedString(name)).append("\n"); sb.append(" recipients: ").append(toIndentedString(recipients)).append("\n"); diff --git a/src/main/java/com/datadog/api/client/v2/model/MonitorNotificationRuleCondition.java b/src/main/java/com/datadog/api/client/v2/model/MonitorNotificationRuleCondition.java new file mode 100644 index 00000000000..7f9612d974c --- /dev/null +++ b/src/main/java/com/datadog/api/client/v2/model/MonitorNotificationRuleCondition.java @@ -0,0 +1,183 @@ +/* + * Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. + * This product includes software developed at Datadog (https://www.datadoghq.com/). + * Copyright 2019-Present Datadog, Inc. + */ + +package com.datadog.api.client.v2.model; + +import com.fasterxml.jackson.annotation.JsonAnyGetter; +import com.fasterxml.jackson.annotation.JsonAnySetter; +import com.fasterxml.jackson.annotation.JsonCreator; +import com.fasterxml.jackson.annotation.JsonIgnore; +import com.fasterxml.jackson.annotation.JsonInclude; +import com.fasterxml.jackson.annotation.JsonProperty; +import com.fasterxml.jackson.annotation.JsonPropertyOrder; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.Objects; + +/** Conditions for conditional_recipients. */ +@JsonPropertyOrder({ + MonitorNotificationRuleCondition.JSON_PROPERTY_RECIPIENTS, + MonitorNotificationRuleCondition.JSON_PROPERTY_SCOPE +}) +@jakarta.annotation.Generated( + value = "https://github.com/DataDog/datadog-api-client-java/blob/master/.generator") +public class MonitorNotificationRuleCondition { + @JsonIgnore public boolean unparsed = false; + public static final String JSON_PROPERTY_RECIPIENTS = "recipients"; + private List recipients = new ArrayList<>(); + + public static final String JSON_PROPERTY_SCOPE = "scope"; + private String scope; + + public MonitorNotificationRuleCondition() {} + + @JsonCreator + public MonitorNotificationRuleCondition( + @JsonProperty(required = true, value = JSON_PROPERTY_RECIPIENTS) List recipients, + @JsonProperty(required = true, value = JSON_PROPERTY_SCOPE) String scope) { + this.recipients = recipients; + this.scope = scope; + } + + public MonitorNotificationRuleCondition recipients(List recipients) { + this.recipients = recipients; + return this; + } + + public MonitorNotificationRuleCondition addRecipientsItem(String recipientsItem) { + this.recipients.add(recipientsItem); + return this; + } + + /** + * A list of recipients to notify. Uses the same format as the monitor message field. + * Must not start with an '@'. + * + * @return recipients + */ + @JsonProperty(JSON_PROPERTY_RECIPIENTS) + @JsonInclude(value = JsonInclude.Include.ALWAYS) + public List getRecipients() { + return recipients; + } + + public void setRecipients(List recipients) { + this.recipients = recipients; + } + + public MonitorNotificationRuleCondition scope(String scope) { + this.scope = scope; + return this; + } + + /** + * The scope to which the monitor applied. + * + * @return scope + */ + @JsonProperty(JSON_PROPERTY_SCOPE) + @JsonInclude(value = JsonInclude.Include.ALWAYS) + public String getScope() { + return scope; + } + + public void setScope(String scope) { + this.scope = scope; + } + + /** + * A container for additional, undeclared properties. This is a holder for any undeclared + * properties as specified with the 'additionalProperties' keyword in the OAS document. + */ + private Map additionalProperties; + + /** + * Set the additional (undeclared) property with the specified name and value. If the property + * does not already exist, create it otherwise replace it. + * + * @param key The arbitrary key to set + * @param value The associated value + * @return MonitorNotificationRuleCondition + */ + @JsonAnySetter + public MonitorNotificationRuleCondition putAdditionalProperty(String key, Object value) { + if (this.additionalProperties == null) { + this.additionalProperties = new HashMap(); + } + this.additionalProperties.put(key, value); + return this; + } + + /** + * Return the additional (undeclared) property. + * + * @return The additional properties + */ + @JsonAnyGetter + public Map getAdditionalProperties() { + return additionalProperties; + } + + /** + * Return the additional (undeclared) property with the specified name. + * + * @param key The arbitrary key to get + * @return The specific additional property for the given key + */ + public Object getAdditionalProperty(String key) { + if (this.additionalProperties == null) { + return null; + } + return this.additionalProperties.get(key); + } + + /** Return true if this MonitorNotificationRuleCondition object is equal to o. */ + @Override + public boolean equals(Object o) { + if (this == o) { + return true; + } + if (o == null || getClass() != o.getClass()) { + return false; + } + MonitorNotificationRuleCondition monitorNotificationRuleCondition = + (MonitorNotificationRuleCondition) o; + return Objects.equals(this.recipients, monitorNotificationRuleCondition.recipients) + && Objects.equals(this.scope, monitorNotificationRuleCondition.scope) + && Objects.equals( + this.additionalProperties, monitorNotificationRuleCondition.additionalProperties); + } + + @Override + public int hashCode() { + return Objects.hash(recipients, scope, additionalProperties); + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder(); + sb.append("class MonitorNotificationRuleCondition {\n"); + sb.append(" recipients: ").append(toIndentedString(recipients)).append("\n"); + sb.append(" scope: ").append(toIndentedString(scope)).append("\n"); + sb.append(" additionalProperties: ") + .append(toIndentedString(additionalProperties)) + .append("\n"); + sb.append('}'); + return sb.toString(); + } + + /** + * Convert the given object to string with each line indented by 4 spaces (except the first line). + */ + private String toIndentedString(Object o) { + if (o == null) { + return "null"; + } + return o.toString().replace("\n", "\n "); + } +} diff --git a/src/main/java/com/datadog/api/client/v2/model/MonitorNotificationRuleConditionalRecipients.java b/src/main/java/com/datadog/api/client/v2/model/MonitorNotificationRuleConditionalRecipients.java new file mode 100644 index 00000000000..827abb94604 --- /dev/null +++ b/src/main/java/com/datadog/api/client/v2/model/MonitorNotificationRuleConditionalRecipients.java @@ -0,0 +1,203 @@ +/* + * Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. + * This product includes software developed at Datadog (https://www.datadoghq.com/). + * Copyright 2019-Present Datadog, Inc. + */ + +package com.datadog.api.client.v2.model; + +import com.fasterxml.jackson.annotation.JsonAnyGetter; +import com.fasterxml.jackson.annotation.JsonAnySetter; +import com.fasterxml.jackson.annotation.JsonCreator; +import com.fasterxml.jackson.annotation.JsonIgnore; +import com.fasterxml.jackson.annotation.JsonInclude; +import com.fasterxml.jackson.annotation.JsonProperty; +import com.fasterxml.jackson.annotation.JsonPropertyOrder; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.Objects; + +/** Use conditional recipients to define different recipients for different situations. */ +@JsonPropertyOrder({ + MonitorNotificationRuleConditionalRecipients.JSON_PROPERTY_CONDITIONS, + MonitorNotificationRuleConditionalRecipients.JSON_PROPERTY_FALLBACK_RECIPIENTS +}) +@jakarta.annotation.Generated( + value = "https://github.com/DataDog/datadog-api-client-java/blob/master/.generator") +public class MonitorNotificationRuleConditionalRecipients { + @JsonIgnore public boolean unparsed = false; + public static final String JSON_PROPERTY_CONDITIONS = "conditions"; + private List conditions = new ArrayList<>(); + + public static final String JSON_PROPERTY_FALLBACK_RECIPIENTS = "fallback_recipients"; + private List fallbackRecipients = null; + + public MonitorNotificationRuleConditionalRecipients() {} + + @JsonCreator + public MonitorNotificationRuleConditionalRecipients( + @JsonProperty(required = true, value = JSON_PROPERTY_CONDITIONS) + List conditions) { + this.conditions = conditions; + } + + public MonitorNotificationRuleConditionalRecipients conditions( + List conditions) { + this.conditions = conditions; + for (MonitorNotificationRuleCondition item : conditions) { + this.unparsed |= item.unparsed; + } + return this; + } + + public MonitorNotificationRuleConditionalRecipients addConditionsItem( + MonitorNotificationRuleCondition conditionsItem) { + this.conditions.add(conditionsItem); + this.unparsed |= conditionsItem.unparsed; + return this; + } + + /** + * Conditions of the notification rule. + * + * @return conditions + */ + @JsonProperty(JSON_PROPERTY_CONDITIONS) + @JsonInclude(value = JsonInclude.Include.ALWAYS) + public List getConditions() { + return conditions; + } + + public void setConditions(List conditions) { + this.conditions = conditions; + } + + public MonitorNotificationRuleConditionalRecipients fallbackRecipients( + List fallbackRecipients) { + this.fallbackRecipients = fallbackRecipients; + return this; + } + + public MonitorNotificationRuleConditionalRecipients addFallbackRecipientsItem( + String fallbackRecipientsItem) { + if (this.fallbackRecipients == null) { + this.fallbackRecipients = new ArrayList<>(); + } + this.fallbackRecipients.add(fallbackRecipientsItem); + return this; + } + + /** + * A list of recipients to notify. Uses the same format as the monitor message field. + * Must not start with an '@'. + * + * @return fallbackRecipients + */ + @jakarta.annotation.Nullable + @JsonProperty(JSON_PROPERTY_FALLBACK_RECIPIENTS) + @JsonInclude(value = JsonInclude.Include.USE_DEFAULTS) + public List getFallbackRecipients() { + return fallbackRecipients; + } + + public void setFallbackRecipients(List fallbackRecipients) { + this.fallbackRecipients = fallbackRecipients; + } + + /** + * A container for additional, undeclared properties. This is a holder for any undeclared + * properties as specified with the 'additionalProperties' keyword in the OAS document. + */ + private Map additionalProperties; + + /** + * Set the additional (undeclared) property with the specified name and value. If the property + * does not already exist, create it otherwise replace it. + * + * @param key The arbitrary key to set + * @param value The associated value + * @return MonitorNotificationRuleConditionalRecipients + */ + @JsonAnySetter + public MonitorNotificationRuleConditionalRecipients putAdditionalProperty( + String key, Object value) { + if (this.additionalProperties == null) { + this.additionalProperties = new HashMap(); + } + this.additionalProperties.put(key, value); + return this; + } + + /** + * Return the additional (undeclared) property. + * + * @return The additional properties + */ + @JsonAnyGetter + public Map getAdditionalProperties() { + return additionalProperties; + } + + /** + * Return the additional (undeclared) property with the specified name. + * + * @param key The arbitrary key to get + * @return The specific additional property for the given key + */ + public Object getAdditionalProperty(String key) { + if (this.additionalProperties == null) { + return null; + } + return this.additionalProperties.get(key); + } + + /** Return true if this MonitorNotificationRuleConditionalRecipients object is equal to o. */ + @Override + public boolean equals(Object o) { + if (this == o) { + return true; + } + if (o == null || getClass() != o.getClass()) { + return false; + } + MonitorNotificationRuleConditionalRecipients monitorNotificationRuleConditionalRecipients = + (MonitorNotificationRuleConditionalRecipients) o; + return Objects.equals(this.conditions, monitorNotificationRuleConditionalRecipients.conditions) + && Objects.equals( + this.fallbackRecipients, + monitorNotificationRuleConditionalRecipients.fallbackRecipients) + && Objects.equals( + this.additionalProperties, + monitorNotificationRuleConditionalRecipients.additionalProperties); + } + + @Override + public int hashCode() { + return Objects.hash(conditions, fallbackRecipients, additionalProperties); + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder(); + sb.append("class MonitorNotificationRuleConditionalRecipients {\n"); + sb.append(" conditions: ").append(toIndentedString(conditions)).append("\n"); + sb.append(" fallbackRecipients: ").append(toIndentedString(fallbackRecipients)).append("\n"); + sb.append(" additionalProperties: ") + .append(toIndentedString(additionalProperties)) + .append("\n"); + sb.append('}'); + return sb.toString(); + } + + /** + * Convert the given object to string with each line indented by 4 spaces (except the first line). + */ + private String toIndentedString(Object o) { + if (o == null) { + return "null"; + } + return o.toString().replace("\n", "\n "); + } +} diff --git a/src/main/java/com/datadog/api/client/v2/model/MonitorNotificationRuleResponseAttributes.java b/src/main/java/com/datadog/api/client/v2/model/MonitorNotificationRuleResponseAttributes.java index 6bd69631ec2..52a51120da3 100644 --- a/src/main/java/com/datadog/api/client/v2/model/MonitorNotificationRuleResponseAttributes.java +++ b/src/main/java/com/datadog/api/client/v2/model/MonitorNotificationRuleResponseAttributes.java @@ -21,6 +21,7 @@ /** Attributes of the monitor notification rule. */ @JsonPropertyOrder({ + MonitorNotificationRuleResponseAttributes.JSON_PROPERTY_CONDITIONAL_RECIPIENTS, MonitorNotificationRuleResponseAttributes.JSON_PROPERTY_CREATED, MonitorNotificationRuleResponseAttributes.JSON_PROPERTY_FILTER, MonitorNotificationRuleResponseAttributes.JSON_PROPERTY_MODIFIED, @@ -31,6 +32,9 @@ value = "https://github.com/DataDog/datadog-api-client-java/blob/master/.generator") public class MonitorNotificationRuleResponseAttributes { @JsonIgnore public boolean unparsed = false; + public static final String JSON_PROPERTY_CONDITIONAL_RECIPIENTS = "conditional_recipients"; + private MonitorNotificationRuleConditionalRecipients conditionalRecipients; + public static final String JSON_PROPERTY_CREATED = "created"; private OffsetDateTime created; @@ -46,6 +50,30 @@ public class MonitorNotificationRuleResponseAttributes { public static final String JSON_PROPERTY_RECIPIENTS = "recipients"; private List recipients = null; + public MonitorNotificationRuleResponseAttributes conditionalRecipients( + MonitorNotificationRuleConditionalRecipients conditionalRecipients) { + this.conditionalRecipients = conditionalRecipients; + this.unparsed |= conditionalRecipients.unparsed; + return this; + } + + /** + * Use conditional recipients to define different recipients for different situations. + * + * @return conditionalRecipients + */ + @jakarta.annotation.Nullable + @JsonProperty(JSON_PROPERTY_CONDITIONAL_RECIPIENTS) + @JsonInclude(value = JsonInclude.Include.USE_DEFAULTS) + public MonitorNotificationRuleConditionalRecipients getConditionalRecipients() { + return conditionalRecipients; + } + + public void setConditionalRecipients( + MonitorNotificationRuleConditionalRecipients conditionalRecipients) { + this.conditionalRecipients = conditionalRecipients; + } + public MonitorNotificationRuleResponseAttributes created(OffsetDateTime created) { this.created = created; return this; @@ -218,7 +246,10 @@ public boolean equals(Object o) { } MonitorNotificationRuleResponseAttributes monitorNotificationRuleResponseAttributes = (MonitorNotificationRuleResponseAttributes) o; - return Objects.equals(this.created, monitorNotificationRuleResponseAttributes.created) + return Objects.equals( + this.conditionalRecipients, + monitorNotificationRuleResponseAttributes.conditionalRecipients) + && Objects.equals(this.created, monitorNotificationRuleResponseAttributes.created) && Objects.equals(this.filter, monitorNotificationRuleResponseAttributes.filter) && Objects.equals(this.modified, monitorNotificationRuleResponseAttributes.modified) && Objects.equals(this.name, monitorNotificationRuleResponseAttributes.name) @@ -230,13 +261,17 @@ public boolean equals(Object o) { @Override public int hashCode() { - return Objects.hash(created, filter, modified, name, recipients, additionalProperties); + return Objects.hash( + conditionalRecipients, created, filter, modified, name, recipients, additionalProperties); } @Override public String toString() { StringBuilder sb = new StringBuilder(); sb.append("class MonitorNotificationRuleResponseAttributes {\n"); + sb.append(" conditionalRecipients: ") + .append(toIndentedString(conditionalRecipients)) + .append("\n"); sb.append(" created: ").append(toIndentedString(created)).append("\n"); sb.append(" filter: ").append(toIndentedString(filter)).append("\n"); sb.append(" modified: ").append(toIndentedString(modified)).append("\n"); diff --git a/src/test/resources/cassettes/features/v2/Create_a_monitor_notification_rule_with_conditional_recipients_returns_OK_response.freeze b/src/test/resources/cassettes/features/v2/Create_a_monitor_notification_rule_with_conditional_recipients_returns_OK_response.freeze new file mode 100644 index 00000000000..da684d32ebf --- /dev/null +++ b/src/test/resources/cassettes/features/v2/Create_a_monitor_notification_rule_with_conditional_recipients_returns_OK_response.freeze @@ -0,0 +1 @@ +2025-09-26T01:50:59.027Z \ No newline at end of file diff --git a/src/test/resources/cassettes/features/v2/Create_a_monitor_notification_rule_with_conditional_recipients_returns_OK_response.json b/src/test/resources/cassettes/features/v2/Create_a_monitor_notification_rule_with_conditional_recipients_returns_OK_response.json new file mode 100644 index 00000000000..dac098260ef --- /dev/null +++ b/src/test/resources/cassettes/features/v2/Create_a_monitor_notification_rule_with_conditional_recipients_returns_OK_response.json @@ -0,0 +1,57 @@ +[ + { + "httpRequest": { + "body": { + "type": "JSON", + "json": "{\"data\":{\"attributes\":{\"conditional_recipients\":{\"conditions\":[{\"recipients\":[\"slack-test-channel\",\"jira-test\"],\"scope\":\"transition_type:is_alert\"}]},\"filter\":{\"tags\":[\"test:test-create_a_monitor_notification_rule_with_conditional_recipients_returns_ok_response-1758851459\"]},\"name\":\"test rule\"},\"type\":\"monitor-notification-rule\"}}" + }, + "headers": {}, + "method": "POST", + "path": "/api/v2/monitor/notification_rule", + "keepAlive": false, + "secure": true + }, + "httpResponse": { + "body": "{\"data\":{\"type\":\"monitor-notification-rule\",\"attributes\":{\"name\":\"test rule\",\"filter\":{\"tags\":[\"test:test-create_a_monitor_notification_rule_with_conditional_recipients_returns_ok_response-1758851459\"]},\"created_at\":\"2025-09-26T01:51:00.132009+00:00\",\"conditional_recipients\":{\"conditions\":[{\"recipients\":[\"slack-test-channel\",\"jira-test\"],\"scope\":\"transition_type:is_alert\"}]},\"modified_at\":\"1970-01-01T00:00:00+00:00\"},\"id\":\"707b82d7-6898-4b20-a577-64f76881fe89\",\"relationships\":{\"created_by\":{\"data\":{\"type\":\"users\",\"id\":\"9919ec9b-ebc7-49ee-8dc8-03626e717cca\"}}}},\"included\":[{\"type\":\"users\",\"id\":\"9919ec9b-ebc7-49ee-8dc8-03626e717cca\",\"attributes\":{\"name\":\"CI Account\",\"handle\":\"9919ec9b-ebc7-49ee-8dc8-03626e717cca\",\"created_at\":\"2020-12-29T22:58:44.733921+00:00\",\"modified_at\":\"2021-04-27T13:54:01.547888+00:00\",\"email\":\"team-intg-tools-libs-spam@datadoghq.com\",\"icon\":\"https://secure.gravatar.com/avatar/b7c189b5b4c2c429d7c1e0bc3749330e?s=48&d=retro\",\"title\":null,\"verified\":true,\"service_account\":true,\"disabled\":false,\"allowed_login_methods\":[],\"status\":\"Active\"}}]}\n", + "headers": { + "Content-Type": [ + "application/json" + ] + }, + "statusCode": 200, + "reasonPhrase": "OK" + }, + "times": { + "remainingTimes": 1 + }, + "timeToLive": { + "unlimited": true + }, + "id": "5a406144-9188-48ee-794d-f49bba5436b3" + }, + { + "httpRequest": { + "headers": {}, + "method": "DELETE", + "path": "/api/v2/monitor/notification_rule/707b82d7-6898-4b20-a577-64f76881fe89", + "keepAlive": false, + "secure": true + }, + "httpResponse": { + "headers": { + "Content-Type": [ + "text/html; charset=utf-8" + ] + }, + "statusCode": 204, + "reasonPhrase": "No Content" + }, + "times": { + "remainingTimes": 1 + }, + "timeToLive": { + "unlimited": true + }, + "id": "c37cabe3-5cdb-94a5-aeb8-0ee7e61c7102" + } +] \ No newline at end of file diff --git a/src/test/resources/cassettes/features/v2/Update_a_monitor_notification_rule_with_conditional_recipients_returns_OK_response.freeze b/src/test/resources/cassettes/features/v2/Update_a_monitor_notification_rule_with_conditional_recipients_returns_OK_response.freeze new file mode 100644 index 00000000000..8543967b2b9 --- /dev/null +++ b/src/test/resources/cassettes/features/v2/Update_a_monitor_notification_rule_with_conditional_recipients_returns_OK_response.freeze @@ -0,0 +1 @@ +2025-09-26T01:51:00.504Z \ No newline at end of file diff --git a/src/test/resources/cassettes/features/v2/Update_a_monitor_notification_rule_with_conditional_recipients_returns_OK_response.json b/src/test/resources/cassettes/features/v2/Update_a_monitor_notification_rule_with_conditional_recipients_returns_OK_response.json new file mode 100644 index 00000000000..d0f2b207774 --- /dev/null +++ b/src/test/resources/cassettes/features/v2/Update_a_monitor_notification_rule_with_conditional_recipients_returns_OK_response.json @@ -0,0 +1,87 @@ +[ + { + "httpRequest": { + "body": { + "type": "JSON", + "json": "{\"data\":{\"attributes\":{\"filter\":{\"tags\":[\"app:test-update_a_monitor_notification_rule_with_conditional_recipients_returns_ok_response-1758851460\"]},\"name\":\"test rule\",\"recipients\":[\"slack-monitor-app\"]},\"type\":\"monitor-notification-rule\"}}" + }, + "headers": {}, + "method": "POST", + "path": "/api/v2/monitor/notification_rule", + "keepAlive": false, + "secure": true + }, + "httpResponse": { + "body": "{\"data\":{\"type\":\"monitor-notification-rule\",\"attributes\":{\"filter\":{\"tags\":[\"app:test-update_a_monitor_notification_rule_with_conditional_recipients_returns_ok_response-1758851460\"]},\"created_at\":\"2025-09-26T01:51:00.665373+00:00\",\"name\":\"test rule\",\"recipients\":[\"slack-monitor-app\"],\"modified_at\":\"1970-01-01T00:00:00+00:00\"},\"id\":\"954d2f74-ec41-4f7b-9f63-7146075f3537\",\"relationships\":{\"created_by\":{\"data\":{\"type\":\"users\",\"id\":\"9919ec9b-ebc7-49ee-8dc8-03626e717cca\"}}}},\"included\":[{\"type\":\"users\",\"id\":\"9919ec9b-ebc7-49ee-8dc8-03626e717cca\",\"attributes\":{\"name\":\"CI Account\",\"handle\":\"9919ec9b-ebc7-49ee-8dc8-03626e717cca\",\"created_at\":\"2020-12-29T22:58:44.733921+00:00\",\"modified_at\":\"2021-04-27T13:54:01.547888+00:00\",\"email\":\"team-intg-tools-libs-spam@datadoghq.com\",\"icon\":\"https://secure.gravatar.com/avatar/b7c189b5b4c2c429d7c1e0bc3749330e?s=48&d=retro\",\"title\":null,\"verified\":true,\"service_account\":true,\"disabled\":false,\"allowed_login_methods\":[],\"status\":\"Active\"}}]}\n", + "headers": { + "Content-Type": [ + "application/json" + ] + }, + "statusCode": 200, + "reasonPhrase": "OK" + }, + "times": { + "remainingTimes": 1 + }, + "timeToLive": { + "unlimited": true + }, + "id": "f74113be-194d-9091-8399-ff38a8c798db" + }, + { + "httpRequest": { + "body": { + "type": "JSON", + "json": "{\"data\":{\"attributes\":{\"conditional_recipients\":{\"conditions\":[{\"recipients\":[\"slack-test-channel\",\"jira-test\"],\"scope\":\"transition_type:is_alert\"}]},\"filter\":{\"tags\":[\"test:test-update_a_monitor_notification_rule_with_conditional_recipients_returns_ok_response-1758851460\",\"host:abc\"]},\"name\":\"updated rule\"},\"id\":\"954d2f74-ec41-4f7b-9f63-7146075f3537\",\"type\":\"monitor-notification-rule\"}}" + }, + "headers": {}, + "method": "PATCH", + "path": "/api/v2/monitor/notification_rule/954d2f74-ec41-4f7b-9f63-7146075f3537", + "keepAlive": false, + "secure": true + }, + "httpResponse": { + "body": "{\"data\":{\"type\":\"monitor-notification-rule\",\"id\":\"954d2f74-ec41-4f7b-9f63-7146075f3537\",\"attributes\":{\"filter\":{\"tags\":[\"test:test-update_a_monitor_notification_rule_with_conditional_recipients_returns_ok_response-1758851460\",\"host:abc\"]},\"modified_at\":\"2025-09-26T01:51:00.876883+00:00\",\"conditional_recipients\":{\"conditions\":[{\"scope\":\"transition_type:is_alert\",\"recipients\":[\"slack-test-channel\",\"jira-test\"]}]},\"name\":\"updated rule\",\"created_at\":\"2025-09-26T01:51:00.665373+00:00\"},\"relationships\":{\"created_by\":{\"data\":{\"type\":\"users\",\"id\":\"9919ec9b-ebc7-49ee-8dc8-03626e717cca\"}}}},\"included\":[{\"type\":\"users\",\"id\":\"9919ec9b-ebc7-49ee-8dc8-03626e717cca\",\"attributes\":{\"name\":\"CI Account\",\"handle\":\"9919ec9b-ebc7-49ee-8dc8-03626e717cca\",\"created_at\":\"2020-12-29T22:58:44.733921+00:00\",\"modified_at\":\"2021-04-27T13:54:01.547888+00:00\",\"email\":\"team-intg-tools-libs-spam@datadoghq.com\",\"icon\":\"https://secure.gravatar.com/avatar/b7c189b5b4c2c429d7c1e0bc3749330e?s=48&d=retro\",\"title\":null,\"verified\":true,\"service_account\":true,\"disabled\":false,\"allowed_login_methods\":[],\"status\":\"Active\"}}]}\n", + "headers": { + "Content-Type": [ + "application/json" + ] + }, + "statusCode": 200, + "reasonPhrase": "OK" + }, + "times": { + "remainingTimes": 1 + }, + "timeToLive": { + "unlimited": true + }, + "id": "56466a6f-999a-45f8-ef1d-7f802ab0c507" + }, + { + "httpRequest": { + "headers": {}, + "method": "DELETE", + "path": "/api/v2/monitor/notification_rule/954d2f74-ec41-4f7b-9f63-7146075f3537", + "keepAlive": false, + "secure": true + }, + "httpResponse": { + "headers": { + "Content-Type": [ + "text/html; charset=utf-8" + ] + }, + "statusCode": 204, + "reasonPhrase": "No Content" + }, + "times": { + "remainingTimes": 1 + }, + "timeToLive": { + "unlimited": true + }, + "id": "47601895-ff82-dd9a-14b5-2f5a0ddc63bd" + } +] \ No newline at end of file diff --git a/src/test/resources/com/datadog/api/client/v2/api/monitors.feature b/src/test/resources/com/datadog/api/client/v2/api/monitors.feature index d49f00dd048..3fd3138f9f5 100644 --- a/src/test/resources/com/datadog/api/client/v2/api/monitors.feature +++ b/src/test/resources/com/datadog/api/client/v2/api/monitors.feature @@ -44,6 +44,14 @@ Feature: Monitors Then the response status is 200 OK And the response "data.attributes.name" is equal to "test rule" + @team:DataDog/monitor-app + Scenario: Create a monitor notification rule with conditional recipients returns "OK" response + Given new "CreateMonitorNotificationRule" request + And body with value {"data": {"attributes": {"filter": {"tags": ["test:{{ unique_lower }}"]}, "name": "test rule", "conditional_recipients": {"conditions": [{"scope": "transition_type:is_alert", "recipients": ["slack-test-channel", "jira-test"]}]}}, "type": "monitor-notification-rule"}} + When the request is sent + Then the response status is 200 OK + And the response "data.attributes.name" is equal to "test rule" + @skip-validation @team:DataDog/monitor-app Scenario: Create a monitor user template returns "Bad Request" response Given new "CreateMonitorUserTemplate" request @@ -255,6 +263,16 @@ Feature: Monitors Then the response status is 200 OK And the response "data.attributes.name" is equal to "updated rule" + @team:DataDog/monitor-app + Scenario: Update a monitor notification rule with conditional_recipients returns "OK" response + Given there is a valid "monitor_notification_rule" in the system + And new "UpdateMonitorNotificationRule" request + And request contains "rule_id" parameter from "monitor_notification_rule.data.id" + And body with value {"data": {"attributes": {"filter": {"tags": ["test:{{ unique_lower }}", "host:abc"]}, "name": "updated rule", "conditional_recipients": {"conditions": [{"scope": "transition_type:is_alert", "recipients": ["slack-test-channel", "jira-test"]}]}}, "id": "{{ monitor_notification_rule.data.id }}", "type": "monitor-notification-rule"}} + When the request is sent + Then the response status is 200 OK + And the response "data.attributes.name" is equal to "updated rule" + @skip-validation @team:DataDog/monitor-app Scenario: Update a monitor user template to a new version returns "Bad Request" response Given there is a valid "monitor_user_template" in the system