Add OpenAPI documentation for scorecards endpoints

examples/v2_service-scorecards_CreateScorecardCampaign.rs

@@ -0,0 +1,46 @@
+// Create a new campaign returns "Created" response
+use chrono::{DateTime, Utc};
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_service_scorecards::ServiceScorecardsAPI;
+use datadog_api_client::datadogV2::model::CampaignStatus;
+use datadog_api_client::datadogV2::model::CampaignType;
+use datadog_api_client::datadogV2::model::CreateCampaignRequest;
+use datadog_api_client::datadogV2::model::CreateCampaignRequestAttributes;
+use datadog_api_client::datadogV2::model::CreateCampaignRequestData;
+
+#[tokio::main]
+async fn main() {
+    let body = CreateCampaignRequest::new(CreateCampaignRequestData::new(
+        CreateCampaignRequestAttributes::new(
+            "q1-security-2024".to_string(),
+            "Q1 Security Campaign".to_string(),
+            "550e8400-e29b-41d4-a716-446655440000".to_string(),
+            vec![
+                "q8MQxk8TCqrHnWkx".to_string(),
+                "r9NRyl9UDrsIoXly".to_string(),
+            ],
+            DateTime::parse_from_rfc3339("2024-01-01T00:00:00+00:00")
+                .expect("Failed to parse datetime")
+                .with_timezone(&Utc),
+        )
+        .description("Campaign to improve security posture for Q1 2024.".to_string())
+        .due_date(
+            DateTime::parse_from_rfc3339("2024-03-31T23:59:59+00:00")
+                .expect("Failed to parse datetime")
+                .with_timezone(&Utc),
+        )
+        .entity_scope("kind:service AND team:platform".to_string())
+        .guidance("Please ensure all services pass the security requirements.".to_string())
+        .status(CampaignStatus::IN_PROGRESS),
+        CampaignType::CAMPAIGN,
+    ));
+    let mut configuration = datadog::Configuration::new();
+    configuration.set_unstable_operation_enabled("v2.CreateScorecardCampaign", true);
+    let api = ServiceScorecardsAPI::with_config(configuration);
+    let resp = api.create_scorecard_campaign(body).await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_service-scorecards_DeleteScorecardCampaign.rs

@@ -0,0 +1,18 @@
+// Delete a campaign returns "No Content" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_service_scorecards::ServiceScorecardsAPI;
+
+#[tokio::main]
+async fn main() {
+    let mut configuration = datadog::Configuration::new();
+    configuration.set_unstable_operation_enabled("v2.DeleteScorecardCampaign", true);
+    let api = ServiceScorecardsAPI::with_config(configuration);
+    let resp = api
+        .delete_scorecard_campaign("c10ODp0VCrrIpXmz".to_string())
+        .await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_service-scorecards_DeleteScorecardRuleWorkflow.rs

@@ -0,0 +1,18 @@
+// Delete rule workflow returns "No Content" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_service_scorecards::ServiceScorecardsAPI;
+
+#[tokio::main]
+async fn main() {
+    let mut configuration = datadog::Configuration::new();
+    configuration.set_unstable_operation_enabled("v2.DeleteScorecardRuleWorkflow", true);
+    let api = ServiceScorecardsAPI::with_config(configuration);
+    let resp = api
+        .delete_scorecard_rule_workflow("rule_id".to_string())
+        .await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_service-scorecards_GenerateScorecardCampaignReport.rs

@@ -0,0 +1,33 @@
+// Generate campaign report returns "Accepted" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_service_scorecards::ServiceScorecardsAPI;
+use datadog_api_client::datadogV2::model::GenerateCampaignReportRequest;
+use datadog_api_client::datadogV2::model::GenerateCampaignReportRequestAttributes;
+use datadog_api_client::datadogV2::model::GenerateCampaignReportRequestData;
+use datadog_api_client::datadogV2::model::GenerateCampaignReportRequestDataType;
+use datadog_api_client::datadogV2::model::SlackRoutingOptions;
+
+#[tokio::main]
+async fn main() {
+    let body = GenerateCampaignReportRequest::new(GenerateCampaignReportRequestData::new(
+        GenerateCampaignReportRequestAttributes::new(
+            SlackRoutingOptions::new()
+                .channel_id("C024BDQ4N".to_string())
+                .channel_name("service-scorecards".to_string())
+                .workspace_id("T024BDQ4N".to_string())
+                .workspace_name("datadog-workspace".to_string()),
+        ),
+        GenerateCampaignReportRequestDataType::CAMPAIGN_REPORT,
+    ));
+    let mut configuration = datadog::Configuration::new();
+    configuration.set_unstable_operation_enabled("v2.GenerateScorecardCampaignReport", true);
+    let api = ServiceScorecardsAPI::with_config(configuration);
+    let resp = api
+        .generate_scorecard_campaign_report("c10ODp0VCrrIpXmz".to_string(), body)
+        .await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_service-scorecards_GenerateScorecardCampaignTeamReports.rs

@@ -0,0 +1,34 @@
+// Generate team-specific campaign reports returns "Accepted" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_service_scorecards::ServiceScorecardsAPI;
+use datadog_api_client::datadogV2::model::EntityOwnerDestination;
+use datadog_api_client::datadogV2::model::GenerateCampaignTeamReportsRequest;
+use datadog_api_client::datadogV2::model::GenerateCampaignTeamReportsRequestAttributes;
+use datadog_api_client::datadogV2::model::GenerateCampaignTeamReportsRequestData;
+use datadog_api_client::datadogV2::model::GenerateCampaignTeamReportsRequestDataType;
+use datadog_api_client::datadogV2::model::SlackRoutingOptions;
+
+#[tokio::main]
+async fn main() {
+    let body =
+        GenerateCampaignTeamReportsRequest::new(GenerateCampaignTeamReportsRequestData::new(
+            GenerateCampaignTeamReportsRequestAttributes::new(vec![EntityOwnerDestination::new(
+                SlackRoutingOptions::new()
+                    .channel_id("C024BDQ4N".to_string())
+                    .workspace_id("T024BDQ4N".to_string()),
+                "550e8400-e29b-41d4-a716-446655440000".to_string(),
+            )]),
+            GenerateCampaignTeamReportsRequestDataType::CAMPAIGN_TEAM_REPORT,
+        ));
+    let mut configuration = datadog::Configuration::new();
+    configuration.set_unstable_operation_enabled("v2.GenerateScorecardCampaignTeamReports", true);
+    let api = ServiceScorecardsAPI::with_config(configuration);
+    let resp = api
+        .generate_scorecard_campaign_team_reports("c10ODp0VCrrIpXmz".to_string(), body)
+        .await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_service-scorecards_GetScorecardCampaign.rs

@@ -0,0 +1,22 @@
+// Get a campaign returns "OK" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_service_scorecards::GetScorecardCampaignOptionalParams;
+use datadog_api_client::datadogV2::api_service_scorecards::ServiceScorecardsAPI;
+
+#[tokio::main]
+async fn main() {
+    let mut configuration = datadog::Configuration::new();
+    configuration.set_unstable_operation_enabled("v2.GetScorecardCampaign", true);
+    let api = ServiceScorecardsAPI::with_config(configuration);
+    let resp = api
+        .get_scorecard_campaign(
+            "c10ODp0VCrrIpXmz".to_string(),
+            GetScorecardCampaignOptionalParams::default(),
+        )
+        .await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_service-scorecards_ListScorecardCampaigns.rs

@@ -0,0 +1,19 @@
+// List all campaigns returns "OK" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_service_scorecards::ListScorecardCampaignsOptionalParams;
+use datadog_api_client::datadogV2::api_service_scorecards::ServiceScorecardsAPI;
+
+#[tokio::main]
+async fn main() {
+    let mut configuration = datadog::Configuration::new();
+    configuration.set_unstable_operation_enabled("v2.ListScorecardCampaigns", true);
+    let api = ServiceScorecardsAPI::with_config(configuration);
+    let resp = api
+        .list_scorecard_campaigns(ListScorecardCampaignsOptionalParams::default())
+        .await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_service-scorecards_ListScorecardDefaultRules.rs

@@ -0,0 +1,16 @@
+// List default rules returns "OK" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_service_scorecards::ServiceScorecardsAPI;
+
+#[tokio::main]
+async fn main() {
+    let mut configuration = datadog::Configuration::new();
+    configuration.set_unstable_operation_enabled("v2.ListScorecardDefaultRules", true);
+    let api = ServiceScorecardsAPI::with_config(configuration);
+    let resp = api.list_scorecard_default_rules().await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_service-scorecards_ListScorecardFacets.rs

@@ -0,0 +1,19 @@
+// List entity facets returns "OK" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_service_scorecards::ListScorecardFacetsOptionalParams;
+use datadog_api_client::datadogV2::api_service_scorecards::ServiceScorecardsAPI;
+
+#[tokio::main]
+async fn main() {
+    let mut configuration = datadog::Configuration::new();
+    configuration.set_unstable_operation_enabled("v2.ListScorecardFacets", true);
+    let api = ServiceScorecardsAPI::with_config(configuration);
+    let resp = api
+        .list_scorecard_facets(ListScorecardFacetsOptionalParams::default())
+        .await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_service-scorecards_ListScorecardScores.rs

@@ -0,0 +1,22 @@
+// List scores by aggregation returns "OK" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_service_scorecards::ListScorecardScoresOptionalParams;
+use datadog_api_client::datadogV2::api_service_scorecards::ServiceScorecardsAPI;
+
+#[tokio::main]
+async fn main() {
+    let mut configuration = datadog::Configuration::new();
+    configuration.set_unstable_operation_enabled("v2.ListScorecardScores", true);
+    let api = ServiceScorecardsAPI::with_config(configuration);
+    let resp = api
+        .list_scorecard_scores(
+            "by-entity".to_string(),
+            ListScorecardScoresOptionalParams::default(),
+        )
+        .await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_service-scorecards_ListScorecards.rs

@@ -0,0 +1,19 @@
+// List all scorecards returns "OK" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_service_scorecards::ListScorecardsOptionalParams;
+use datadog_api_client::datadogV2::api_service_scorecards::ServiceScorecardsAPI;
+
+#[tokio::main]
+async fn main() {
+    let mut configuration = datadog::Configuration::new();
+    configuration.set_unstable_operation_enabled("v2.ListScorecards", true);
+    let api = ServiceScorecardsAPI::with_config(configuration);
+    let resp = api
+        .list_scorecards(ListScorecardsOptionalParams::default())
+        .await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_service-scorecards_SetupScorecardRules.rs

@@ -0,0 +1,27 @@
+// Set up rules for organization returns "No Content" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_service_scorecards::ServiceScorecardsAPI;
+use datadog_api_client::datadogV2::model::SetupRulesRequest;
+use datadog_api_client::datadogV2::model::SetupRulesRequestAttributes;
+use datadog_api_client::datadogV2::model::SetupRulesRequestData;
+use datadog_api_client::datadogV2::model::SetupRulesRequestDataType;
+
+#[tokio::main]
+async fn main() {
+    let body = SetupRulesRequest::new(SetupRulesRequestData::new(
+        SetupRulesRequestAttributes::new().disabled_default_rules(vec![
+            "q8MQxk8TCqrHnWkx".to_string(),
+            "r9NRyl9UDrsIoXly".to_string(),
+        ]),
+        SetupRulesRequestDataType::SETUP,
+    ));
+    let mut configuration = datadog::Configuration::new();
+    configuration.set_unstable_operation_enabled("v2.SetupScorecardRules", true);
+    let api = ServiceScorecardsAPI::with_config(configuration);
+    let resp = api.setup_scorecard_rules(body).await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_service-scorecards_UpdateScorecardCampaign.rs

@@ -0,0 +1,47 @@
+// Update a campaign returns "OK" response
+use chrono::{DateTime, Utc};
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_service_scorecards::ServiceScorecardsAPI;
+use datadog_api_client::datadogV2::model::CampaignType;
+use datadog_api_client::datadogV2::model::UpdateCampaignRequest;
+use datadog_api_client::datadogV2::model::UpdateCampaignRequestAttributes;
+use datadog_api_client::datadogV2::model::UpdateCampaignRequestData;
+
+#[tokio::main]
+async fn main() {
+    let body = UpdateCampaignRequest::new(UpdateCampaignRequestData::new(
+        UpdateCampaignRequestAttributes::new(
+            "Q1 Security Campaign".to_string(),
+            "550e8400-e29b-41d4-a716-446655440000".to_string(),
+            vec![
+                "q8MQxk8TCqrHnWkx".to_string(),
+                "r9NRyl9UDrsIoXly".to_string(),
+            ],
+            DateTime::parse_from_rfc3339("2024-01-01T00:00:00+00:00")
+                .expect("Failed to parse datetime")
+                .with_timezone(&Utc),
+            "in_progress".to_string(),
+        )
+        .description("Campaign to improve security posture for Q1 2024.".to_string())
+        .due_date(
+            DateTime::parse_from_rfc3339("2024-03-31T23:59:59+00:00")
+                .expect("Failed to parse datetime")
+                .with_timezone(&Utc),
+        )
+        .entity_scope("kind:service AND team:platform".to_string())
+        .guidance("Please ensure all services pass the security requirements.".to_string())
+        .key("q1-security-2024".to_string()),
+        CampaignType::CAMPAIGN,
+    ));
+    let mut configuration = datadog::Configuration::new();
+    configuration.set_unstable_operation_enabled("v2.UpdateScorecardCampaign", true);
+    let api = ServiceScorecardsAPI::with_config(configuration);
+    let resp = api
+        .update_scorecard_campaign("c10ODp0VCrrIpXmz".to_string(), body)
+        .await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_service-scorecards_UpdateScorecardRuleWorkflow.rs

@@ -0,0 +1,21 @@
+// Associate workflow with rule returns "No Content" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_service_scorecards::ServiceScorecardsAPI;
+
+#[tokio::main]
+async fn main() {
+    let mut configuration = datadog::Configuration::new();
+    configuration.set_unstable_operation_enabled("v2.UpdateScorecardRuleWorkflow", true);
+    let api = ServiceScorecardsAPI::with_config(configuration);
+    let resp = api
+        .update_scorecard_rule_workflow(
+            "rule_id".to_string(),
+            "550e8400-e29b-41d4-a716-446655440000".to_string(),
+        )
+        .await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}