Add public API for security findings automation rules

examples/v2/security-monitoring/CreateSecurityFindingsAutomationDueDateRule.java

@@ -0,0 +1,63 @@
+// Create a due date rule returns "Successfully created the due date rule" response
+
+import com.datadog.api.client.ApiClient;
+import com.datadog.api.client.ApiException;
+import com.datadog.api.client.v2.api.SecurityMonitoringApi;
+import com.datadog.api.client.v2.model.AutomationRuleScope;
+import com.datadog.api.client.v2.model.DueDateFrom;
+import com.datadog.api.client.v2.model.DueDatePerSeverityItem;
+import com.datadog.api.client.v2.model.DueDateRuleAction;
+import com.datadog.api.client.v2.model.DueDateRuleAttributesCreate;
+import com.datadog.api.client.v2.model.DueDateRuleCreateRequest;
+import com.datadog.api.client.v2.model.DueDateRuleDataCreate;
+import com.datadog.api.client.v2.model.DueDateRuleResponse;
+import com.datadog.api.client.v2.model.DueDateRuleType;
+import com.datadog.api.client.v2.model.DueDateSeverity;
+import com.datadog.api.client.v2.model.SecurityFindingType;
+import java.util.Collections;
+
+public class Example {
+  public static void main(String[] args) {
+    ApiClient defaultClient = ApiClient.getDefaultApiClient();
+    defaultClient.setUnstableOperationEnabled(
+        "v2.createSecurityFindingsAutomationDueDateRule", true);
+    SecurityMonitoringApi apiInstance = new SecurityMonitoringApi(defaultClient);
+
+    DueDateRuleCreateRequest body =
+        new DueDateRuleCreateRequest()
+            .data(
+                new DueDateRuleDataCreate()
+                    .attributes(
+                        new DueDateRuleAttributesCreate()
+                            .action(
+                                new DueDateRuleAction()
+                                    .dueDaysPerSeverity(
+                                        Collections.singletonList(
+                                            new DueDatePerSeverityItem()
+                                                .dueInDays(7L)
+                                                .severity(DueDateSeverity.CRITICAL)))
+                                    .dueFrom(DueDateFrom.FIRST_SEEN))
+                            .enabled(true)
+                            .name("Example-Security-Monitoring")
+                            .rule(
+                                new AutomationRuleScope()
+                                    .findingTypes(
+                                        Collections.singletonList(
+                                            SecurityFindingType.MISCONFIGURATION))
+                                    .query("env:staging")))
+                    .type(DueDateRuleType.DUE_DATE_RULES));
+
+    try {
+      DueDateRuleResponse result = apiInstance.createSecurityFindingsAutomationDueDateRule(body);
+      System.out.println(result);
+    } catch (ApiException e) {
+      System.err.println(
+          "Exception when calling"
+              + " SecurityMonitoringApi#createSecurityFindingsAutomationDueDateRule");
+      System.err.println("Status code: " + e.getCode());
+      System.err.println("Reason: " + e.getResponseBody());
+      System.err.println("Response headers: " + e.getResponseHeaders());
+      e.printStackTrace();
+    }
+  }
+}

examples/v2/security-monitoring/CreateSecurityFindingsAutomationMuteRule.java

@@ -0,0 +1,52 @@
+// Create a mute rule returns "Successfully created the mute rule" response
+
+import com.datadog.api.client.ApiClient;
+import com.datadog.api.client.ApiException;
+import com.datadog.api.client.v2.api.SecurityMonitoringApi;
+import com.datadog.api.client.v2.model.AutomationRuleScope;
+import com.datadog.api.client.v2.model.MuteReason;
+import com.datadog.api.client.v2.model.MuteRuleAction;
+import com.datadog.api.client.v2.model.MuteRuleAttributesCreate;
+import com.datadog.api.client.v2.model.MuteRuleCreateRequest;
+import com.datadog.api.client.v2.model.MuteRuleDataCreate;
+import com.datadog.api.client.v2.model.MuteRuleResponse;
+import com.datadog.api.client.v2.model.MuteRuleType;
+import com.datadog.api.client.v2.model.SecurityFindingType;
+import java.util.Collections;
+
+public class Example {
+  public static void main(String[] args) {
+    ApiClient defaultClient = ApiClient.getDefaultApiClient();
+    defaultClient.setUnstableOperationEnabled("v2.createSecurityFindingsAutomationMuteRule", true);
+    SecurityMonitoringApi apiInstance = new SecurityMonitoringApi(defaultClient);
+
+    MuteRuleCreateRequest body =
+        new MuteRuleCreateRequest()
+            .data(
+                new MuteRuleDataCreate()
+                    .attributes(
+                        new MuteRuleAttributesCreate()
+                            .action(new MuteRuleAction().reason(MuteReason.RISK_ACCEPTED))
+                            .enabled(true)
+                            .name("Example-Security-Monitoring")
+                            .rule(
+                                new AutomationRuleScope()
+                                    .findingTypes(
+                                        Collections.singletonList(
+                                            SecurityFindingType.MISCONFIGURATION))
+                                    .query("env:staging")))
+                    .type(MuteRuleType.MUTE_RULES));
+
+    try {
+      MuteRuleResponse result = apiInstance.createSecurityFindingsAutomationMuteRule(body);
+      System.out.println(result);
+    } catch (ApiException e) {
+      System.err.println(
+          "Exception when calling SecurityMonitoringApi#createSecurityFindingsAutomationMuteRule");
+      System.err.println("Status code: " + e.getCode());
+      System.err.println("Reason: " + e.getResponseBody());
+      System.err.println("Response headers: " + e.getResponseHeaders());
+      e.printStackTrace();
+    }
+  }
+}

examples/v2/security-monitoring/CreateSecurityFindingsAutomationTicketCreationRule.java

@@ -0,0 +1,61 @@
+// Create a ticket creation rule returns "Successfully created the ticket creation rule" response
+
+import com.datadog.api.client.ApiClient;
+import com.datadog.api.client.ApiException;
+import com.datadog.api.client.v2.api.SecurityMonitoringApi;
+import com.datadog.api.client.v2.model.AutomationRuleScope;
+import com.datadog.api.client.v2.model.SecurityFindingType;
+import com.datadog.api.client.v2.model.TicketCreationRuleAction;
+import com.datadog.api.client.v2.model.TicketCreationRuleAttributesCreate;
+import com.datadog.api.client.v2.model.TicketCreationRuleCreateRequest;
+import com.datadog.api.client.v2.model.TicketCreationRuleDataCreate;
+import com.datadog.api.client.v2.model.TicketCreationRuleResponse;
+import com.datadog.api.client.v2.model.TicketCreationRuleType;
+import com.datadog.api.client.v2.model.TicketCreationTarget;
+import java.util.Collections;
+import java.util.UUID;
+
+public class Example {
+  public static void main(String[] args) {
+    ApiClient defaultClient = ApiClient.getDefaultApiClient();
+    defaultClient.setUnstableOperationEnabled(
+        "v2.createSecurityFindingsAutomationTicketCreationRule", true);
+    SecurityMonitoringApi apiInstance = new SecurityMonitoringApi(defaultClient);
+
+    TicketCreationRuleCreateRequest body =
+        new TicketCreationRuleCreateRequest()
+            .data(
+                new TicketCreationRuleDataCreate()
+                    .attributes(
+                        new TicketCreationRuleAttributesCreate()
+                            .action(
+                                new TicketCreationRuleAction()
+                                    .maxTicketsPerDay(10L)
+                                    .projectId(
+                                        UUID.fromString("11111111-1111-1111-1111-111111111111"))
+                                    .target(TicketCreationTarget.JIRA))
+                            .enabled(true)
+                            .name("Example-Security-Monitoring")
+                            .rule(
+                                new AutomationRuleScope()
+                                    .findingTypes(
+                                        Collections.singletonList(
+                                            SecurityFindingType.MISCONFIGURATION))
+                                    .query("env:staging")))
+                    .type(TicketCreationRuleType.TICKET_CREATION_RULES));
+
+    try {
+      TicketCreationRuleResponse result =
+          apiInstance.createSecurityFindingsAutomationTicketCreationRule(body);
+      System.out.println(result);
+    } catch (ApiException e) {
+      System.err.println(
+          "Exception when calling"
+              + " SecurityMonitoringApi#createSecurityFindingsAutomationTicketCreationRule");
+      System.err.println("Status code: " + e.getCode());
+      System.err.println("Reason: " + e.getResponseBody());
+      System.err.println("Response headers: " + e.getResponseHeaders());
+      e.printStackTrace();
+    }
+  }
+}

examples/v2/security-monitoring/DeleteSecurityFindingsAutomationDueDateRule.java

@@ -0,0 +1,35 @@
+// Delete a due date rule returns "Rule successfully deleted." response
+
+import com.datadog.api.client.ApiClient;
+import com.datadog.api.client.ApiException;
+import com.datadog.api.client.v2.api.SecurityMonitoringApi;
+import java.util.UUID;
+
+public class Example {
+  public static void main(String[] args) {
+    ApiClient defaultClient = ApiClient.getDefaultApiClient();
+    defaultClient.setUnstableOperationEnabled(
+        "v2.deleteSecurityFindingsAutomationDueDateRule", true);
+    SecurityMonitoringApi apiInstance = new SecurityMonitoringApi(defaultClient);
+
+    // there is a valid "valid_due_date_rule" in the system
+    UUID VALID_DUE_DATE_RULE_DATA_ID = null;
+    try {
+      VALID_DUE_DATE_RULE_DATA_ID = UUID.fromString(System.getenv("VALID_DUE_DATE_RULE_DATA_ID"));
+    } catch (IllegalArgumentException e) {
+      System.err.println("Error parsing UUID: " + e.getMessage());
+    }
+
+    try {
+      apiInstance.deleteSecurityFindingsAutomationDueDateRule(VALID_DUE_DATE_RULE_DATA_ID);
+    } catch (ApiException e) {
+      System.err.println(
+          "Exception when calling"
+              + " SecurityMonitoringApi#deleteSecurityFindingsAutomationDueDateRule");
+      System.err.println("Status code: " + e.getCode());
+      System.err.println("Reason: " + e.getResponseBody());
+      System.err.println("Response headers: " + e.getResponseHeaders());
+      e.printStackTrace();
+    }
+  }
+}

examples/v2/security-monitoring/DeleteSecurityFindingsAutomationMuteRule.java

@@ -0,0 +1,33 @@
+// Delete a mute rule returns "Rule successfully deleted." response
+
+import com.datadog.api.client.ApiClient;
+import com.datadog.api.client.ApiException;
+import com.datadog.api.client.v2.api.SecurityMonitoringApi;
+import java.util.UUID;
+
+public class Example {
+  public static void main(String[] args) {
+    ApiClient defaultClient = ApiClient.getDefaultApiClient();
+    defaultClient.setUnstableOperationEnabled("v2.deleteSecurityFindingsAutomationMuteRule", true);
+    SecurityMonitoringApi apiInstance = new SecurityMonitoringApi(defaultClient);
+
+    // there is a valid "valid_mute_rule" in the system
+    UUID VALID_MUTE_RULE_DATA_ID = null;
+    try {
+      VALID_MUTE_RULE_DATA_ID = UUID.fromString(System.getenv("VALID_MUTE_RULE_DATA_ID"));
+    } catch (IllegalArgumentException e) {
+      System.err.println("Error parsing UUID: " + e.getMessage());
+    }
+
+    try {
+      apiInstance.deleteSecurityFindingsAutomationMuteRule(VALID_MUTE_RULE_DATA_ID);
+    } catch (ApiException e) {
+      System.err.println(
+          "Exception when calling SecurityMonitoringApi#deleteSecurityFindingsAutomationMuteRule");
+      System.err.println("Status code: " + e.getCode());
+      System.err.println("Reason: " + e.getResponseBody());
+      System.err.println("Response headers: " + e.getResponseHeaders());
+      e.printStackTrace();
+    }
+  }
+}

examples/v2/security-monitoring/DeleteSecurityFindingsAutomationTicketCreationRule.java

@@ -0,0 +1,37 @@
+// Delete a ticket creation rule returns "Rule successfully deleted." response
+
+import com.datadog.api.client.ApiClient;
+import com.datadog.api.client.ApiException;
+import com.datadog.api.client.v2.api.SecurityMonitoringApi;
+import java.util.UUID;
+
+public class Example {
+  public static void main(String[] args) {
+    ApiClient defaultClient = ApiClient.getDefaultApiClient();
+    defaultClient.setUnstableOperationEnabled(
+        "v2.deleteSecurityFindingsAutomationTicketCreationRule", true);
+    SecurityMonitoringApi apiInstance = new SecurityMonitoringApi(defaultClient);
+
+    // there is a valid "valid_ticket_creation_rule" in the system
+    UUID VALID_TICKET_CREATION_RULE_DATA_ID = null;
+    try {
+      VALID_TICKET_CREATION_RULE_DATA_ID =
+          UUID.fromString(System.getenv("VALID_TICKET_CREATION_RULE_DATA_ID"));
+    } catch (IllegalArgumentException e) {
+      System.err.println("Error parsing UUID: " + e.getMessage());
+    }
+
+    try {
+      apiInstance.deleteSecurityFindingsAutomationTicketCreationRule(
+          VALID_TICKET_CREATION_RULE_DATA_ID);
+    } catch (ApiException e) {
+      System.err.println(
+          "Exception when calling"
+              + " SecurityMonitoringApi#deleteSecurityFindingsAutomationTicketCreationRule");
+      System.err.println("Status code: " + e.getCode());
+      System.err.println("Reason: " + e.getResponseBody());
+      System.err.println("Response headers: " + e.getResponseHeaders());
+      e.printStackTrace();
+    }
+  }
+}

examples/v2/security-monitoring/GetSecurityFindingsAutomationDueDateRule.java

@@ -0,0 +1,36 @@
+// Get a due date rule returns "Successfully retrieved the due date rule" response
+
+import com.datadog.api.client.ApiClient;
+import com.datadog.api.client.ApiException;
+import com.datadog.api.client.v2.api.SecurityMonitoringApi;
+import com.datadog.api.client.v2.model.DueDateRuleResponse;
+import java.util.UUID;
+
+public class Example {
+  public static void main(String[] args) {
+    ApiClient defaultClient = ApiClient.getDefaultApiClient();
+    defaultClient.setUnstableOperationEnabled("v2.getSecurityFindingsAutomationDueDateRule", true);
+    SecurityMonitoringApi apiInstance = new SecurityMonitoringApi(defaultClient);
+
+    // there is a valid "valid_due_date_rule" in the system
+    UUID VALID_DUE_DATE_RULE_DATA_ID = null;
+    try {
+      VALID_DUE_DATE_RULE_DATA_ID = UUID.fromString(System.getenv("VALID_DUE_DATE_RULE_DATA_ID"));
+    } catch (IllegalArgumentException e) {
+      System.err.println("Error parsing UUID: " + e.getMessage());
+    }
+
+    try {
+      DueDateRuleResponse result =
+          apiInstance.getSecurityFindingsAutomationDueDateRule(VALID_DUE_DATE_RULE_DATA_ID);
+      System.out.println(result);
+    } catch (ApiException e) {
+      System.err.println(
+          "Exception when calling SecurityMonitoringApi#getSecurityFindingsAutomationDueDateRule");
+      System.err.println("Status code: " + e.getCode());
+      System.err.println("Reason: " + e.getResponseBody());
+      System.err.println("Response headers: " + e.getResponseHeaders());
+      e.printStackTrace();
+    }
+  }
+}

examples/v2/security-monitoring/GetSecurityFindingsAutomationMuteRule.java

@@ -0,0 +1,36 @@
+// Get a mute rule returns "Successfully retrieved the mute rule" response
+
+import com.datadog.api.client.ApiClient;
+import com.datadog.api.client.ApiException;
+import com.datadog.api.client.v2.api.SecurityMonitoringApi;
+import com.datadog.api.client.v2.model.MuteRuleResponse;
+import java.util.UUID;
+
+public class Example {
+  public static void main(String[] args) {
+    ApiClient defaultClient = ApiClient.getDefaultApiClient();
+    defaultClient.setUnstableOperationEnabled("v2.getSecurityFindingsAutomationMuteRule", true);
+    SecurityMonitoringApi apiInstance = new SecurityMonitoringApi(defaultClient);
+
+    // there is a valid "valid_mute_rule" in the system
+    UUID VALID_MUTE_RULE_DATA_ID = null;
+    try {
+      VALID_MUTE_RULE_DATA_ID = UUID.fromString(System.getenv("VALID_MUTE_RULE_DATA_ID"));
+    } catch (IllegalArgumentException e) {
+      System.err.println("Error parsing UUID: " + e.getMessage());
+    }
+
+    try {
+      MuteRuleResponse result =
+          apiInstance.getSecurityFindingsAutomationMuteRule(VALID_MUTE_RULE_DATA_ID);
+      System.out.println(result);
+    } catch (ApiException e) {
+      System.err.println(
+          "Exception when calling SecurityMonitoringApi#getSecurityFindingsAutomationMuteRule");
+      System.err.println("Status code: " + e.getCode());
+      System.err.println("Reason: " + e.getResponseBody());
+      System.err.println("Response headers: " + e.getResponseHeaders());
+      e.printStackTrace();
+    }
+  }
+}