diff --git a/.generator/schemas/v2/openapi.yaml b/.generator/schemas/v2/openapi.yaml index e83df8269e..7f2cc7c1b2 100644 --- a/.generator/schemas/v2/openapi.yaml +++ b/.generator/schemas/v2/openapi.yaml @@ -3734,6 +3734,114 @@ components: description: The `markdownTextAnnotation` `text`. type: string type: object + AnonymizeUserError: + description: Error encountered when anonymizing a specific user. + properties: + error: + description: Error message describing why anonymization failed. + example: "" + type: string + user_id: + description: UUID of the user that failed to be anonymized. + example: "00000000-0000-0000-0000-000000000000" + type: string + required: + - user_id + - error + type: object + AnonymizeUsersRequest: + description: Request body for anonymizing users. + properties: + data: + $ref: "#/components/schemas/AnonymizeUsersRequestData" + required: + - data + type: object + AnonymizeUsersRequestAttributes: + description: Attributes of an anonymize users request. + properties: + user_ids: + description: List of user IDs (UUIDs) to anonymize. + example: + - "00000000-0000-0000-0000-000000000000" + items: + example: "00000000-0000-0000-0000-000000000000" + type: string + type: array + required: + - user_ids + type: object + AnonymizeUsersRequestData: + description: Object to anonymize a list of users. + properties: + attributes: + $ref: "#/components/schemas/AnonymizeUsersRequestAttributes" + id: + description: Unique identifier for the request. Not used server-side. + example: "00000000-0000-0000-0000-000000000000" + type: string + type: + $ref: "#/components/schemas/AnonymizeUsersRequestType" + required: + - type + - attributes + type: object + AnonymizeUsersRequestType: + default: anonymize_users_request + description: Type of the anonymize users request. + enum: + - anonymize_users_request + example: anonymize_users_request + type: string + x-enum-varnames: + - ANONYMIZE_USERS_REQUEST + AnonymizeUsersResponse: + description: Response containing the result of an anonymize users request. + properties: + data: + $ref: "#/components/schemas/AnonymizeUsersResponseData" + type: object + AnonymizeUsersResponseAttributes: + description: Attributes of an anonymize users response. + properties: + anonymize_errors: + description: List of errors encountered during anonymization, one entry per failed user. + items: + $ref: "#/components/schemas/AnonymizeUserError" + type: array + anonymized_user_ids: + description: List of user IDs (UUIDs) that were successfully anonymized. + example: + - "00000000-0000-0000-0000-000000000000" + items: + example: "00000000-0000-0000-0000-000000000000" + type: string + type: array + required: + - anonymized_user_ids + - anonymize_errors + type: object + AnonymizeUsersResponseData: + description: Response data for anonymizing users. + properties: + attributes: + $ref: "#/components/schemas/AnonymizeUsersResponseAttributes" + id: + description: Unique identifier of the response. + example: "00000000-0000-0000-0000-000000000000" + type: string + type: + $ref: "#/components/schemas/AnonymizeUsersResponseType" + type: object + AnonymizeUsersResponseType: + default: anonymize_users_response + description: Type of the anonymize users response. + enum: + - anonymize_users_response + example: anonymize_users_response + type: string + x-enum-varnames: + - ANONYMIZE_USERS_RESPONSE AnthropicAPIKey: description: The definition of the `AnthropicAPIKey` object. properties: @@ -76578,6 +76686,53 @@ paths: operator: OR permissions: - security_monitoring_findings_read + /api/v2/anonymize_users: + put: + description: |- + Anonymize a list of users, removing their personal data. This operation is irreversible. + Requires the `user_access_manage` permission. + operationId: AnonymizeUsers + requestBody: + content: + application/json: + schema: + $ref: "#/components/schemas/AnonymizeUsersRequest" + required: true + responses: + "200": + content: + application/json: + schema: + $ref: "#/components/schemas/AnonymizeUsersResponse" + description: OK + "400": + content: + application/json: + schema: + $ref: "#/components/schemas/APIErrorResponse" + description: Bad Request + "403": + content: + application/json: + schema: + $ref: "#/components/schemas/APIErrorResponse" + description: Authentication error + "429": + $ref: "#/components/responses/TooManyRequestsResponse" + security: + - apiKeyAuth: [] + appKeyAuth: [] + - AuthZ: + - user_access_manage + summary: Anonymize users + tags: + - Users + x-codegen-request-body-name: body + x-permission: + operator: OR + permissions: + - user_access_manage + x-unstable: "**Note**: This endpoint is in Preview and may be subject to changes." /api/v2/api_keys: get: description: List all API keys available for your account. diff --git a/examples/v2_users_AnonymizeUsers.rs b/examples/v2_users_AnonymizeUsers.rs new file mode 100644 index 0000000000..40db65e6ee --- /dev/null +++ b/examples/v2_users_AnonymizeUsers.rs @@ -0,0 +1,29 @@ +// Anonymize users returns "OK" response +use datadog_api_client::datadog; +use datadog_api_client::datadogV2::api_users::UsersAPI; +use datadog_api_client::datadogV2::model::AnonymizeUsersRequest; +use datadog_api_client::datadogV2::model::AnonymizeUsersRequestAttributes; +use datadog_api_client::datadogV2::model::AnonymizeUsersRequestData; +use datadog_api_client::datadogV2::model::AnonymizeUsersRequestType; + +#[tokio::main] +async fn main() { + let body = AnonymizeUsersRequest::new( + AnonymizeUsersRequestData::new( + AnonymizeUsersRequestAttributes::new(vec![ + "00000000-0000-0000-0000-000000000000".to_string() + ]), + AnonymizeUsersRequestType::ANONYMIZE_USERS_REQUEST, + ) + .id("00000000-0000-0000-0000-000000000000".to_string()), + ); + let mut configuration = datadog::Configuration::new(); + configuration.set_unstable_operation_enabled("v2.AnonymizeUsers", true); + let api = UsersAPI::with_config(configuration); + let resp = api.anonymize_users(body).await; + if let Ok(value) = resp { + println!("{:#?}", value); + } else { + println!("{:#?}", resp.unwrap_err()); + } +} diff --git a/src/datadog/configuration.rs b/src/datadog/configuration.rs index 676b8b35a9..caecf27b94 100644 --- a/src/datadog/configuration.rs +++ b/src/datadog/configuration.rs @@ -136,6 +136,7 @@ impl Default for Configuration { ("v2.list_fleet_schedules".to_owned(), false), ("v2.trigger_fleet_schedule".to_owned(), false), ("v2.update_fleet_schedule".to_owned(), false), + ("v2.anonymize_users".to_owned(), false), ("v2.create_open_api".to_owned(), false), ("v2.delete_open_api".to_owned(), false), ("v2.get_open_api".to_owned(), false), diff --git a/src/datadogV2/api/api_users.rs b/src/datadogV2/api/api_users.rs index d610eb0d45..7821bf2918 100644 --- a/src/datadogV2/api/api_users.rs +++ b/src/datadogV2/api/api_users.rs @@ -8,6 +8,7 @@ use flate2::{ Compression, }; use futures_core::stream::Stream; +use log::warn; use reqwest::header::{HeaderMap, HeaderValue}; use serde::{Deserialize, Serialize}; use std::io::Write; @@ -73,6 +74,14 @@ impl ListUsersOptionalParams { } } +/// AnonymizeUsersError is a struct for typed errors of method [`UsersAPI::anonymize_users`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum AnonymizeUsersError { + APIErrorResponse(crate::datadogV2::model::APIErrorResponse), + UnknownValue(serde_json::Value), +} + /// CreateUserError is a struct for typed errors of method [`UsersAPI::create_user`] #[derive(Debug, Clone, Serialize, Deserialize)] #[serde(untagged)] @@ -219,6 +228,169 @@ impl UsersAPI { Self { config, client } } + /// Anonymize a list of users, removing their personal data. This operation is irreversible. + /// Requires the `user_access_manage` permission. + pub async fn anonymize_users( + &self, + body: crate::datadogV2::model::AnonymizeUsersRequest, + ) -> Result> + { + match self.anonymize_users_with_http_info(body).await { + Ok(response_content) => { + if let Some(e) = response_content.entity { + Ok(e) + } else { + Err(datadog::Error::Serde(serde::de::Error::custom( + "response content was None", + ))) + } + } + Err(err) => Err(err), + } + } + + /// Anonymize a list of users, removing their personal data. This operation is irreversible. + /// Requires the `user_access_manage` permission. + pub async fn anonymize_users_with_http_info( + &self, + body: crate::datadogV2::model::AnonymizeUsersRequest, + ) -> Result< + datadog::ResponseContent, + datadog::Error, + > { + let local_configuration = &self.config; + let operation_id = "v2.anonymize_users"; + if local_configuration.is_unstable_operation_enabled(operation_id) { + warn!("Using unstable operation {operation_id}"); + } else { + let local_error = datadog::UnstableOperationDisabledError { + msg: "Operation 'v2.anonymize_users' is not enabled".to_string(), + }; + return Err(datadog::Error::UnstableOperationDisabledError(local_error)); + } + + let local_client = &self.client; + + let local_uri_str = format!( + "{}/api/v2/anonymize_users", + local_configuration.get_operation_host(operation_id) + ); + let mut local_req_builder = + local_client.request(reqwest::Method::PUT, local_uri_str.as_str()); + + // build headers + let mut headers = HeaderMap::new(); + headers.insert("Content-Type", HeaderValue::from_static("application/json")); + headers.insert("Accept", HeaderValue::from_static("application/json")); + + // build user agent + match HeaderValue::from_str(local_configuration.user_agent.as_str()) { + Ok(user_agent) => headers.insert(reqwest::header::USER_AGENT, user_agent), + Err(e) => { + log::warn!("Failed to parse user agent header: {e}, falling back to default"); + headers.insert( + reqwest::header::USER_AGENT, + HeaderValue::from_static(datadog::DEFAULT_USER_AGENT.as_str()), + ) + } + }; + + // build auth + if let Some(local_key) = local_configuration.auth_keys.get("apiKeyAuth") { + headers.insert( + "DD-API-KEY", + HeaderValue::from_str(local_key.key.as_str()) + .expect("failed to parse DD-API-KEY header"), + ); + }; + if let Some(local_key) = local_configuration.auth_keys.get("appKeyAuth") { + headers.insert( + "DD-APPLICATION-KEY", + HeaderValue::from_str(local_key.key.as_str()) + .expect("failed to parse DD-APPLICATION-KEY header"), + ); + }; + + // build body parameters + let output = Vec::new(); + let mut ser = serde_json::Serializer::with_formatter(output, datadog::DDFormatter); + if body.serialize(&mut ser).is_ok() { + if let Some(content_encoding) = headers.get("Content-Encoding") { + match content_encoding.to_str().unwrap_or_default() { + "gzip" => { + let mut enc = GzEncoder::new(Vec::new(), Compression::default()); + let _ = enc.write_all(ser.into_inner().as_slice()); + match enc.finish() { + Ok(buf) => { + local_req_builder = local_req_builder.body(buf); + } + Err(e) => return Err(datadog::Error::Io(e)), + } + } + "deflate" => { + let mut enc = ZlibEncoder::new(Vec::new(), Compression::default()); + let _ = enc.write_all(ser.into_inner().as_slice()); + match enc.finish() { + Ok(buf) => { + local_req_builder = local_req_builder.body(buf); + } + Err(e) => return Err(datadog::Error::Io(e)), + } + } + #[cfg(feature = "zstd")] + "zstd1" => { + let mut enc = zstd::stream::Encoder::new(Vec::new(), 0).unwrap(); + let _ = enc.write_all(ser.into_inner().as_slice()); + match enc.finish() { + Ok(buf) => { + local_req_builder = local_req_builder.body(buf); + } + Err(e) => return Err(datadog::Error::Io(e)), + } + } + _ => { + local_req_builder = local_req_builder.body(ser.into_inner()); + } + } + } else { + local_req_builder = local_req_builder.body(ser.into_inner()); + } + } + + local_req_builder = local_req_builder.headers(headers); + let local_req = local_req_builder.build()?; + log::debug!("request content: {:?}", local_req.body()); + let local_resp = local_client.execute(local_req).await?; + + let local_status = local_resp.status(); + let local_content = local_resp.text().await?; + log::debug!("response content: {}", local_content); + + if !local_status.is_client_error() && !local_status.is_server_error() { + match serde_json::from_str::( + &local_content, + ) { + Ok(e) => { + return Ok(datadog::ResponseContent { + status: local_status, + content: local_content, + entity: Some(e), + }) + } + Err(e) => return Err(datadog::Error::Serde(e)), + }; + } else { + let local_entity: Option = + serde_json::from_str(&local_content).ok(); + let local_error = datadog::ResponseContent { + status: local_status, + content: local_content, + entity: local_entity, + }; + Err(datadog::Error::ResponseError(local_error)) + } + } + /// Create a user for your organization. pub async fn create_user( &self, diff --git a/src/datadogV2/model/mod.rs b/src/datadogV2/model/mod.rs index 56e58eb84a..7ddd09b5f5 100644 --- a/src/datadogV2/model/mod.rs +++ b/src/datadogV2/model/mod.rs @@ -722,6 +722,24 @@ pub mod model_aws_on_demand_create_attributes; pub use self::model_aws_on_demand_create_attributes::AwsOnDemandCreateAttributes; pub mod model_aws_on_demand_response; pub use self::model_aws_on_demand_response::AwsOnDemandResponse; +pub mod model_anonymize_users_request; +pub use self::model_anonymize_users_request::AnonymizeUsersRequest; +pub mod model_anonymize_users_request_data; +pub use self::model_anonymize_users_request_data::AnonymizeUsersRequestData; +pub mod model_anonymize_users_request_attributes; +pub use self::model_anonymize_users_request_attributes::AnonymizeUsersRequestAttributes; +pub mod model_anonymize_users_request_type; +pub use self::model_anonymize_users_request_type::AnonymizeUsersRequestType; +pub mod model_anonymize_users_response; +pub use self::model_anonymize_users_response::AnonymizeUsersResponse; +pub mod model_anonymize_users_response_data; +pub use self::model_anonymize_users_response_data::AnonymizeUsersResponseData; +pub mod model_anonymize_users_response_attributes; +pub use self::model_anonymize_users_response_attributes::AnonymizeUsersResponseAttributes; +pub mod model_anonymize_user_error; +pub use self::model_anonymize_user_error::AnonymizeUserError; +pub mod model_anonymize_users_response_type; +pub use self::model_anonymize_users_response_type::AnonymizeUsersResponseType; pub mod model_api_keys_sort; pub use self::model_api_keys_sort::APIKeysSort; pub mod model_api_keys_response; diff --git a/src/datadogV2/model/model_anonymize_user_error.rs b/src/datadogV2/model/model_anonymize_user_error.rs new file mode 100644 index 0000000000..fee02100fb --- /dev/null +++ b/src/datadogV2/model/model_anonymize_user_error.rs @@ -0,0 +1,102 @@ +// 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. +use serde::de::{Error, MapAccess, Visitor}; +use serde::{Deserialize, Deserializer, Serialize}; +use serde_with::skip_serializing_none; +use std::fmt::{self, Formatter}; + +/// Error encountered when anonymizing a specific user. +#[non_exhaustive] +#[skip_serializing_none] +#[derive(Clone, Debug, PartialEq, Serialize)] +pub struct AnonymizeUserError { + /// Error message describing why anonymization failed. + #[serde(rename = "error")] + pub error: String, + /// UUID of the user that failed to be anonymized. + #[serde(rename = "user_id")] + pub user_id: String, + #[serde(flatten)] + pub additional_properties: std::collections::BTreeMap, + #[serde(skip)] + #[serde(default)] + pub(crate) _unparsed: bool, +} + +impl AnonymizeUserError { + pub fn new(error: String, user_id: String) -> AnonymizeUserError { + AnonymizeUserError { + error, + user_id, + additional_properties: std::collections::BTreeMap::new(), + _unparsed: false, + } + } + + pub fn additional_properties( + mut self, + value: std::collections::BTreeMap, + ) -> Self { + self.additional_properties = value; + self + } +} + +impl<'de> Deserialize<'de> for AnonymizeUserError { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + struct AnonymizeUserErrorVisitor; + impl<'a> Visitor<'a> for AnonymizeUserErrorVisitor { + type Value = AnonymizeUserError; + + fn expecting(&self, f: &mut Formatter<'_>) -> fmt::Result { + f.write_str("a mapping") + } + + fn visit_map(self, mut map: M) -> Result + where + M: MapAccess<'a>, + { + let mut error: Option = None; + let mut user_id: Option = None; + let mut additional_properties: std::collections::BTreeMap< + String, + serde_json::Value, + > = std::collections::BTreeMap::new(); + let mut _unparsed = false; + + while let Some((k, v)) = map.next_entry::()? { + match k.as_str() { + "error" => { + error = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "user_id" => { + user_id = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + &_ => { + if let Ok(value) = serde_json::from_value(v.clone()) { + additional_properties.insert(k, value); + } + } + } + } + let error = error.ok_or_else(|| M::Error::missing_field("error"))?; + let user_id = user_id.ok_or_else(|| M::Error::missing_field("user_id"))?; + + let content = AnonymizeUserError { + error, + user_id, + additional_properties, + _unparsed, + }; + + Ok(content) + } + } + + deserializer.deserialize_any(AnonymizeUserErrorVisitor) + } +} diff --git a/src/datadogV2/model/model_anonymize_users_request.rs b/src/datadogV2/model/model_anonymize_users_request.rs new file mode 100644 index 0000000000..f22edfd0b6 --- /dev/null +++ b/src/datadogV2/model/model_anonymize_users_request.rs @@ -0,0 +1,92 @@ +// 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. +use serde::de::{Error, MapAccess, Visitor}; +use serde::{Deserialize, Deserializer, Serialize}; +use serde_with::skip_serializing_none; +use std::fmt::{self, Formatter}; + +/// Request body for anonymizing users. +#[non_exhaustive] +#[skip_serializing_none] +#[derive(Clone, Debug, PartialEq, Serialize)] +pub struct AnonymizeUsersRequest { + /// Object to anonymize a list of users. + #[serde(rename = "data")] + pub data: crate::datadogV2::model::AnonymizeUsersRequestData, + #[serde(flatten)] + pub additional_properties: std::collections::BTreeMap, + #[serde(skip)] + #[serde(default)] + pub(crate) _unparsed: bool, +} + +impl AnonymizeUsersRequest { + pub fn new(data: crate::datadogV2::model::AnonymizeUsersRequestData) -> AnonymizeUsersRequest { + AnonymizeUsersRequest { + data, + additional_properties: std::collections::BTreeMap::new(), + _unparsed: false, + } + } + + pub fn additional_properties( + mut self, + value: std::collections::BTreeMap, + ) -> Self { + self.additional_properties = value; + self + } +} + +impl<'de> Deserialize<'de> for AnonymizeUsersRequest { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + struct AnonymizeUsersRequestVisitor; + impl<'a> Visitor<'a> for AnonymizeUsersRequestVisitor { + type Value = AnonymizeUsersRequest; + + fn expecting(&self, f: &mut Formatter<'_>) -> fmt::Result { + f.write_str("a mapping") + } + + fn visit_map(self, mut map: M) -> Result + where + M: MapAccess<'a>, + { + let mut data: Option = None; + let mut additional_properties: std::collections::BTreeMap< + String, + serde_json::Value, + > = std::collections::BTreeMap::new(); + let mut _unparsed = false; + + while let Some((k, v)) = map.next_entry::()? { + match k.as_str() { + "data" => { + data = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + &_ => { + if let Ok(value) = serde_json::from_value(v.clone()) { + additional_properties.insert(k, value); + } + } + } + } + let data = data.ok_or_else(|| M::Error::missing_field("data"))?; + + let content = AnonymizeUsersRequest { + data, + additional_properties, + _unparsed, + }; + + Ok(content) + } + } + + deserializer.deserialize_any(AnonymizeUsersRequestVisitor) + } +} diff --git a/src/datadogV2/model/model_anonymize_users_request_attributes.rs b/src/datadogV2/model/model_anonymize_users_request_attributes.rs new file mode 100644 index 0000000000..51741a6b55 --- /dev/null +++ b/src/datadogV2/model/model_anonymize_users_request_attributes.rs @@ -0,0 +1,92 @@ +// 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. +use serde::de::{Error, MapAccess, Visitor}; +use serde::{Deserialize, Deserializer, Serialize}; +use serde_with::skip_serializing_none; +use std::fmt::{self, Formatter}; + +/// Attributes of an anonymize users request. +#[non_exhaustive] +#[skip_serializing_none] +#[derive(Clone, Debug, PartialEq, Serialize)] +pub struct AnonymizeUsersRequestAttributes { + /// List of user IDs (UUIDs) to anonymize. + #[serde(rename = "user_ids")] + pub user_ids: Vec, + #[serde(flatten)] + pub additional_properties: std::collections::BTreeMap, + #[serde(skip)] + #[serde(default)] + pub(crate) _unparsed: bool, +} + +impl AnonymizeUsersRequestAttributes { + pub fn new(user_ids: Vec) -> AnonymizeUsersRequestAttributes { + AnonymizeUsersRequestAttributes { + user_ids, + additional_properties: std::collections::BTreeMap::new(), + _unparsed: false, + } + } + + pub fn additional_properties( + mut self, + value: std::collections::BTreeMap, + ) -> Self { + self.additional_properties = value; + self + } +} + +impl<'de> Deserialize<'de> for AnonymizeUsersRequestAttributes { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + struct AnonymizeUsersRequestAttributesVisitor; + impl<'a> Visitor<'a> for AnonymizeUsersRequestAttributesVisitor { + type Value = AnonymizeUsersRequestAttributes; + + fn expecting(&self, f: &mut Formatter<'_>) -> fmt::Result { + f.write_str("a mapping") + } + + fn visit_map(self, mut map: M) -> Result + where + M: MapAccess<'a>, + { + let mut user_ids: Option> = None; + let mut additional_properties: std::collections::BTreeMap< + String, + serde_json::Value, + > = std::collections::BTreeMap::new(); + let mut _unparsed = false; + + while let Some((k, v)) = map.next_entry::()? { + match k.as_str() { + "user_ids" => { + user_ids = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + &_ => { + if let Ok(value) = serde_json::from_value(v.clone()) { + additional_properties.insert(k, value); + } + } + } + } + let user_ids = user_ids.ok_or_else(|| M::Error::missing_field("user_ids"))?; + + let content = AnonymizeUsersRequestAttributes { + user_ids, + additional_properties, + _unparsed, + }; + + Ok(content) + } + } + + deserializer.deserialize_any(AnonymizeUsersRequestAttributesVisitor) + } +} diff --git a/src/datadogV2/model/model_anonymize_users_request_data.rs b/src/datadogV2/model/model_anonymize_users_request_data.rs new file mode 100644 index 0000000000..e5647a4d5c --- /dev/null +++ b/src/datadogV2/model/model_anonymize_users_request_data.rs @@ -0,0 +1,132 @@ +// 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. +use serde::de::{Error, MapAccess, Visitor}; +use serde::{Deserialize, Deserializer, Serialize}; +use serde_with::skip_serializing_none; +use std::fmt::{self, Formatter}; + +/// Object to anonymize a list of users. +#[non_exhaustive] +#[skip_serializing_none] +#[derive(Clone, Debug, PartialEq, Serialize)] +pub struct AnonymizeUsersRequestData { + /// Attributes of an anonymize users request. + #[serde(rename = "attributes")] + pub attributes: crate::datadogV2::model::AnonymizeUsersRequestAttributes, + /// Unique identifier for the request. Not used server-side. + #[serde(rename = "id")] + pub id: Option, + /// Type of the anonymize users request. + #[serde(rename = "type")] + pub type_: crate::datadogV2::model::AnonymizeUsersRequestType, + #[serde(flatten)] + pub additional_properties: std::collections::BTreeMap, + #[serde(skip)] + #[serde(default)] + pub(crate) _unparsed: bool, +} + +impl AnonymizeUsersRequestData { + pub fn new( + attributes: crate::datadogV2::model::AnonymizeUsersRequestAttributes, + type_: crate::datadogV2::model::AnonymizeUsersRequestType, + ) -> AnonymizeUsersRequestData { + AnonymizeUsersRequestData { + attributes, + id: None, + type_, + additional_properties: std::collections::BTreeMap::new(), + _unparsed: false, + } + } + + pub fn id(mut self, value: String) -> Self { + self.id = Some(value); + self + } + + pub fn additional_properties( + mut self, + value: std::collections::BTreeMap, + ) -> Self { + self.additional_properties = value; + self + } +} + +impl<'de> Deserialize<'de> for AnonymizeUsersRequestData { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + struct AnonymizeUsersRequestDataVisitor; + impl<'a> Visitor<'a> for AnonymizeUsersRequestDataVisitor { + type Value = AnonymizeUsersRequestData; + + fn expecting(&self, f: &mut Formatter<'_>) -> fmt::Result { + f.write_str("a mapping") + } + + fn visit_map(self, mut map: M) -> Result + where + M: MapAccess<'a>, + { + let mut attributes: Option< + crate::datadogV2::model::AnonymizeUsersRequestAttributes, + > = None; + let mut id: Option = None; + let mut type_: Option = None; + let mut additional_properties: std::collections::BTreeMap< + String, + serde_json::Value, + > = std::collections::BTreeMap::new(); + let mut _unparsed = false; + + while let Some((k, v)) = map.next_entry::()? { + match k.as_str() { + "attributes" => { + attributes = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "id" => { + if v.is_null() { + continue; + } + id = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "type" => { + type_ = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + if let Some(ref _type_) = type_ { + match _type_ { + crate::datadogV2::model::AnonymizeUsersRequestType::UnparsedObject(_type_) => { + _unparsed = true; + }, + _ => {} + } + } + } + &_ => { + if let Ok(value) = serde_json::from_value(v.clone()) { + additional_properties.insert(k, value); + } + } + } + } + let attributes = attributes.ok_or_else(|| M::Error::missing_field("attributes"))?; + let type_ = type_.ok_or_else(|| M::Error::missing_field("type_"))?; + + let content = AnonymizeUsersRequestData { + attributes, + id, + type_, + additional_properties, + _unparsed, + }; + + Ok(content) + } + } + + deserializer.deserialize_any(AnonymizeUsersRequestDataVisitor) + } +} diff --git a/src/datadogV2/model/model_anonymize_users_request_type.rs b/src/datadogV2/model/model_anonymize_users_request_type.rs new file mode 100644 index 0000000000..70e68f268d --- /dev/null +++ b/src/datadogV2/model/model_anonymize_users_request_type.rs @@ -0,0 +1,48 @@ +// 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. + +use serde::{Deserialize, Deserializer, Serialize, Serializer}; + +#[non_exhaustive] +#[derive(Clone, Debug, Eq, PartialEq)] +pub enum AnonymizeUsersRequestType { + ANONYMIZE_USERS_REQUEST, + UnparsedObject(crate::datadog::UnparsedObject), +} + +impl ToString for AnonymizeUsersRequestType { + fn to_string(&self) -> String { + match self { + Self::ANONYMIZE_USERS_REQUEST => String::from("anonymize_users_request"), + Self::UnparsedObject(v) => v.value.to_string(), + } + } +} + +impl Serialize for AnonymizeUsersRequestType { + fn serialize(&self, serializer: S) -> Result + where + S: Serializer, + { + match self { + Self::UnparsedObject(v) => v.serialize(serializer), + _ => serializer.serialize_str(self.to_string().as_str()), + } + } +} + +impl<'de> Deserialize<'de> for AnonymizeUsersRequestType { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + let s: String = String::deserialize(deserializer)?; + Ok(match s.as_str() { + "anonymize_users_request" => Self::ANONYMIZE_USERS_REQUEST, + _ => Self::UnparsedObject(crate::datadog::UnparsedObject { + value: serde_json::Value::String(s.into()), + }), + }) + } +} diff --git a/src/datadogV2/model/model_anonymize_users_response.rs b/src/datadogV2/model/model_anonymize_users_response.rs new file mode 100644 index 0000000000..c64758997f --- /dev/null +++ b/src/datadogV2/model/model_anonymize_users_response.rs @@ -0,0 +1,105 @@ +// 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. +use serde::de::{Error, MapAccess, Visitor}; +use serde::{Deserialize, Deserializer, Serialize}; +use serde_with::skip_serializing_none; +use std::fmt::{self, Formatter}; + +/// Response containing the result of an anonymize users request. +#[non_exhaustive] +#[skip_serializing_none] +#[derive(Clone, Debug, PartialEq, Serialize)] +pub struct AnonymizeUsersResponse { + /// Response data for anonymizing users. + #[serde(rename = "data")] + pub data: Option, + #[serde(flatten)] + pub additional_properties: std::collections::BTreeMap, + #[serde(skip)] + #[serde(default)] + pub(crate) _unparsed: bool, +} + +impl AnonymizeUsersResponse { + pub fn new() -> AnonymizeUsersResponse { + AnonymizeUsersResponse { + data: None, + additional_properties: std::collections::BTreeMap::new(), + _unparsed: false, + } + } + + pub fn data(mut self, value: crate::datadogV2::model::AnonymizeUsersResponseData) -> Self { + self.data = Some(value); + self + } + + pub fn additional_properties( + mut self, + value: std::collections::BTreeMap, + ) -> Self { + self.additional_properties = value; + self + } +} + +impl Default for AnonymizeUsersResponse { + fn default() -> Self { + Self::new() + } +} + +impl<'de> Deserialize<'de> for AnonymizeUsersResponse { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + struct AnonymizeUsersResponseVisitor; + impl<'a> Visitor<'a> for AnonymizeUsersResponseVisitor { + type Value = AnonymizeUsersResponse; + + fn expecting(&self, f: &mut Formatter<'_>) -> fmt::Result { + f.write_str("a mapping") + } + + fn visit_map(self, mut map: M) -> Result + where + M: MapAccess<'a>, + { + let mut data: Option = None; + let mut additional_properties: std::collections::BTreeMap< + String, + serde_json::Value, + > = std::collections::BTreeMap::new(); + let mut _unparsed = false; + + while let Some((k, v)) = map.next_entry::()? { + match k.as_str() { + "data" => { + if v.is_null() { + continue; + } + data = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + &_ => { + if let Ok(value) = serde_json::from_value(v.clone()) { + additional_properties.insert(k, value); + } + } + } + } + + let content = AnonymizeUsersResponse { + data, + additional_properties, + _unparsed, + }; + + Ok(content) + } + } + + deserializer.deserialize_any(AnonymizeUsersResponseVisitor) + } +} diff --git a/src/datadogV2/model/model_anonymize_users_response_attributes.rs b/src/datadogV2/model/model_anonymize_users_response_attributes.rs new file mode 100644 index 0000000000..f76d40508b --- /dev/null +++ b/src/datadogV2/model/model_anonymize_users_response_attributes.rs @@ -0,0 +1,110 @@ +// 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. +use serde::de::{Error, MapAccess, Visitor}; +use serde::{Deserialize, Deserializer, Serialize}; +use serde_with::skip_serializing_none; +use std::fmt::{self, Formatter}; + +/// Attributes of an anonymize users response. +#[non_exhaustive] +#[skip_serializing_none] +#[derive(Clone, Debug, PartialEq, Serialize)] +pub struct AnonymizeUsersResponseAttributes { + /// List of errors encountered during anonymization, one entry per failed user. + #[serde(rename = "anonymize_errors")] + pub anonymize_errors: Vec, + /// List of user IDs (UUIDs) that were successfully anonymized. + #[serde(rename = "anonymized_user_ids")] + pub anonymized_user_ids: Vec, + #[serde(flatten)] + pub additional_properties: std::collections::BTreeMap, + #[serde(skip)] + #[serde(default)] + pub(crate) _unparsed: bool, +} + +impl AnonymizeUsersResponseAttributes { + pub fn new( + anonymize_errors: Vec, + anonymized_user_ids: Vec, + ) -> AnonymizeUsersResponseAttributes { + AnonymizeUsersResponseAttributes { + anonymize_errors, + anonymized_user_ids, + additional_properties: std::collections::BTreeMap::new(), + _unparsed: false, + } + } + + pub fn additional_properties( + mut self, + value: std::collections::BTreeMap, + ) -> Self { + self.additional_properties = value; + self + } +} + +impl<'de> Deserialize<'de> for AnonymizeUsersResponseAttributes { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + struct AnonymizeUsersResponseAttributesVisitor; + impl<'a> Visitor<'a> for AnonymizeUsersResponseAttributesVisitor { + type Value = AnonymizeUsersResponseAttributes; + + fn expecting(&self, f: &mut Formatter<'_>) -> fmt::Result { + f.write_str("a mapping") + } + + fn visit_map(self, mut map: M) -> Result + where + M: MapAccess<'a>, + { + let mut anonymize_errors: Option> = + None; + let mut anonymized_user_ids: Option> = None; + let mut additional_properties: std::collections::BTreeMap< + String, + serde_json::Value, + > = std::collections::BTreeMap::new(); + let mut _unparsed = false; + + while let Some((k, v)) = map.next_entry::()? { + match k.as_str() { + "anonymize_errors" => { + anonymize_errors = + Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "anonymized_user_ids" => { + anonymized_user_ids = + Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + &_ => { + if let Ok(value) = serde_json::from_value(v.clone()) { + additional_properties.insert(k, value); + } + } + } + } + let anonymize_errors = + anonymize_errors.ok_or_else(|| M::Error::missing_field("anonymize_errors"))?; + let anonymized_user_ids = anonymized_user_ids + .ok_or_else(|| M::Error::missing_field("anonymized_user_ids"))?; + + let content = AnonymizeUsersResponseAttributes { + anonymize_errors, + anonymized_user_ids, + additional_properties, + _unparsed, + }; + + Ok(content) + } + } + + deserializer.deserialize_any(AnonymizeUsersResponseAttributesVisitor) + } +} diff --git a/src/datadogV2/model/model_anonymize_users_response_data.rs b/src/datadogV2/model/model_anonymize_users_response_data.rs new file mode 100644 index 0000000000..1fe9c841fc --- /dev/null +++ b/src/datadogV2/model/model_anonymize_users_response_data.rs @@ -0,0 +1,152 @@ +// 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. +use serde::de::{Error, MapAccess, Visitor}; +use serde::{Deserialize, Deserializer, Serialize}; +use serde_with::skip_serializing_none; +use std::fmt::{self, Formatter}; + +/// Response data for anonymizing users. +#[non_exhaustive] +#[skip_serializing_none] +#[derive(Clone, Debug, PartialEq, Serialize)] +pub struct AnonymizeUsersResponseData { + /// Attributes of an anonymize users response. + #[serde(rename = "attributes")] + pub attributes: Option, + /// Unique identifier of the response. + #[serde(rename = "id")] + pub id: Option, + /// Type of the anonymize users response. + #[serde(rename = "type")] + pub type_: Option, + #[serde(flatten)] + pub additional_properties: std::collections::BTreeMap, + #[serde(skip)] + #[serde(default)] + pub(crate) _unparsed: bool, +} + +impl AnonymizeUsersResponseData { + pub fn new() -> AnonymizeUsersResponseData { + AnonymizeUsersResponseData { + attributes: None, + id: None, + type_: None, + additional_properties: std::collections::BTreeMap::new(), + _unparsed: false, + } + } + + pub fn attributes( + mut self, + value: crate::datadogV2::model::AnonymizeUsersResponseAttributes, + ) -> Self { + self.attributes = Some(value); + self + } + + pub fn id(mut self, value: String) -> Self { + self.id = Some(value); + self + } + + pub fn type_(mut self, value: crate::datadogV2::model::AnonymizeUsersResponseType) -> Self { + self.type_ = Some(value); + self + } + + pub fn additional_properties( + mut self, + value: std::collections::BTreeMap, + ) -> Self { + self.additional_properties = value; + self + } +} + +impl Default for AnonymizeUsersResponseData { + fn default() -> Self { + Self::new() + } +} + +impl<'de> Deserialize<'de> for AnonymizeUsersResponseData { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + struct AnonymizeUsersResponseDataVisitor; + impl<'a> Visitor<'a> for AnonymizeUsersResponseDataVisitor { + type Value = AnonymizeUsersResponseData; + + fn expecting(&self, f: &mut Formatter<'_>) -> fmt::Result { + f.write_str("a mapping") + } + + fn visit_map(self, mut map: M) -> Result + where + M: MapAccess<'a>, + { + let mut attributes: Option< + crate::datadogV2::model::AnonymizeUsersResponseAttributes, + > = None; + let mut id: Option = None; + let mut type_: Option = None; + let mut additional_properties: std::collections::BTreeMap< + String, + serde_json::Value, + > = std::collections::BTreeMap::new(); + let mut _unparsed = false; + + while let Some((k, v)) = map.next_entry::()? { + match k.as_str() { + "attributes" => { + if v.is_null() { + continue; + } + attributes = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "id" => { + if v.is_null() { + continue; + } + id = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "type" => { + if v.is_null() { + continue; + } + type_ = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + if let Some(ref _type_) = type_ { + match _type_ { + crate::datadogV2::model::AnonymizeUsersResponseType::UnparsedObject(_type_) => { + _unparsed = true; + }, + _ => {} + } + } + } + &_ => { + if let Ok(value) = serde_json::from_value(v.clone()) { + additional_properties.insert(k, value); + } + } + } + } + + let content = AnonymizeUsersResponseData { + attributes, + id, + type_, + additional_properties, + _unparsed, + }; + + Ok(content) + } + } + + deserializer.deserialize_any(AnonymizeUsersResponseDataVisitor) + } +} diff --git a/src/datadogV2/model/model_anonymize_users_response_type.rs b/src/datadogV2/model/model_anonymize_users_response_type.rs new file mode 100644 index 0000000000..359699b1b1 --- /dev/null +++ b/src/datadogV2/model/model_anonymize_users_response_type.rs @@ -0,0 +1,48 @@ +// 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. + +use serde::{Deserialize, Deserializer, Serialize, Serializer}; + +#[non_exhaustive] +#[derive(Clone, Debug, Eq, PartialEq)] +pub enum AnonymizeUsersResponseType { + ANONYMIZE_USERS_RESPONSE, + UnparsedObject(crate::datadog::UnparsedObject), +} + +impl ToString for AnonymizeUsersResponseType { + fn to_string(&self) -> String { + match self { + Self::ANONYMIZE_USERS_RESPONSE => String::from("anonymize_users_response"), + Self::UnparsedObject(v) => v.value.to_string(), + } + } +} + +impl Serialize for AnonymizeUsersResponseType { + fn serialize(&self, serializer: S) -> Result + where + S: Serializer, + { + match self { + Self::UnparsedObject(v) => v.serialize(serializer), + _ => serializer.serialize_str(self.to_string().as_str()), + } + } +} + +impl<'de> Deserialize<'de> for AnonymizeUsersResponseType { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + let s: String = String::deserialize(deserializer)?; + Ok(match s.as_str() { + "anonymize_users_response" => Self::ANONYMIZE_USERS_RESPONSE, + _ => Self::UnparsedObject(crate::datadog::UnparsedObject { + value: serde_json::Value::String(s.into()), + }), + }) + } +} diff --git a/tests/scenarios/features/v2/undo.json b/tests/scenarios/features/v2/undo.json index 1f11ffb7e7..1df03bf266 100644 --- a/tests/scenarios/features/v2/undo.json +++ b/tests/scenarios/features/v2/undo.json @@ -362,6 +362,12 @@ "type": "safe" } }, + "AnonymizeUsers": { + "tag": "Users", + "undo": { + "type": "idempotent" + } + }, "ListAPIKeys": { "tag": "Key Management", "undo": { diff --git a/tests/scenarios/features/v2/users.feature b/tests/scenarios/features/v2/users.feature index ce27d72998..bb2f3fb989 100644 --- a/tests/scenarios/features/v2/users.feature +++ b/tests/scenarios/features/v2/users.feature @@ -7,6 +7,22 @@ Feature: Users And a valid "appKeyAuth" key in the system And an instance of "Users" API + @generated @skip @team:DataDog/team-aaa-identity + Scenario: Anonymize users returns "Bad Request" response + Given operation "AnonymizeUsers" enabled + And new "AnonymizeUsers" request + And body with value {"data": {"attributes": {"user_ids": ["00000000-0000-0000-0000-000000000000"]}, "id": "00000000-0000-0000-0000-000000000000", "type": "anonymize_users_request"}} + When the request is sent + Then the response status is 400 Bad Request + + @generated @skip @team:DataDog/team-aaa-identity + Scenario: Anonymize users returns "OK" response + Given operation "AnonymizeUsers" enabled + And new "AnonymizeUsers" request + And body with value {"data": {"attributes": {"user_ids": ["00000000-0000-0000-0000-000000000000"]}, "id": "00000000-0000-0000-0000-000000000000", "type": "anonymize_users_request"}} + When the request is sent + Then the response status is 200 OK + @generated @skip @team:DataDog/team-aaa-identity Scenario: Create a user returns "Bad Request" response Given new "CreateUser" request diff --git a/tests/scenarios/function_mappings.rs b/tests/scenarios/function_mappings.rs index fe44736273..d5213f13d0 100644 --- a/tests/scenarios/function_mappings.rs +++ b/tests/scenarios/function_mappings.rs @@ -53,6 +53,7 @@ pub struct ApiInstances { pub v2_api_actions_datastores: Option, pub v2_api_action_connection: Option, pub v2_api_agentless_scanning: Option, + pub v2_api_users: Option, pub v2_api_key_management: Option, pub v2_api_api_management: Option, pub v2_api_spans_metrics: Option, @@ -182,7 +183,6 @@ pub struct ApiInstances { pub v2_api_synthetics: Option, pub v2_api_teams: Option, pub v2_api_incident_teams: Option, - pub v2_api_users: Option, pub v2_api_widgets: Option, pub v2_api_workflow_automation: Option, @@ -2204,6 +2204,42 @@ pub fn collect_function_calls(world: &mut DatadogWorld) { "v2.GetAwsOnDemandTask".into(), test_v2_get_aws_on_demand_task, ); + world + .function_mappings + .insert("v2.AnonymizeUsers".into(), test_v2_anonymize_users); + world + .function_mappings + .insert("v2.SendInvitations".into(), test_v2_send_invitations); + world + .function_mappings + .insert("v2.GetInvitation".into(), test_v2_get_invitation); + world + .function_mappings + .insert("v2.ListUsers".into(), test_v2_list_users); + world.function_mappings.insert( + "v2.ListUsersWithPagination".into(), + test_v2_list_users_with_pagination, + ); + world + .function_mappings + .insert("v2.CreateUser".into(), test_v2_create_user); + world + .function_mappings + .insert("v2.DisableUser".into(), test_v2_disable_user); + world + .function_mappings + .insert("v2.GetUser".into(), test_v2_get_user); + world + .function_mappings + .insert("v2.UpdateUser".into(), test_v2_update_user); + world.function_mappings.insert( + "v2.ListUserOrganizations".into(), + test_v2_list_user_organizations, + ); + world.function_mappings.insert( + "v2.ListUserPermissions".into(), + test_v2_list_user_permissions, + ); world .function_mappings .insert("v2.ListAPIKeys".into(), test_v2_list_api_keys); @@ -5554,39 +5590,6 @@ pub fn collect_function_calls(world: &mut DatadogWorld) { world .function_mappings .insert("v2.UpdateIncidentTeam".into(), test_v2_update_incident_team); - world - .function_mappings - .insert("v2.SendInvitations".into(), test_v2_send_invitations); - world - .function_mappings - .insert("v2.GetInvitation".into(), test_v2_get_invitation); - world - .function_mappings - .insert("v2.ListUsers".into(), test_v2_list_users); - world.function_mappings.insert( - "v2.ListUsersWithPagination".into(), - test_v2_list_users_with_pagination, - ); - world - .function_mappings - .insert("v2.CreateUser".into(), test_v2_create_user); - world - .function_mappings - .insert("v2.DisableUser".into(), test_v2_disable_user); - world - .function_mappings - .insert("v2.GetUser".into(), test_v2_get_user); - world - .function_mappings - .insert("v2.UpdateUser".into(), test_v2_update_user); - world.function_mappings.insert( - "v2.ListUserOrganizations".into(), - test_v2_list_user_organizations, - ); - world.function_mappings.insert( - "v2.ListUserPermissions".into(), - test_v2_list_user_permissions, - ); world .function_mappings .insert("v2.SearchWidgets".into(), test_v2_search_widgets); @@ -14292,6 +14295,343 @@ fn test_v2_get_aws_on_demand_task(world: &mut DatadogWorld, _parameters: &HashMa world.response.code = response.status.as_u16(); } +fn test_v2_anonymize_users(world: &mut DatadogWorld, _parameters: &HashMap) { + let api = world + .api_instances + .v2_api_users + .as_ref() + .expect("api instance not found"); + let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); + let response = match block_on(api.anonymize_users_with_http_info(body)) { + Ok(response) => response, + Err(error) => { + return match error { + Error::ResponseError(e) => { + world.response.code = e.status.as_u16(); + if let Some(entity) = e.entity { + world.response.object = serde_json::to_value(entity).unwrap(); + } + } + _ => panic!("error parsing response: {error}"), + }; + } + }; + world.response.object = serde_json::to_value(response.entity).unwrap(); + world.response.code = response.status.as_u16(); +} + +fn test_v2_send_invitations(world: &mut DatadogWorld, _parameters: &HashMap) { + let api = world + .api_instances + .v2_api_users + .as_ref() + .expect("api instance not found"); + let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); + let response = match block_on(api.send_invitations_with_http_info(body)) { + Ok(response) => response, + Err(error) => { + return match error { + Error::ResponseError(e) => { + world.response.code = e.status.as_u16(); + if let Some(entity) = e.entity { + world.response.object = serde_json::to_value(entity).unwrap(); + } + } + _ => panic!("error parsing response: {error}"), + }; + } + }; + world.response.object = serde_json::to_value(response.entity).unwrap(); + world.response.code = response.status.as_u16(); +} + +fn test_v2_get_invitation(world: &mut DatadogWorld, _parameters: &HashMap) { + let api = world + .api_instances + .v2_api_users + .as_ref() + .expect("api instance not found"); + let user_invitation_uuid = + serde_json::from_value(_parameters.get("user_invitation_uuid").unwrap().clone()).unwrap(); + let response = match block_on(api.get_invitation_with_http_info(user_invitation_uuid)) { + Ok(response) => response, + Err(error) => { + return match error { + Error::ResponseError(e) => { + world.response.code = e.status.as_u16(); + if let Some(entity) = e.entity { + world.response.object = serde_json::to_value(entity).unwrap(); + } + } + _ => panic!("error parsing response: {error}"), + }; + } + }; + world.response.object = serde_json::to_value(response.entity).unwrap(); + world.response.code = response.status.as_u16(); +} + +fn test_v2_list_users(world: &mut DatadogWorld, _parameters: &HashMap) { + let api = world + .api_instances + .v2_api_users + .as_ref() + .expect("api instance not found"); + let page_size = _parameters + .get("page[size]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let page_number = _parameters + .get("page[number]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let sort = _parameters + .get("sort") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let sort_dir = _parameters + .get("sort_dir") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let filter = _parameters + .get("filter") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let filter_status = _parameters + .get("filter[status]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let mut params = datadogV2::api_users::ListUsersOptionalParams::default(); + params.page_size = page_size; + params.page_number = page_number; + params.sort = sort; + params.sort_dir = sort_dir; + params.filter = filter; + params.filter_status = filter_status; + let response = match block_on(api.list_users_with_http_info(params)) { + Ok(response) => response, + Err(error) => { + return match error { + Error::ResponseError(e) => { + world.response.code = e.status.as_u16(); + if let Some(entity) = e.entity { + world.response.object = serde_json::to_value(entity).unwrap(); + } + } + _ => panic!("error parsing response: {error}"), + }; + } + }; + world.response.object = serde_json::to_value(response.entity).unwrap(); + world.response.code = response.status.as_u16(); +} +fn test_v2_list_users_with_pagination( + world: &mut DatadogWorld, + _parameters: &HashMap, +) { + let api = world + .api_instances + .v2_api_users + .as_ref() + .expect("api instance not found"); + let page_size = _parameters + .get("page[size]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let page_number = _parameters + .get("page[number]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let sort = _parameters + .get("sort") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let sort_dir = _parameters + .get("sort_dir") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let filter = _parameters + .get("filter") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let filter_status = _parameters + .get("filter[status]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let mut params = datadogV2::api_users::ListUsersOptionalParams::default(); + params.page_size = page_size; + params.page_number = page_number; + params.sort = sort; + params.sort_dir = sort_dir; + params.filter = filter; + params.filter_status = filter_status; + let response = api.list_users_with_pagination(params); + let mut result = Vec::new(); + + block_on(async { + pin_mut!(response); + + while let Some(resp) = response.next().await { + match resp { + Ok(response) => { + result.push(response); + } + Err(error) => { + return match error { + Error::ResponseError(e) => { + if let Some(entity) = e.entity { + world.response.object = serde_json::to_value(entity).unwrap(); + } + } + _ => panic!("error parsing response: {}", error), + }; + } + } + } + }); + world.response.object = serde_json::to_value(result).unwrap(); + world.response.code = 200; +} + +fn test_v2_create_user(world: &mut DatadogWorld, _parameters: &HashMap) { + let api = world + .api_instances + .v2_api_users + .as_ref() + .expect("api instance not found"); + let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); + let response = match block_on(api.create_user_with_http_info(body)) { + Ok(response) => response, + Err(error) => { + return match error { + Error::ResponseError(e) => { + world.response.code = e.status.as_u16(); + if let Some(entity) = e.entity { + world.response.object = serde_json::to_value(entity).unwrap(); + } + } + _ => panic!("error parsing response: {error}"), + }; + } + }; + world.response.object = serde_json::to_value(response.entity).unwrap(); + world.response.code = response.status.as_u16(); +} + +fn test_v2_disable_user(world: &mut DatadogWorld, _parameters: &HashMap) { + let api = world + .api_instances + .v2_api_users + .as_ref() + .expect("api instance not found"); + let user_id = serde_json::from_value(_parameters.get("user_id").unwrap().clone()).unwrap(); + let response = match block_on(api.disable_user_with_http_info(user_id)) { + Ok(response) => response, + Err(error) => { + return match error { + Error::ResponseError(e) => { + world.response.code = e.status.as_u16(); + if let Some(entity) = e.entity { + world.response.object = serde_json::to_value(entity).unwrap(); + } + } + _ => panic!("error parsing response: {error}"), + }; + } + }; + world.response.object = serde_json::to_value(response.entity).unwrap(); + world.response.code = response.status.as_u16(); +} + +fn test_v2_get_user(world: &mut DatadogWorld, _parameters: &HashMap) { + let api = world + .api_instances + .v2_api_users + .as_ref() + .expect("api instance not found"); + let user_id = serde_json::from_value(_parameters.get("user_id").unwrap().clone()).unwrap(); + let response = match block_on(api.get_user_with_http_info(user_id)) { + Ok(response) => response, + Err(error) => { + return match error { + Error::ResponseError(e) => { + world.response.code = e.status.as_u16(); + if let Some(entity) = e.entity { + world.response.object = serde_json::to_value(entity).unwrap(); + } + } + _ => panic!("error parsing response: {error}"), + }; + } + }; + world.response.object = serde_json::to_value(response.entity).unwrap(); + world.response.code = response.status.as_u16(); +} + +fn test_v2_update_user(world: &mut DatadogWorld, _parameters: &HashMap) { + let api = world + .api_instances + .v2_api_users + .as_ref() + .expect("api instance not found"); + let user_id = serde_json::from_value(_parameters.get("user_id").unwrap().clone()).unwrap(); + let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); + let response = match block_on(api.update_user_with_http_info(user_id, body)) { + Ok(response) => response, + Err(error) => { + return match error { + Error::ResponseError(e) => { + world.response.code = e.status.as_u16(); + if let Some(entity) = e.entity { + world.response.object = serde_json::to_value(entity).unwrap(); + } + } + _ => panic!("error parsing response: {error}"), + }; + } + }; + world.response.object = serde_json::to_value(response.entity).unwrap(); + world.response.code = response.status.as_u16(); +} + +fn test_v2_list_user_organizations(world: &mut DatadogWorld, _parameters: &HashMap) { + let api = world + .api_instances + .v2_api_users + .as_ref() + .expect("api instance not found"); + let user_id = serde_json::from_value(_parameters.get("user_id").unwrap().clone()).unwrap(); + let response = match block_on(api.list_user_organizations_with_http_info(user_id)) { + Ok(response) => response, + Err(error) => { + return match error { + Error::ResponseError(e) => { + world.response.code = e.status.as_u16(); + if let Some(entity) = e.entity { + world.response.object = serde_json::to_value(entity).unwrap(); + } + } + _ => panic!("error parsing response: {error}"), + }; + } + }; + world.response.object = serde_json::to_value(response.entity).unwrap(); + world.response.code = response.status.as_u16(); +} + +fn test_v2_list_user_permissions(world: &mut DatadogWorld, _parameters: &HashMap) { + let api = world + .api_instances + .v2_api_users + .as_ref() + .expect("api instance not found"); + let user_id = serde_json::from_value(_parameters.get("user_id").unwrap().clone()).unwrap(); + let response = match block_on(api.list_user_permissions_with_http_info(user_id)) { + Ok(response) => response, + Err(error) => { + return match error { + Error::ResponseError(e) => { + world.response.code = e.status.as_u16(); + if let Some(entity) = e.entity { + world.response.object = serde_json::to_value(entity).unwrap(); + } + } + _ => panic!("error parsing response: {error}"), + }; + } + }; + world.response.object = serde_json::to_value(response.entity).unwrap(); + world.response.code = response.status.as_u16(); +} + fn test_v2_list_api_keys(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances @@ -43352,318 +43692,6 @@ fn test_v2_update_incident_team(world: &mut DatadogWorld, _parameters: &HashMap< world.response.code = response.status.as_u16(); } -fn test_v2_send_invitations(world: &mut DatadogWorld, _parameters: &HashMap) { - let api = world - .api_instances - .v2_api_users - .as_ref() - .expect("api instance not found"); - let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); - let response = match block_on(api.send_invitations_with_http_info(body)) { - Ok(response) => response, - Err(error) => { - return match error { - Error::ResponseError(e) => { - world.response.code = e.status.as_u16(); - if let Some(entity) = e.entity { - world.response.object = serde_json::to_value(entity).unwrap(); - } - } - _ => panic!("error parsing response: {error}"), - }; - } - }; - world.response.object = serde_json::to_value(response.entity).unwrap(); - world.response.code = response.status.as_u16(); -} - -fn test_v2_get_invitation(world: &mut DatadogWorld, _parameters: &HashMap) { - let api = world - .api_instances - .v2_api_users - .as_ref() - .expect("api instance not found"); - let user_invitation_uuid = - serde_json::from_value(_parameters.get("user_invitation_uuid").unwrap().clone()).unwrap(); - let response = match block_on(api.get_invitation_with_http_info(user_invitation_uuid)) { - Ok(response) => response, - Err(error) => { - return match error { - Error::ResponseError(e) => { - world.response.code = e.status.as_u16(); - if let Some(entity) = e.entity { - world.response.object = serde_json::to_value(entity).unwrap(); - } - } - _ => panic!("error parsing response: {error}"), - }; - } - }; - world.response.object = serde_json::to_value(response.entity).unwrap(); - world.response.code = response.status.as_u16(); -} - -fn test_v2_list_users(world: &mut DatadogWorld, _parameters: &HashMap) { - let api = world - .api_instances - .v2_api_users - .as_ref() - .expect("api instance not found"); - let page_size = _parameters - .get("page[size]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let page_number = _parameters - .get("page[number]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let sort = _parameters - .get("sort") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let sort_dir = _parameters - .get("sort_dir") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let filter = _parameters - .get("filter") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let filter_status = _parameters - .get("filter[status]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let mut params = datadogV2::api_users::ListUsersOptionalParams::default(); - params.page_size = page_size; - params.page_number = page_number; - params.sort = sort; - params.sort_dir = sort_dir; - params.filter = filter; - params.filter_status = filter_status; - let response = match block_on(api.list_users_with_http_info(params)) { - Ok(response) => response, - Err(error) => { - return match error { - Error::ResponseError(e) => { - world.response.code = e.status.as_u16(); - if let Some(entity) = e.entity { - world.response.object = serde_json::to_value(entity).unwrap(); - } - } - _ => panic!("error parsing response: {error}"), - }; - } - }; - world.response.object = serde_json::to_value(response.entity).unwrap(); - world.response.code = response.status.as_u16(); -} -fn test_v2_list_users_with_pagination( - world: &mut DatadogWorld, - _parameters: &HashMap, -) { - let api = world - .api_instances - .v2_api_users - .as_ref() - .expect("api instance not found"); - let page_size = _parameters - .get("page[size]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let page_number = _parameters - .get("page[number]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let sort = _parameters - .get("sort") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let sort_dir = _parameters - .get("sort_dir") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let filter = _parameters - .get("filter") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let filter_status = _parameters - .get("filter[status]") - .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); - let mut params = datadogV2::api_users::ListUsersOptionalParams::default(); - params.page_size = page_size; - params.page_number = page_number; - params.sort = sort; - params.sort_dir = sort_dir; - params.filter = filter; - params.filter_status = filter_status; - let response = api.list_users_with_pagination(params); - let mut result = Vec::new(); - - block_on(async { - pin_mut!(response); - - while let Some(resp) = response.next().await { - match resp { - Ok(response) => { - result.push(response); - } - Err(error) => { - return match error { - Error::ResponseError(e) => { - if let Some(entity) = e.entity { - world.response.object = serde_json::to_value(entity).unwrap(); - } - } - _ => panic!("error parsing response: {}", error), - }; - } - } - } - }); - world.response.object = serde_json::to_value(result).unwrap(); - world.response.code = 200; -} - -fn test_v2_create_user(world: &mut DatadogWorld, _parameters: &HashMap) { - let api = world - .api_instances - .v2_api_users - .as_ref() - .expect("api instance not found"); - let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); - let response = match block_on(api.create_user_with_http_info(body)) { - Ok(response) => response, - Err(error) => { - return match error { - Error::ResponseError(e) => { - world.response.code = e.status.as_u16(); - if let Some(entity) = e.entity { - world.response.object = serde_json::to_value(entity).unwrap(); - } - } - _ => panic!("error parsing response: {error}"), - }; - } - }; - world.response.object = serde_json::to_value(response.entity).unwrap(); - world.response.code = response.status.as_u16(); -} - -fn test_v2_disable_user(world: &mut DatadogWorld, _parameters: &HashMap) { - let api = world - .api_instances - .v2_api_users - .as_ref() - .expect("api instance not found"); - let user_id = serde_json::from_value(_parameters.get("user_id").unwrap().clone()).unwrap(); - let response = match block_on(api.disable_user_with_http_info(user_id)) { - Ok(response) => response, - Err(error) => { - return match error { - Error::ResponseError(e) => { - world.response.code = e.status.as_u16(); - if let Some(entity) = e.entity { - world.response.object = serde_json::to_value(entity).unwrap(); - } - } - _ => panic!("error parsing response: {error}"), - }; - } - }; - world.response.object = serde_json::to_value(response.entity).unwrap(); - world.response.code = response.status.as_u16(); -} - -fn test_v2_get_user(world: &mut DatadogWorld, _parameters: &HashMap) { - let api = world - .api_instances - .v2_api_users - .as_ref() - .expect("api instance not found"); - let user_id = serde_json::from_value(_parameters.get("user_id").unwrap().clone()).unwrap(); - let response = match block_on(api.get_user_with_http_info(user_id)) { - Ok(response) => response, - Err(error) => { - return match error { - Error::ResponseError(e) => { - world.response.code = e.status.as_u16(); - if let Some(entity) = e.entity { - world.response.object = serde_json::to_value(entity).unwrap(); - } - } - _ => panic!("error parsing response: {error}"), - }; - } - }; - world.response.object = serde_json::to_value(response.entity).unwrap(); - world.response.code = response.status.as_u16(); -} - -fn test_v2_update_user(world: &mut DatadogWorld, _parameters: &HashMap) { - let api = world - .api_instances - .v2_api_users - .as_ref() - .expect("api instance not found"); - let user_id = serde_json::from_value(_parameters.get("user_id").unwrap().clone()).unwrap(); - let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); - let response = match block_on(api.update_user_with_http_info(user_id, body)) { - Ok(response) => response, - Err(error) => { - return match error { - Error::ResponseError(e) => { - world.response.code = e.status.as_u16(); - if let Some(entity) = e.entity { - world.response.object = serde_json::to_value(entity).unwrap(); - } - } - _ => panic!("error parsing response: {error}"), - }; - } - }; - world.response.object = serde_json::to_value(response.entity).unwrap(); - world.response.code = response.status.as_u16(); -} - -fn test_v2_list_user_organizations(world: &mut DatadogWorld, _parameters: &HashMap) { - let api = world - .api_instances - .v2_api_users - .as_ref() - .expect("api instance not found"); - let user_id = serde_json::from_value(_parameters.get("user_id").unwrap().clone()).unwrap(); - let response = match block_on(api.list_user_organizations_with_http_info(user_id)) { - Ok(response) => response, - Err(error) => { - return match error { - Error::ResponseError(e) => { - world.response.code = e.status.as_u16(); - if let Some(entity) = e.entity { - world.response.object = serde_json::to_value(entity).unwrap(); - } - } - _ => panic!("error parsing response: {error}"), - }; - } - }; - world.response.object = serde_json::to_value(response.entity).unwrap(); - world.response.code = response.status.as_u16(); -} - -fn test_v2_list_user_permissions(world: &mut DatadogWorld, _parameters: &HashMap) { - let api = world - .api_instances - .v2_api_users - .as_ref() - .expect("api instance not found"); - let user_id = serde_json::from_value(_parameters.get("user_id").unwrap().clone()).unwrap(); - let response = match block_on(api.list_user_permissions_with_http_info(user_id)) { - Ok(response) => response, - Err(error) => { - return match error { - Error::ResponseError(e) => { - world.response.code = e.status.as_u16(); - if let Some(entity) = e.entity { - world.response.object = serde_json::to_value(entity).unwrap(); - } - } - _ => panic!("error parsing response: {error}"), - }; - } - }; - world.response.object = serde_json::to_value(response.entity).unwrap(); - world.response.code = response.status.as_u16(); -} - fn test_v2_search_widgets(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances