feat: add example for UsageSummary additionalProperties iteration

examples/v1_usage-metering_GetUsageSummary.rs

@@ -3,22 +3,91 @@ use chrono::{DateTime, Utc};
 use datadog_api_client::datadog;
 use datadog_api_client::datadogV1::api_usage_metering::GetUsageSummaryOptionalParams;
 use datadog_api_client::datadogV1::api_usage_metering::UsageMeteringAPI;
+use datadog_api_client::datadogV2::api_usage_metering::UsageMeteringAPI as UsageMeteringAPIV2;
 
 #[tokio::main]
 async fn main() {
     let configuration = datadog::Configuration::new();
-    let api = UsageMeteringAPI::with_config(configuration);
-    let resp = api
+
+    // Step 1: call v2 GetUsageSummaryAvailableFields to learn which keys exist
+    let api_v2 = UsageMeteringAPIV2::with_config(configuration.clone());
+    let fields_resp = api_v2.get_usage_summary_available_fields().await;
+    let (response_fields, date_fields, date_org_fields) = match fields_resp {
+        Ok(body) => {
+            let attrs = body
+                .data
+                .and_then(|d| d.attributes)
+                .unwrap_or_default();
+            (
+                attrs.response_fields.unwrap_or_default(),
+                attrs.date_fields.unwrap_or_default(),
+                attrs.date_org_fields.unwrap_or_default(),
+            )
+        }
+        Err(e) => {
+            println!("{:#?}", e);
+            return;
+        }
+    };
+
+    // Step 2: call v1 GetUsageSummary with include_org_details
+    let api_v1 = UsageMeteringAPI::with_config(configuration);
+    let resp = api_v1
         .get_usage_summary(
             DateTime::parse_from_rfc3339("2021-11-11T11:11:11.111000+00:00")
                 .expect("Failed to parse datetime")
                 .with_timezone(&Utc),
-            GetUsageSummaryOptionalParams::default(),
+            GetUsageSummaryOptionalParams::default().include_org_details(true),
         )
         .await;
-    if let Ok(value) = resp {
-        println!("{:#?}", value);
-    } else {
-        println!("{:#?}", resp.unwrap_err());
+
+    let summary = match resp {
+        Ok(value) => value,
+        Err(e) => {
+            println!("{:#?}", e);
+            return;
+        }
+    };
+
+    // Layer 1: iterate response_fields over top-level UsageSummaryResponse additional_properties
+    println!("=== response-level additional_properties ===");
+    for field in &response_fields {
+        if let Some(val) = summary.additional_properties.get(field) {
+            println!("  {field}: {val}");
+        }
+    }
+
+    // Layer 2 & 3: iterate date_fields and date_org_fields over each UsageSummaryDate (and its orgs)
+    if let Some(usage_dates) = &summary.usage {
+        for usage_date in usage_dates {
+            println!(
+                "\n=== date {} additional_properties ===",
+                usage_date
+                    .date
+                    .map(|d| d.to_string())
+                    .unwrap_or_else(|| "(unknown)".to_string())
+            );
+            for field in &date_fields {
+                if let Some(val) = usage_date.additional_properties.get(field) {
+                    println!("  {field}: {val}");
+                }
+            }
+
+            if let Some(orgs) = &usage_date.orgs {
+                for org in orgs {
+                    println!(
+                        "\n  === org {} additional_properties ===",
+                        org.name
+                            .as_deref()
+                            .unwrap_or("(unknown)")
+                    );
+                    for field in &date_org_fields {
+                        if let Some(val) = org.additional_properties.get(field) {
+                            println!("    {field}: {val}");
+                        }
+                    }
+                }
+            }
+        }
     }
 }

examples/v2_usage-metering_GetUsageSummaryAvailableFields.rs

@@ -1,4 +1,4 @@
-// Get available fields for usage summary returns "OK." response
+// Get available fields for usage summary returns "OK" response
 use datadog_api_client::datadog;
 use datadog_api_client::datadogV2::api_usage_metering::UsageMeteringAPI;
 
@@ -7,9 +7,30 @@ async fn main() {
     let configuration = datadog::Configuration::new();
     let api = UsageMeteringAPI::with_config(configuration);
     let resp = api.get_usage_summary_available_fields().await;
-    if let Ok(value) = resp {
-        println!("{:#?}", value);
-    } else {
-        println!("{:#?}", resp.unwrap_err());
+    match resp {
+        Ok(value) => {
+            if let Some(data) = value.data {
+                if let Some(attrs) = data.attributes {
+                    let response_fields = attrs.response_fields.unwrap_or_default();
+                    println!("response_fields ({}):", response_fields.len());
+                    for f in &response_fields {
+                        println!("  {f}");
+                    }
+
+                    let date_fields = attrs.date_fields.unwrap_or_default();
+                    println!("date_fields ({}):", date_fields.len());
+                    for f in &date_fields {
+                        println!("  {f}");
+                    }
+
+                    let date_org_fields = attrs.date_org_fields.unwrap_or_default();
+                    println!("date_org_fields ({}):", date_org_fields.len());
+                    for f in &date_org_fields {
+                        println!("  {f}");
+                    }
+                }
+            }
+        }
+        Err(e) => println!("{:#?}", e),
     }
 }