diff --git a/.generator/schemas/v2/openapi.yaml b/.generator/schemas/v2/openapi.yaml index fa9ffba157..e7201e5e9e 100644 --- a/.generator/schemas/v2/openapi.yaml +++ b/.generator/schemas/v2/openapi.yaml @@ -85666,6 +85666,11 @@ components: description: A short name for the schedule. example: Primary On-Call type: string + tags: + description: A list of tags associated with the schedule. + items: + type: string + type: array time_zone: description: The time zone in which this schedule operates. example: America/New_York @@ -85789,6 +85794,231 @@ components: type: string x-enum-varnames: - MEMBERS + ScheduleOnCallResponderData: + description: Represents one position's (previous, current, or next) group of on-call responder shifts. Positions with no matching shift are omitted entirely from the response. + properties: + attributes: + $ref: "#/components/schemas/ScheduleOnCallResponderDataAttributes" + id: + description: Unique identifier of this responder group. + type: string + relationships: + $ref: "#/components/schemas/ScheduleOnCallResponderDataRelationships" + type: + $ref: "#/components/schemas/ScheduleOnCallResponderDataType" + required: + - type + type: object + ScheduleOnCallResponderDataAttributes: + description: Attributes for one position's (previous, current, or next) group of on-call responder shifts. + properties: + position: + $ref: "#/components/schemas/ScheduleTargetPosition" + type: object + ScheduleOnCallResponderDataRelationships: + description: Relationships for a single position's (previous, current, or next) responder group. + properties: + shifts: + $ref: "#/components/schemas/ScheduleOnCallResponderDataRelationshipsShifts" + type: object + ScheduleOnCallResponderDataRelationshipsShifts: + description: Defines the list of shifts satisfying this responder group's position. Multiple shifts occur when a schedule has multiple concurrent on-call responders at that position. + properties: + data: + description: Array of references to the shifts included in the response. + items: + $ref: "#/components/schemas/ScheduleOnCallResponderDataRelationshipsShiftsDataItems" + type: array + type: object + ScheduleOnCallResponderDataRelationshipsShiftsDataItems: + description: Represents a reference to one of the shifts satisfying this responder group's position. + properties: + id: + description: Unique identifier of the shift. + example: "00000000-0000-0000-0000-000000000000" + type: string + type: + $ref: "#/components/schemas/ScheduleOnCallResponderDataRelationshipsShiftsDataItemsType" + required: + - type + - id + type: object + ScheduleOnCallResponderDataRelationshipsShiftsDataItemsType: + default: shifts + description: "Indicates that the related resource is of type `shifts`." + enum: + - shifts + example: shifts + type: string + x-enum-varnames: + - SHIFTS + ScheduleOnCallResponderDataType: + default: schedule_oncall_responder + description: Represents the resource type for a single position's (previous, current, or next) group of on-call responder shifts. + enum: + - schedule_oncall_responder + example: schedule_oncall_responder + type: string + x-enum-varnames: + - SCHEDULE_ONCALL_RESPONDER + ScheduleOnCallResponders: + description: Root object representing a schedule's on-call responders, grouped by position (previous, current, next), for a given point in time. + example: + data: + attributes: + scheduled_at: "2024-05-07T02:53:01.000000000Z" + id: "3653d3c6-0c75-11ea-ad28-fb5701eabc7d-1715054400" + relationships: + responders: + data: + - id: "3653d3c6-0c75-11ea-ad28-fb5701eabc7d-1715054400-current" + type: schedule_oncall_responder + schedule: + data: + id: 3653d3c6-0c75-11ea-ad28-fb5701eabc7d + type: schedules + type: schedule_oncall_responders + included: + - attributes: + position: current + id: "3653d3c6-0c75-11ea-ad28-fb5701eabc7d-1715054400-current" + relationships: + shifts: + data: + - id: 00000000-0000-0000-0000-000000000000 + type: shifts + type: schedule_oncall_responder + - attributes: + end: "2024-05-08T02:53:01.000000000Z" + start: "2024-05-07T02:53:01.000000000Z" + id: 00000000-0000-0000-0000-000000000000 + relationships: + user: + data: + id: 00000000-aba1-0000-0000-000000000000 + type: users + type: shifts + - attributes: + email: test@test.com + name: Test User + status: active + id: 00000000-aba1-0000-0000-000000000000 + type: users + properties: + data: + $ref: "#/components/schemas/ScheduleOnCallRespondersData" + included: + description: Related resources referenced in the responder groups' relationships, such as shifts, schedules, and users. + items: + $ref: "#/components/schemas/ScheduleOnCallRespondersIncluded" + type: array + type: object + ScheduleOnCallRespondersData: + description: The main data object representing a schedule's on-call responders lookup, including relationships and metadata. + properties: + attributes: + $ref: "#/components/schemas/ScheduleOnCallRespondersDataAttributes" + id: + description: Unique identifier of this on-call responders lookup. + type: string + relationships: + $ref: "#/components/schemas/ScheduleOnCallRespondersDataRelationships" + type: + $ref: "#/components/schemas/ScheduleOnCallRespondersDataType" + required: + - type + type: object + ScheduleOnCallRespondersDataAttributes: + description: Attributes for a schedule's on-call responders lookup. + properties: + scheduled_at: + description: The timestamp the responders were resolved at. + format: date-time + type: string + type: object + ScheduleOnCallRespondersDataRelationships: + description: Relationships for a schedule's on-call responders lookup, including the schedule and its responder groups. + properties: + responders: + $ref: "#/components/schemas/ScheduleOnCallRespondersDataRelationshipsResponders" + schedule: + $ref: "#/components/schemas/ScheduleOnCallRespondersDataRelationshipsSchedule" + type: object + ScheduleOnCallRespondersDataRelationshipsResponders: + description: Defines the list of per-position (previous, current, next) responder groups for the schedule. + properties: + data: + description: Array of references to the responder groups included in the response. + items: + $ref: "#/components/schemas/ScheduleOnCallRespondersDataRelationshipsRespondersDataItems" + type: array + type: object + ScheduleOnCallRespondersDataRelationshipsRespondersDataItems: + description: Represents a reference to one position's (previous, current, or next) responder group. + properties: + id: + description: Unique identifier of the responder group. + example: "" + type: string + type: + $ref: "#/components/schemas/ScheduleOnCallRespondersDataRelationshipsRespondersDataItemsType" + required: + - type + - id + type: object + ScheduleOnCallRespondersDataRelationshipsRespondersDataItemsType: + default: schedule_oncall_responder + description: Identifies the resource type for a responder group linked to a schedule's on-call responders lookup. + enum: + - schedule_oncall_responder + example: schedule_oncall_responder + type: string + x-enum-varnames: + - SCHEDULE_ONCALL_RESPONDER + ScheduleOnCallRespondersDataRelationshipsSchedule: + description: Defines the relationship to the schedule this on-call responders lookup was performed for. + properties: + data: + $ref: "#/components/schemas/ScheduleOnCallRespondersDataRelationshipsScheduleData" + type: object + ScheduleOnCallRespondersDataRelationshipsScheduleData: + description: Represents a reference to the schedule this on-call responders lookup was performed for. + properties: + id: + description: Unique identifier of the schedule. + example: "3653d3c6-0c75-11ea-ad28-fb5701eabc7d" + type: string + type: + $ref: "#/components/schemas/ScheduleOnCallRespondersDataRelationshipsScheduleDataType" + required: + - type + - id + type: object + ScheduleOnCallRespondersDataRelationshipsScheduleDataType: + default: schedules + description: Identifies the resource type for the schedule associated with this on-call responders lookup. + enum: + - schedules + example: schedules + type: string + x-enum-varnames: + - SCHEDULES + ScheduleOnCallRespondersDataType: + default: schedule_oncall_responders + description: Represents the resource type for a schedule's grouped on-call responders across the previous, current, and next positions. + enum: + - schedule_oncall_responders + example: schedule_oncall_responders + type: string + x-enum-varnames: + - SCHEDULE_ONCALL_RESPONDERS + ScheduleOnCallRespondersIncluded: + description: Represents a union of related resources included in the response, such as responder groups, shifts, schedules, and users. + oneOf: + - $ref: "#/components/schemas/ScheduleOnCallResponderData" + - $ref: "#/components/schemas/ShiftData" + - $ref: "#/components/schemas/ScheduleData" + - $ref: "#/components/schemas/User" ScheduleRequestDataAttributesLayersItemsMembersItems: description: |- Defines a single member within a schedule layer, including the reference to the underlying user. @@ -160912,7 +161142,8 @@ paths: - on_call_write /api/v2/on-call/schedules/{schedule_id}/on-call: get: - description: "Retrieves the user who is on-call for the specified schedule at a given time." + deprecated: true + description: "Retrieves the user who is on-call for the specified schedule at a given time. This endpoint does not support schedules with multiple concurrent on-call responders at a position. Deprecated. Use `Get on-call responders for a schedule` instead." operationId: GetScheduleOnCallUser parameters: - description: "Specifies related resources to include in the response as a comma-separated list. Allowed value: `user`." @@ -160975,6 +161206,101 @@ paths: operator: AND permissions: - on_call_read + x-sunset: "2027-02-01" + /api/v2/on-call/schedules/{schedule_id}/responders: + get: + description: "Retrieves the on-call responders for the specified schedule, grouped by position (previous, current, next), at a given time. Supports schedules with multiple concurrent on-call responders at a position, by returning a list of shifts per position." + operationId: GetScheduleOnCallResponders + parameters: + - description: "Comma-separated list of included relationships to be returned. Allowed values: `schedule`, `responders`, `responders.shifts`, `responders.shifts.user`." + in: query + name: include + schema: + type: string + - description: The ID of the schedule. + in: path + name: schedule_id + required: true + schema: + example: 3653d3c6-0c75-11ea-ad28-fb5701eabc7d + type: string + - description: "Comma-separated list of positions to retrieve. Allowed values: `previous`, `current`, `next`. Defaults to `current` if omitted." + in: query + name: filter[position] + schema: + example: previous,current,next + type: string + - description: "Retrieves the on-call responders at the given timestamp in RFC3339 format (for example, `2025-05-07T02:53:01Z` or `2025-05-07T02:53:01+00:00`). When using timezone offsets with `+` or `-`, ensure proper URL encoding (`+` should be encoded as `%2B`). Defaults to the current time if omitted." + in: query + name: filter[at_ts] + schema: + example: "2025-05-07T02:53:01Z" + type: string + responses: + "200": + content: + application/json: + examples: + default: + value: + data: + attributes: + scheduled_at: "2024-05-07T02:53:01.000000000Z" + id: "3653d3c6-0c75-11ea-ad28-fb5701eabc7d-1715054400" + relationships: + responders: + data: + - id: "3653d3c6-0c75-11ea-ad28-fb5701eabc7d-1715054400-current" + type: schedule_oncall_responder + schedule: + data: + id: 3653d3c6-0c75-11ea-ad28-fb5701eabc7d + type: schedules + type: schedule_oncall_responders + included: + - attributes: + position: current + id: "3653d3c6-0c75-11ea-ad28-fb5701eabc7d-1715054400-current" + relationships: + shifts: + data: + - id: 00000000-0000-0000-0000-000000000000 + type: shifts + type: schedule_oncall_responder + - attributes: + end: "2024-05-08T02:53:01.000000000Z" + start: "2024-05-07T02:53:01.000000000Z" + id: 00000000-0000-0000-0000-000000000000 + relationships: + user: + data: + id: 00000000-aba1-0000-0000-000000000000 + type: users + type: shifts + schema: + $ref: "#/components/schemas/ScheduleOnCallResponders" + description: OK + "400": + $ref: "#/components/responses/BadRequestResponse" + "401": + $ref: "#/components/responses/UnauthorizedResponse" + "403": + $ref: "#/components/responses/ForbiddenResponse" + "404": + $ref: "#/components/responses/NotFoundResponse" + "429": + $ref: "#/components/responses/TooManyRequestsResponse" + security: + - apiKeyAuth: [] + appKeyAuth: [] + - AuthZ: [] + summary: Get on-call responders for a schedule + tags: + - On-Call + "x-permission": + operator: AND + permissions: + - on_call_read /api/v2/on-call/teams/{team_id}/on-call: get: description: Get a team's on-call users at a given time diff --git a/examples/v2_on-call_GetScheduleOnCallResponders.rs b/examples/v2_on-call_GetScheduleOnCallResponders.rs new file mode 100644 index 0000000000..21127cf0ee --- /dev/null +++ b/examples/v2_on-call_GetScheduleOnCallResponders.rs @@ -0,0 +1,23 @@ +// Get on-call responders for a schedule returns "OK" response +use datadog_api_client::datadog; +use datadog_api_client::datadogV2::api_on_call::GetScheduleOnCallRespondersOptionalParams; +use datadog_api_client::datadogV2::api_on_call::OnCallAPI; + +#[tokio::main] +async fn main() { + // there is a valid "schedule" in the system + let schedule_data_id = std::env::var("SCHEDULE_DATA_ID").unwrap(); + let configuration = datadog::Configuration::new(); + let api = OnCallAPI::with_config(configuration); + let resp = api + .get_schedule_on_call_responders( + schedule_data_id.clone(), + GetScheduleOnCallRespondersOptionalParams::default(), + ) + .await; + if let Ok(value) = resp { + println!("{:#?}", value); + } else { + println!("{:#?}", resp.unwrap_err()); + } +} diff --git a/src/datadogV2/api/api_on_call.rs b/src/datadogV2/api/api_on_call.rs index a5989696d2..91fa23789c 100644 --- a/src/datadogV2/api/api_on_call.rs +++ b/src/datadogV2/api/api_on_call.rs @@ -90,6 +90,36 @@ impl GetOnCallTeamRoutingRulesOptionalParams { } } +/// GetScheduleOnCallRespondersOptionalParams is a struct for passing parameters to the method [`OnCallAPI::get_schedule_on_call_responders`] +#[non_exhaustive] +#[derive(Clone, Default, Debug)] +pub struct GetScheduleOnCallRespondersOptionalParams { + /// Comma-separated list of included relationships to be returned. Allowed values: `schedule`, `responders`, `responders.shifts`, `responders.shifts.user`. + pub include: Option, + /// Comma-separated list of positions to retrieve. Allowed values: `previous`, `current`, `next`. Defaults to `current` if omitted. + pub filter_position: Option, + /// Retrieves the on-call responders at the given timestamp in RFC3339 format (for example, `2025-05-07T02:53:01Z` or `2025-05-07T02:53:01+00:00`). When using timezone offsets with `+` or `-`, ensure proper URL encoding (`+` should be encoded as `%2B`). Defaults to the current time if omitted. + pub filter_at_ts: Option, +} + +impl GetScheduleOnCallRespondersOptionalParams { + /// Comma-separated list of included relationships to be returned. Allowed values: `schedule`, `responders`, `responders.shifts`, `responders.shifts.user`. + pub fn include(mut self, value: String) -> Self { + self.include = Some(value); + self + } + /// Comma-separated list of positions to retrieve. Allowed values: `previous`, `current`, `next`. Defaults to `current` if omitted. + pub fn filter_position(mut self, value: String) -> Self { + self.filter_position = Some(value); + self + } + /// Retrieves the on-call responders at the given timestamp in RFC3339 format (for example, `2025-05-07T02:53:01Z` or `2025-05-07T02:53:01+00:00`). When using timezone offsets with `+` or `-`, ensure proper URL encoding (`+` should be encoded as `%2B`). Defaults to the current time if omitted. + pub fn filter_at_ts(mut self, value: String) -> Self { + self.filter_at_ts = Some(value); + self + } +} + /// GetScheduleOnCallUserOptionalParams is a struct for passing parameters to the method [`OnCallAPI::get_schedule_on_call_user`] #[non_exhaustive] #[derive(Clone, Default, Debug)] @@ -313,6 +343,14 @@ pub enum GetOnCallTeamRoutingRulesError { UnknownValue(serde_json::Value), } +/// GetScheduleOnCallRespondersError is a struct for typed errors of method [`OnCallAPI::get_schedule_on_call_responders`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum GetScheduleOnCallRespondersError { + APIErrorResponse(crate::datadogV2::model::APIErrorResponse), + UnknownValue(serde_json::Value), +} + /// GetScheduleOnCallUserError is a struct for typed errors of method [`OnCallAPI::get_schedule_on_call_user`] #[derive(Debug, Clone, Serialize, Deserialize)] #[serde(untagged)] @@ -1851,7 +1889,139 @@ impl OnCallAPI { } } - /// Retrieves the user who is on-call for the specified schedule at a given time. + /// Retrieves the on-call responders for the specified schedule, grouped by position (previous, current, next), at a given time. Supports schedules with multiple concurrent on-call responders at a position, by returning a list of shifts per position. + pub async fn get_schedule_on_call_responders( + &self, + schedule_id: String, + params: GetScheduleOnCallRespondersOptionalParams, + ) -> Result< + crate::datadogV2::model::ScheduleOnCallResponders, + datadog::Error, + > { + match self + .get_schedule_on_call_responders_with_http_info(schedule_id, params) + .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), + } + } + + /// Retrieves the on-call responders for the specified schedule, grouped by position (previous, current, next), at a given time. Supports schedules with multiple concurrent on-call responders at a position, by returning a list of shifts per position. + pub async fn get_schedule_on_call_responders_with_http_info( + &self, + schedule_id: String, + params: GetScheduleOnCallRespondersOptionalParams, + ) -> Result< + datadog::ResponseContent, + datadog::Error, + > { + let local_configuration = &self.config; + let operation_id = "v2.get_schedule_on_call_responders"; + + // unbox and build optional parameters + let include = params.include; + let filter_position = params.filter_position; + let filter_at_ts = params.filter_at_ts; + + let local_client = &self.client; + + let local_uri_str = format!( + "{}/api/v2/on-call/schedules/{schedule_id}/responders", + local_configuration.get_operation_host(operation_id), + schedule_id = datadog::urlencode(schedule_id) + ); + let mut local_req_builder = + local_client.request(reqwest::Method::GET, local_uri_str.as_str()); + + if let Some(ref local_query_param) = include { + local_req_builder = + local_req_builder.query(&[("include", &local_query_param.to_string())]); + }; + if let Some(ref local_query_param) = filter_position { + local_req_builder = + local_req_builder.query(&[("filter[position]", &local_query_param.to_string())]); + }; + if let Some(ref local_query_param) = filter_at_ts { + local_req_builder = + local_req_builder.query(&[("filter[at_ts]", &local_query_param.to_string())]); + }; + + // build headers + let mut headers = HeaderMap::new(); + 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"), + ); + }; + + 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)) + } + } + + /// Retrieves the user who is on-call for the specified schedule at a given time. This endpoint does not support schedules with multiple concurrent on-call responders at a position. Deprecated. Use `Get on-call responders for a schedule` instead. pub async fn get_schedule_on_call_user( &self, schedule_id: String, @@ -1874,7 +2044,7 @@ impl OnCallAPI { } } - /// Retrieves the user who is on-call for the specified schedule at a given time. + /// Retrieves the user who is on-call for the specified schedule at a given time. This endpoint does not support schedules with multiple concurrent on-call responders at a position. Deprecated. Use `Get on-call responders for a schedule` instead. pub async fn get_schedule_on_call_user_with_http_info( &self, schedule_id: String, diff --git a/src/datadogV2/model/mod.rs b/src/datadogV2/model/mod.rs index 9e8c535d63..b1389ef0ac 100644 --- a/src/datadogV2/model/mod.rs +++ b/src/datadogV2/model/mod.rs @@ -8044,6 +8044,44 @@ pub mod model_shift_data_type; pub use self::model_shift_data_type::ShiftDataType; pub mod model_shift_included; pub use self::model_shift_included::ShiftIncluded; +pub mod model_schedule_on_call_responders; +pub use self::model_schedule_on_call_responders::ScheduleOnCallResponders; +pub mod model_schedule_on_call_responders_data; +pub use self::model_schedule_on_call_responders_data::ScheduleOnCallRespondersData; +pub mod model_schedule_on_call_responders_data_attributes; +pub use self::model_schedule_on_call_responders_data_attributes::ScheduleOnCallRespondersDataAttributes; +pub mod model_schedule_on_call_responders_data_relationships; +pub use self::model_schedule_on_call_responders_data_relationships::ScheduleOnCallRespondersDataRelationships; +pub mod model_schedule_on_call_responders_data_relationships_responders; +pub use self::model_schedule_on_call_responders_data_relationships_responders::ScheduleOnCallRespondersDataRelationshipsResponders; +pub mod model_schedule_on_call_responders_data_relationships_responders_data_items; +pub use self::model_schedule_on_call_responders_data_relationships_responders_data_items::ScheduleOnCallRespondersDataRelationshipsRespondersDataItems; +pub mod model_schedule_on_call_responders_data_relationships_responders_data_items_type; +pub use self::model_schedule_on_call_responders_data_relationships_responders_data_items_type::ScheduleOnCallRespondersDataRelationshipsRespondersDataItemsType; +pub mod model_schedule_on_call_responders_data_relationships_schedule; +pub use self::model_schedule_on_call_responders_data_relationships_schedule::ScheduleOnCallRespondersDataRelationshipsSchedule; +pub mod model_schedule_on_call_responders_data_relationships_schedule_data; +pub use self::model_schedule_on_call_responders_data_relationships_schedule_data::ScheduleOnCallRespondersDataRelationshipsScheduleData; +pub mod model_schedule_on_call_responders_data_relationships_schedule_data_type; +pub use self::model_schedule_on_call_responders_data_relationships_schedule_data_type::ScheduleOnCallRespondersDataRelationshipsScheduleDataType; +pub mod model_schedule_on_call_responders_data_type; +pub use self::model_schedule_on_call_responders_data_type::ScheduleOnCallRespondersDataType; +pub mod model_schedule_on_call_responder_data; +pub use self::model_schedule_on_call_responder_data::ScheduleOnCallResponderData; +pub mod model_schedule_on_call_responder_data_attributes; +pub use self::model_schedule_on_call_responder_data_attributes::ScheduleOnCallResponderDataAttributes; +pub mod model_schedule_on_call_responder_data_relationships; +pub use self::model_schedule_on_call_responder_data_relationships::ScheduleOnCallResponderDataRelationships; +pub mod model_schedule_on_call_responder_data_relationships_shifts; +pub use self::model_schedule_on_call_responder_data_relationships_shifts::ScheduleOnCallResponderDataRelationshipsShifts; +pub mod model_schedule_on_call_responder_data_relationships_shifts_data_items; +pub use self::model_schedule_on_call_responder_data_relationships_shifts_data_items::ScheduleOnCallResponderDataRelationshipsShiftsDataItems; +pub mod model_schedule_on_call_responder_data_relationships_shifts_data_items_type; +pub use self::model_schedule_on_call_responder_data_relationships_shifts_data_items_type::ScheduleOnCallResponderDataRelationshipsShiftsDataItemsType; +pub mod model_schedule_on_call_responder_data_type; +pub use self::model_schedule_on_call_responder_data_type::ScheduleOnCallResponderDataType; +pub mod model_schedule_on_call_responders_included; +pub use self::model_schedule_on_call_responders_included::ScheduleOnCallRespondersIncluded; pub mod model_team_on_call_responders; pub use self::model_team_on_call_responders::TeamOnCallResponders; pub mod model_team_on_call_responders_data; diff --git a/src/datadogV2/model/model_schedule_data_attributes.rs b/src/datadogV2/model/model_schedule_data_attributes.rs index d394c353f7..31b9c2f0a8 100644 --- a/src/datadogV2/model/model_schedule_data_attributes.rs +++ b/src/datadogV2/model/model_schedule_data_attributes.rs @@ -14,6 +14,9 @@ pub struct ScheduleDataAttributes { /// A short name for the schedule. #[serde(rename = "name")] pub name: Option, + /// A list of tags associated with the schedule. + #[serde(rename = "tags")] + pub tags: Option>, /// The time zone in which this schedule operates. #[serde(rename = "time_zone")] pub time_zone: Option, @@ -28,6 +31,7 @@ impl ScheduleDataAttributes { pub fn new() -> ScheduleDataAttributes { ScheduleDataAttributes { name: None, + tags: None, time_zone: None, additional_properties: std::collections::BTreeMap::new(), _unparsed: false, @@ -39,6 +43,11 @@ impl ScheduleDataAttributes { self } + pub fn tags(mut self, value: Vec) -> Self { + self.tags = Some(value); + self + } + pub fn time_zone(mut self, value: String) -> Self { self.time_zone = Some(value); self @@ -77,6 +86,7 @@ impl<'de> Deserialize<'de> for ScheduleDataAttributes { M: MapAccess<'a>, { let mut name: Option = None; + let mut tags: Option> = None; let mut time_zone: Option = None; let mut additional_properties: std::collections::BTreeMap< String, @@ -92,6 +102,12 @@ impl<'de> Deserialize<'de> for ScheduleDataAttributes { } name = Some(serde_json::from_value(v).map_err(M::Error::custom)?); } + "tags" => { + if v.is_null() { + continue; + } + tags = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } "time_zone" => { if v.is_null() { continue; @@ -108,6 +124,7 @@ impl<'de> Deserialize<'de> for ScheduleDataAttributes { let content = ScheduleDataAttributes { name, + tags, time_zone, additional_properties, _unparsed, diff --git a/src/datadogV2/model/model_schedule_on_call_responder_data.rs b/src/datadogV2/model/model_schedule_on_call_responder_data.rs new file mode 100644 index 0000000000..f07510e747 --- /dev/null +++ b/src/datadogV2/model/model_schedule_on_call_responder_data.rs @@ -0,0 +1,165 @@ +// 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}; + +/// Represents one position's (previous, current, or next) group of on-call responder shifts. Positions with no matching shift are omitted entirely from the response. +#[non_exhaustive] +#[skip_serializing_none] +#[derive(Clone, Debug, PartialEq, Serialize)] +pub struct ScheduleOnCallResponderData { + /// Attributes for one position's (previous, current, or next) group of on-call responder shifts. + #[serde(rename = "attributes")] + pub attributes: Option, + /// Unique identifier of this responder group. + #[serde(rename = "id")] + pub id: Option, + /// Relationships for a single position's (previous, current, or next) responder group. + #[serde(rename = "relationships")] + pub relationships: Option, + /// Represents the resource type for a single position's (previous, current, or next) group of on-call responder shifts. + #[serde(rename = "type")] + pub type_: crate::datadogV2::model::ScheduleOnCallResponderDataType, + #[serde(flatten)] + pub additional_properties: std::collections::BTreeMap, + #[serde(skip)] + #[serde(default)] + pub(crate) _unparsed: bool, +} + +impl ScheduleOnCallResponderData { + pub fn new( + type_: crate::datadogV2::model::ScheduleOnCallResponderDataType, + ) -> ScheduleOnCallResponderData { + ScheduleOnCallResponderData { + attributes: None, + id: None, + relationships: None, + type_, + additional_properties: std::collections::BTreeMap::new(), + _unparsed: false, + } + } + + pub fn attributes( + mut self, + value: crate::datadogV2::model::ScheduleOnCallResponderDataAttributes, + ) -> Self { + self.attributes = Some(value); + self + } + + pub fn id(mut self, value: String) -> Self { + self.id = Some(value); + self + } + + pub fn relationships( + mut self, + value: crate::datadogV2::model::ScheduleOnCallResponderDataRelationships, + ) -> Self { + self.relationships = Some(value); + self + } + + pub fn additional_properties( + mut self, + value: std::collections::BTreeMap, + ) -> Self { + self.additional_properties = value; + self + } +} + +impl<'de> Deserialize<'de> for ScheduleOnCallResponderData { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + struct ScheduleOnCallResponderDataVisitor; + impl<'a> Visitor<'a> for ScheduleOnCallResponderDataVisitor { + type Value = ScheduleOnCallResponderData; + + 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::ScheduleOnCallResponderDataAttributes, + > = None; + let mut id: Option = None; + let mut relationships: Option< + crate::datadogV2::model::ScheduleOnCallResponderDataRelationships, + > = 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)?); + } + "relationships" => { + if v.is_null() { + continue; + } + relationships = + 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::ScheduleOnCallResponderDataType::UnparsedObject(_type_) => { + _unparsed = true; + }, + _ => {} + } + } + } + &_ => { + if let Ok(value) = serde_json::from_value(v.clone()) { + additional_properties.insert(k, value); + } + } + } + } + let type_ = type_.ok_or_else(|| M::Error::missing_field("type_"))?; + + let content = ScheduleOnCallResponderData { + attributes, + id, + relationships, + type_, + additional_properties, + _unparsed, + }; + + Ok(content) + } + } + + deserializer.deserialize_any(ScheduleOnCallResponderDataVisitor) + } +} diff --git a/src/datadogV2/model/model_schedule_on_call_responder_data_attributes.rs b/src/datadogV2/model/model_schedule_on_call_responder_data_attributes.rs new file mode 100644 index 0000000000..645490ff46 --- /dev/null +++ b/src/datadogV2/model/model_schedule_on_call_responder_data_attributes.rs @@ -0,0 +1,113 @@ +// 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 for one position's (previous, current, or next) group of on-call responder shifts. +#[non_exhaustive] +#[skip_serializing_none] +#[derive(Clone, Debug, PartialEq, Serialize)] +pub struct ScheduleOnCallResponderDataAttributes { + /// Specifies the position of a schedule target (example `previous`, `current`, or `next`). + #[serde(rename = "position")] + pub position: Option, + #[serde(flatten)] + pub additional_properties: std::collections::BTreeMap, + #[serde(skip)] + #[serde(default)] + pub(crate) _unparsed: bool, +} + +impl ScheduleOnCallResponderDataAttributes { + pub fn new() -> ScheduleOnCallResponderDataAttributes { + ScheduleOnCallResponderDataAttributes { + position: None, + additional_properties: std::collections::BTreeMap::new(), + _unparsed: false, + } + } + + pub fn position(mut self, value: crate::datadogV2::model::ScheduleTargetPosition) -> Self { + self.position = Some(value); + self + } + + pub fn additional_properties( + mut self, + value: std::collections::BTreeMap, + ) -> Self { + self.additional_properties = value; + self + } +} + +impl Default for ScheduleOnCallResponderDataAttributes { + fn default() -> Self { + Self::new() + } +} + +impl<'de> Deserialize<'de> for ScheduleOnCallResponderDataAttributes { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + struct ScheduleOnCallResponderDataAttributesVisitor; + impl<'a> Visitor<'a> for ScheduleOnCallResponderDataAttributesVisitor { + type Value = ScheduleOnCallResponderDataAttributes; + + 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 position: 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() { + "position" => { + if v.is_null() { + continue; + } + position = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + if let Some(ref _position) = position { + match _position { + crate::datadogV2::model::ScheduleTargetPosition::UnparsedObject(_position) => { + _unparsed = true; + }, + _ => {} + } + } + } + &_ => { + if let Ok(value) = serde_json::from_value(v.clone()) { + additional_properties.insert(k, value); + } + } + } + } + + let content = ScheduleOnCallResponderDataAttributes { + position, + additional_properties, + _unparsed, + }; + + Ok(content) + } + } + + deserializer.deserialize_any(ScheduleOnCallResponderDataAttributesVisitor) + } +} diff --git a/src/datadogV2/model/model_schedule_on_call_responder_data_relationships.rs b/src/datadogV2/model/model_schedule_on_call_responder_data_relationships.rs new file mode 100644 index 0000000000..5d40f8a178 --- /dev/null +++ b/src/datadogV2/model/model_schedule_on_call_responder_data_relationships.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}; + +/// Relationships for a single position's (previous, current, or next) responder group. +#[non_exhaustive] +#[skip_serializing_none] +#[derive(Clone, Debug, PartialEq, Serialize)] +pub struct ScheduleOnCallResponderDataRelationships { + /// Defines the list of shifts satisfying this responder group's position. Multiple shifts occur when a schedule has multiple concurrent on-call responders at that position. + #[serde(rename = "shifts")] + pub shifts: Option, + #[serde(flatten)] + pub additional_properties: std::collections::BTreeMap, + #[serde(skip)] + #[serde(default)] + pub(crate) _unparsed: bool, +} + +impl ScheduleOnCallResponderDataRelationships { + pub fn new() -> ScheduleOnCallResponderDataRelationships { + ScheduleOnCallResponderDataRelationships { + shifts: None, + additional_properties: std::collections::BTreeMap::new(), + _unparsed: false, + } + } + + pub fn shifts( + mut self, + value: crate::datadogV2::model::ScheduleOnCallResponderDataRelationshipsShifts, + ) -> Self { + self.shifts = Some(value); + self + } + + pub fn additional_properties( + mut self, + value: std::collections::BTreeMap, + ) -> Self { + self.additional_properties = value; + self + } +} + +impl Default for ScheduleOnCallResponderDataRelationships { + fn default() -> Self { + Self::new() + } +} + +impl<'de> Deserialize<'de> for ScheduleOnCallResponderDataRelationships { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + struct ScheduleOnCallResponderDataRelationshipsVisitor; + impl<'a> Visitor<'a> for ScheduleOnCallResponderDataRelationshipsVisitor { + type Value = ScheduleOnCallResponderDataRelationships; + + 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 shifts: Option< + crate::datadogV2::model::ScheduleOnCallResponderDataRelationshipsShifts, + > = 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() { + "shifts" => { + if v.is_null() { + continue; + } + shifts = 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 = ScheduleOnCallResponderDataRelationships { + shifts, + additional_properties, + _unparsed, + }; + + Ok(content) + } + } + + deserializer.deserialize_any(ScheduleOnCallResponderDataRelationshipsVisitor) + } +} diff --git a/src/datadogV2/model/model_schedule_on_call_responder_data_relationships_shifts.rs b/src/datadogV2/model/model_schedule_on_call_responder_data_relationships_shifts.rs new file mode 100644 index 0000000000..03937f26f7 --- /dev/null +++ b/src/datadogV2/model/model_schedule_on_call_responder_data_relationships_shifts.rs @@ -0,0 +1,112 @@ +// 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}; + +/// Defines the list of shifts satisfying this responder group's position. Multiple shifts occur when a schedule has multiple concurrent on-call responders at that position. +#[non_exhaustive] +#[skip_serializing_none] +#[derive(Clone, Debug, PartialEq, Serialize)] +pub struct ScheduleOnCallResponderDataRelationshipsShifts { + /// Array of references to the shifts included in the response. + #[serde(rename = "data")] + pub data: Option< + Vec, + >, + #[serde(flatten)] + pub additional_properties: std::collections::BTreeMap, + #[serde(skip)] + #[serde(default)] + pub(crate) _unparsed: bool, +} + +impl ScheduleOnCallResponderDataRelationshipsShifts { + pub fn new() -> ScheduleOnCallResponderDataRelationshipsShifts { + ScheduleOnCallResponderDataRelationshipsShifts { + data: None, + additional_properties: std::collections::BTreeMap::new(), + _unparsed: false, + } + } + + pub fn data( + mut self, + value: Vec< + crate::datadogV2::model::ScheduleOnCallResponderDataRelationshipsShiftsDataItems, + >, + ) -> 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 ScheduleOnCallResponderDataRelationshipsShifts { + fn default() -> Self { + Self::new() + } +} + +impl<'de> Deserialize<'de> for ScheduleOnCallResponderDataRelationshipsShifts { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + struct ScheduleOnCallResponderDataRelationshipsShiftsVisitor; + impl<'a> Visitor<'a> for ScheduleOnCallResponderDataRelationshipsShiftsVisitor { + type Value = ScheduleOnCallResponderDataRelationshipsShifts; + + 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 = ScheduleOnCallResponderDataRelationshipsShifts { + data, + additional_properties, + _unparsed, + }; + + Ok(content) + } + } + + deserializer.deserialize_any(ScheduleOnCallResponderDataRelationshipsShiftsVisitor) + } +} diff --git a/src/datadogV2/model/model_schedule_on_call_responder_data_relationships_shifts_data_items.rs b/src/datadogV2/model/model_schedule_on_call_responder_data_relationships_shifts_data_items.rs new file mode 100644 index 0000000000..64002795f4 --- /dev/null +++ b/src/datadogV2/model/model_schedule_on_call_responder_data_relationships_shifts_data_items.rs @@ -0,0 +1,113 @@ +// 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}; + +/// Represents a reference to one of the shifts satisfying this responder group's position. +#[non_exhaustive] +#[skip_serializing_none] +#[derive(Clone, Debug, PartialEq, Serialize)] +pub struct ScheduleOnCallResponderDataRelationshipsShiftsDataItems { + /// Unique identifier of the shift. + #[serde(rename = "id")] + pub id: String, + /// Indicates that the related resource is of type `shifts`. + #[serde(rename = "type")] + pub type_: crate::datadogV2::model::ScheduleOnCallResponderDataRelationshipsShiftsDataItemsType, + #[serde(flatten)] + pub additional_properties: std::collections::BTreeMap, + #[serde(skip)] + #[serde(default)] + pub(crate) _unparsed: bool, +} + +impl ScheduleOnCallResponderDataRelationshipsShiftsDataItems { + pub fn new( + id: String, + type_: crate::datadogV2::model::ScheduleOnCallResponderDataRelationshipsShiftsDataItemsType, + ) -> ScheduleOnCallResponderDataRelationshipsShiftsDataItems { + ScheduleOnCallResponderDataRelationshipsShiftsDataItems { + id, + type_, + 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 ScheduleOnCallResponderDataRelationshipsShiftsDataItems { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + struct ScheduleOnCallResponderDataRelationshipsShiftsDataItemsVisitor; + impl<'a> Visitor<'a> for ScheduleOnCallResponderDataRelationshipsShiftsDataItemsVisitor { + type Value = ScheduleOnCallResponderDataRelationshipsShiftsDataItems; + + 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 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() { + "id" => { + 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::ScheduleOnCallResponderDataRelationshipsShiftsDataItemsType::UnparsedObject(_type_) => { + _unparsed = true; + }, + _ => {} + } + } + } + &_ => { + if let Ok(value) = serde_json::from_value(v.clone()) { + additional_properties.insert(k, value); + } + } + } + } + let id = id.ok_or_else(|| M::Error::missing_field("id"))?; + let type_ = type_.ok_or_else(|| M::Error::missing_field("type_"))?; + + let content = ScheduleOnCallResponderDataRelationshipsShiftsDataItems { + id, + type_, + additional_properties, + _unparsed, + }; + + Ok(content) + } + } + + deserializer.deserialize_any(ScheduleOnCallResponderDataRelationshipsShiftsDataItemsVisitor) + } +} diff --git a/src/datadogV2/model/model_schedule_on_call_responder_data_relationships_shifts_data_items_type.rs b/src/datadogV2/model/model_schedule_on_call_responder_data_relationships_shifts_data_items_type.rs new file mode 100644 index 0000000000..26d3edd800 --- /dev/null +++ b/src/datadogV2/model/model_schedule_on_call_responder_data_relationships_shifts_data_items_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 ScheduleOnCallResponderDataRelationshipsShiftsDataItemsType { + SHIFTS, + UnparsedObject(crate::datadog::UnparsedObject), +} + +impl ToString for ScheduleOnCallResponderDataRelationshipsShiftsDataItemsType { + fn to_string(&self) -> String { + match self { + Self::SHIFTS => String::from("shifts"), + Self::UnparsedObject(v) => v.value.to_string(), + } + } +} + +impl Serialize for ScheduleOnCallResponderDataRelationshipsShiftsDataItemsType { + 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 ScheduleOnCallResponderDataRelationshipsShiftsDataItemsType { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + let s: String = String::deserialize(deserializer)?; + Ok(match s.as_str() { + "shifts" => Self::SHIFTS, + _ => Self::UnparsedObject(crate::datadog::UnparsedObject { + value: serde_json::Value::String(s.into()), + }), + }) + } +} diff --git a/src/datadogV2/model/model_schedule_on_call_responder_data_type.rs b/src/datadogV2/model/model_schedule_on_call_responder_data_type.rs new file mode 100644 index 0000000000..213f74324d --- /dev/null +++ b/src/datadogV2/model/model_schedule_on_call_responder_data_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 ScheduleOnCallResponderDataType { + SCHEDULE_ONCALL_RESPONDER, + UnparsedObject(crate::datadog::UnparsedObject), +} + +impl ToString for ScheduleOnCallResponderDataType { + fn to_string(&self) -> String { + match self { + Self::SCHEDULE_ONCALL_RESPONDER => String::from("schedule_oncall_responder"), + Self::UnparsedObject(v) => v.value.to_string(), + } + } +} + +impl Serialize for ScheduleOnCallResponderDataType { + 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 ScheduleOnCallResponderDataType { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + let s: String = String::deserialize(deserializer)?; + Ok(match s.as_str() { + "schedule_oncall_responder" => Self::SCHEDULE_ONCALL_RESPONDER, + _ => Self::UnparsedObject(crate::datadog::UnparsedObject { + value: serde_json::Value::String(s.into()), + }), + }) + } +} diff --git a/src/datadogV2/model/model_schedule_on_call_responders.rs b/src/datadogV2/model/model_schedule_on_call_responders.rs new file mode 100644 index 0000000000..b165779baf --- /dev/null +++ b/src/datadogV2/model/model_schedule_on_call_responders.rs @@ -0,0 +1,127 @@ +// 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}; + +/// Root object representing a schedule's on-call responders, grouped by position (previous, current, next), for a given point in time. +#[non_exhaustive] +#[skip_serializing_none] +#[derive(Clone, Debug, PartialEq, Serialize)] +pub struct ScheduleOnCallResponders { + /// The main data object representing a schedule's on-call responders lookup, including relationships and metadata. + #[serde(rename = "data")] + pub data: Option, + /// Related resources referenced in the responder groups' relationships, such as shifts, schedules, and users. + #[serde(rename = "included")] + pub included: Option>, + #[serde(flatten)] + pub additional_properties: std::collections::BTreeMap, + #[serde(skip)] + #[serde(default)] + pub(crate) _unparsed: bool, +} + +impl ScheduleOnCallResponders { + pub fn new() -> ScheduleOnCallResponders { + ScheduleOnCallResponders { + data: None, + included: None, + additional_properties: std::collections::BTreeMap::new(), + _unparsed: false, + } + } + + pub fn data(mut self, value: crate::datadogV2::model::ScheduleOnCallRespondersData) -> Self { + self.data = Some(value); + self + } + + pub fn included( + mut self, + value: Vec, + ) -> Self { + self.included = Some(value); + self + } + + pub fn additional_properties( + mut self, + value: std::collections::BTreeMap, + ) -> Self { + self.additional_properties = value; + self + } +} + +impl Default for ScheduleOnCallResponders { + fn default() -> Self { + Self::new() + } +} + +impl<'de> Deserialize<'de> for ScheduleOnCallResponders { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + struct ScheduleOnCallRespondersVisitor; + impl<'a> Visitor<'a> for ScheduleOnCallRespondersVisitor { + type Value = ScheduleOnCallResponders; + + 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 included: Option< + Vec, + > = 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)?); + } + "included" => { + if v.is_null() { + continue; + } + included = 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 = ScheduleOnCallResponders { + data, + included, + additional_properties, + _unparsed, + }; + + Ok(content) + } + } + + deserializer.deserialize_any(ScheduleOnCallRespondersVisitor) + } +} diff --git a/src/datadogV2/model/model_schedule_on_call_responders_data.rs b/src/datadogV2/model/model_schedule_on_call_responders_data.rs new file mode 100644 index 0000000000..bcb14571ed --- /dev/null +++ b/src/datadogV2/model/model_schedule_on_call_responders_data.rs @@ -0,0 +1,165 @@ +// 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}; + +/// The main data object representing a schedule's on-call responders lookup, including relationships and metadata. +#[non_exhaustive] +#[skip_serializing_none] +#[derive(Clone, Debug, PartialEq, Serialize)] +pub struct ScheduleOnCallRespondersData { + /// Attributes for a schedule's on-call responders lookup. + #[serde(rename = "attributes")] + pub attributes: Option, + /// Unique identifier of this on-call responders lookup. + #[serde(rename = "id")] + pub id: Option, + /// Relationships for a schedule's on-call responders lookup, including the schedule and its responder groups. + #[serde(rename = "relationships")] + pub relationships: Option, + /// Represents the resource type for a schedule's grouped on-call responders across the previous, current, and next positions. + #[serde(rename = "type")] + pub type_: crate::datadogV2::model::ScheduleOnCallRespondersDataType, + #[serde(flatten)] + pub additional_properties: std::collections::BTreeMap, + #[serde(skip)] + #[serde(default)] + pub(crate) _unparsed: bool, +} + +impl ScheduleOnCallRespondersData { + pub fn new( + type_: crate::datadogV2::model::ScheduleOnCallRespondersDataType, + ) -> ScheduleOnCallRespondersData { + ScheduleOnCallRespondersData { + attributes: None, + id: None, + relationships: None, + type_, + additional_properties: std::collections::BTreeMap::new(), + _unparsed: false, + } + } + + pub fn attributes( + mut self, + value: crate::datadogV2::model::ScheduleOnCallRespondersDataAttributes, + ) -> Self { + self.attributes = Some(value); + self + } + + pub fn id(mut self, value: String) -> Self { + self.id = Some(value); + self + } + + pub fn relationships( + mut self, + value: crate::datadogV2::model::ScheduleOnCallRespondersDataRelationships, + ) -> Self { + self.relationships = Some(value); + self + } + + pub fn additional_properties( + mut self, + value: std::collections::BTreeMap, + ) -> Self { + self.additional_properties = value; + self + } +} + +impl<'de> Deserialize<'de> for ScheduleOnCallRespondersData { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + struct ScheduleOnCallRespondersDataVisitor; + impl<'a> Visitor<'a> for ScheduleOnCallRespondersDataVisitor { + type Value = ScheduleOnCallRespondersData; + + 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::ScheduleOnCallRespondersDataAttributes, + > = None; + let mut id: Option = None; + let mut relationships: Option< + crate::datadogV2::model::ScheduleOnCallRespondersDataRelationships, + > = 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)?); + } + "relationships" => { + if v.is_null() { + continue; + } + relationships = + 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::ScheduleOnCallRespondersDataType::UnparsedObject(_type_) => { + _unparsed = true; + }, + _ => {} + } + } + } + &_ => { + if let Ok(value) = serde_json::from_value(v.clone()) { + additional_properties.insert(k, value); + } + } + } + } + let type_ = type_.ok_or_else(|| M::Error::missing_field("type_"))?; + + let content = ScheduleOnCallRespondersData { + attributes, + id, + relationships, + type_, + additional_properties, + _unparsed, + }; + + Ok(content) + } + } + + deserializer.deserialize_any(ScheduleOnCallRespondersDataVisitor) + } +} diff --git a/src/datadogV2/model/model_schedule_on_call_responders_data_attributes.rs b/src/datadogV2/model/model_schedule_on_call_responders_data_attributes.rs new file mode 100644 index 0000000000..1a6761382a --- /dev/null +++ b/src/datadogV2/model/model_schedule_on_call_responders_data_attributes.rs @@ -0,0 +1,106 @@ +// 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 for a schedule's on-call responders lookup. +#[non_exhaustive] +#[skip_serializing_none] +#[derive(Clone, Debug, PartialEq, Serialize)] +pub struct ScheduleOnCallRespondersDataAttributes { + /// The timestamp the responders were resolved at. + #[serde(rename = "scheduled_at")] + pub scheduled_at: Option>, + #[serde(flatten)] + pub additional_properties: std::collections::BTreeMap, + #[serde(skip)] + #[serde(default)] + pub(crate) _unparsed: bool, +} + +impl ScheduleOnCallRespondersDataAttributes { + pub fn new() -> ScheduleOnCallRespondersDataAttributes { + ScheduleOnCallRespondersDataAttributes { + scheduled_at: None, + additional_properties: std::collections::BTreeMap::new(), + _unparsed: false, + } + } + + pub fn scheduled_at(mut self, value: chrono::DateTime) -> Self { + self.scheduled_at = Some(value); + self + } + + pub fn additional_properties( + mut self, + value: std::collections::BTreeMap, + ) -> Self { + self.additional_properties = value; + self + } +} + +impl Default for ScheduleOnCallRespondersDataAttributes { + fn default() -> Self { + Self::new() + } +} + +impl<'de> Deserialize<'de> for ScheduleOnCallRespondersDataAttributes { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + struct ScheduleOnCallRespondersDataAttributesVisitor; + impl<'a> Visitor<'a> for ScheduleOnCallRespondersDataAttributesVisitor { + type Value = ScheduleOnCallRespondersDataAttributes; + + 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 scheduled_at: 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() { + "scheduled_at" => { + if v.is_null() { + continue; + } + scheduled_at = + 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 = ScheduleOnCallRespondersDataAttributes { + scheduled_at, + additional_properties, + _unparsed, + }; + + Ok(content) + } + } + + deserializer.deserialize_any(ScheduleOnCallRespondersDataAttributesVisitor) + } +} diff --git a/src/datadogV2/model/model_schedule_on_call_responders_data_relationships.rs b/src/datadogV2/model/model_schedule_on_call_responders_data_relationships.rs new file mode 100644 index 0000000000..5c41df2b3d --- /dev/null +++ b/src/datadogV2/model/model_schedule_on_call_responders_data_relationships.rs @@ -0,0 +1,134 @@ +// 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}; + +/// Relationships for a schedule's on-call responders lookup, including the schedule and its responder groups. +#[non_exhaustive] +#[skip_serializing_none] +#[derive(Clone, Debug, PartialEq, Serialize)] +pub struct ScheduleOnCallRespondersDataRelationships { + /// Defines the list of per-position (previous, current, next) responder groups for the schedule. + #[serde(rename = "responders")] + pub responders: + Option, + /// Defines the relationship to the schedule this on-call responders lookup was performed for. + #[serde(rename = "schedule")] + pub schedule: + Option, + #[serde(flatten)] + pub additional_properties: std::collections::BTreeMap, + #[serde(skip)] + #[serde(default)] + pub(crate) _unparsed: bool, +} + +impl ScheduleOnCallRespondersDataRelationships { + pub fn new() -> ScheduleOnCallRespondersDataRelationships { + ScheduleOnCallRespondersDataRelationships { + responders: None, + schedule: None, + additional_properties: std::collections::BTreeMap::new(), + _unparsed: false, + } + } + + pub fn responders( + mut self, + value: crate::datadogV2::model::ScheduleOnCallRespondersDataRelationshipsResponders, + ) -> Self { + self.responders = Some(value); + self + } + + pub fn schedule( + mut self, + value: crate::datadogV2::model::ScheduleOnCallRespondersDataRelationshipsSchedule, + ) -> Self { + self.schedule = Some(value); + self + } + + pub fn additional_properties( + mut self, + value: std::collections::BTreeMap, + ) -> Self { + self.additional_properties = value; + self + } +} + +impl Default for ScheduleOnCallRespondersDataRelationships { + fn default() -> Self { + Self::new() + } +} + +impl<'de> Deserialize<'de> for ScheduleOnCallRespondersDataRelationships { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + struct ScheduleOnCallRespondersDataRelationshipsVisitor; + impl<'a> Visitor<'a> for ScheduleOnCallRespondersDataRelationshipsVisitor { + type Value = ScheduleOnCallRespondersDataRelationships; + + 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 responders: Option< + crate::datadogV2::model::ScheduleOnCallRespondersDataRelationshipsResponders, + > = None; + let mut schedule: Option< + crate::datadogV2::model::ScheduleOnCallRespondersDataRelationshipsSchedule, + > = 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() { + "responders" => { + if v.is_null() { + continue; + } + responders = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "schedule" => { + if v.is_null() { + continue; + } + schedule = 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 = ScheduleOnCallRespondersDataRelationships { + responders, + schedule, + additional_properties, + _unparsed, + }; + + Ok(content) + } + } + + deserializer.deserialize_any(ScheduleOnCallRespondersDataRelationshipsVisitor) + } +} diff --git a/src/datadogV2/model/model_schedule_on_call_responders_data_relationships_responders.rs b/src/datadogV2/model/model_schedule_on_call_responders_data_relationships_responders.rs new file mode 100644 index 0000000000..67e4ab3d2f --- /dev/null +++ b/src/datadogV2/model/model_schedule_on_call_responders_data_relationships_responders.rs @@ -0,0 +1,112 @@ +// 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}; + +/// Defines the list of per-position (previous, current, next) responder groups for the schedule. +#[non_exhaustive] +#[skip_serializing_none] +#[derive(Clone, Debug, PartialEq, Serialize)] +pub struct ScheduleOnCallRespondersDataRelationshipsResponders { + /// Array of references to the responder groups included in the response. + #[serde(rename = "data")] + pub data: Option< + Vec, + >, + #[serde(flatten)] + pub additional_properties: std::collections::BTreeMap, + #[serde(skip)] + #[serde(default)] + pub(crate) _unparsed: bool, +} + +impl ScheduleOnCallRespondersDataRelationshipsResponders { + pub fn new() -> ScheduleOnCallRespondersDataRelationshipsResponders { + ScheduleOnCallRespondersDataRelationshipsResponders { + data: None, + additional_properties: std::collections::BTreeMap::new(), + _unparsed: false, + } + } + + pub fn data( + mut self, + value: Vec< + crate::datadogV2::model::ScheduleOnCallRespondersDataRelationshipsRespondersDataItems, + >, + ) -> 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 ScheduleOnCallRespondersDataRelationshipsResponders { + fn default() -> Self { + Self::new() + } +} + +impl<'de> Deserialize<'de> for ScheduleOnCallRespondersDataRelationshipsResponders { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + struct ScheduleOnCallRespondersDataRelationshipsRespondersVisitor; + impl<'a> Visitor<'a> for ScheduleOnCallRespondersDataRelationshipsRespondersVisitor { + type Value = ScheduleOnCallRespondersDataRelationshipsResponders; + + 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 = ScheduleOnCallRespondersDataRelationshipsResponders { + data, + additional_properties, + _unparsed, + }; + + Ok(content) + } + } + + deserializer.deserialize_any(ScheduleOnCallRespondersDataRelationshipsRespondersVisitor) + } +} diff --git a/src/datadogV2/model/model_schedule_on_call_responders_data_relationships_responders_data_items.rs b/src/datadogV2/model/model_schedule_on_call_responders_data_relationships_responders_data_items.rs new file mode 100644 index 0000000000..8716d4e1ec --- /dev/null +++ b/src/datadogV2/model/model_schedule_on_call_responders_data_relationships_responders_data_items.rs @@ -0,0 +1,115 @@ +// 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}; + +/// Represents a reference to one position's (previous, current, or next) responder group. +#[non_exhaustive] +#[skip_serializing_none] +#[derive(Clone, Debug, PartialEq, Serialize)] +pub struct ScheduleOnCallRespondersDataRelationshipsRespondersDataItems { + /// Unique identifier of the responder group. + #[serde(rename = "id")] + pub id: String, + /// Identifies the resource type for a responder group linked to a schedule's on-call responders lookup. + #[serde(rename = "type")] + pub type_: + crate::datadogV2::model::ScheduleOnCallRespondersDataRelationshipsRespondersDataItemsType, + #[serde(flatten)] + pub additional_properties: std::collections::BTreeMap, + #[serde(skip)] + #[serde(default)] + pub(crate) _unparsed: bool, +} + +impl ScheduleOnCallRespondersDataRelationshipsRespondersDataItems { + pub fn new( + id: String, + type_: crate::datadogV2::model::ScheduleOnCallRespondersDataRelationshipsRespondersDataItemsType, + ) -> ScheduleOnCallRespondersDataRelationshipsRespondersDataItems { + ScheduleOnCallRespondersDataRelationshipsRespondersDataItems { + id, + type_, + 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 ScheduleOnCallRespondersDataRelationshipsRespondersDataItems { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + struct ScheduleOnCallRespondersDataRelationshipsRespondersDataItemsVisitor; + impl<'a> Visitor<'a> for ScheduleOnCallRespondersDataRelationshipsRespondersDataItemsVisitor { + type Value = ScheduleOnCallRespondersDataRelationshipsRespondersDataItems; + + 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 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() { + "id" => { + 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::ScheduleOnCallRespondersDataRelationshipsRespondersDataItemsType::UnparsedObject(_type_) => { + _unparsed = true; + }, + _ => {} + } + } + } + &_ => { + if let Ok(value) = serde_json::from_value(v.clone()) { + additional_properties.insert(k, value); + } + } + } + } + let id = id.ok_or_else(|| M::Error::missing_field("id"))?; + let type_ = type_.ok_or_else(|| M::Error::missing_field("type_"))?; + + let content = ScheduleOnCallRespondersDataRelationshipsRespondersDataItems { + id, + type_, + additional_properties, + _unparsed, + }; + + Ok(content) + } + } + + deserializer + .deserialize_any(ScheduleOnCallRespondersDataRelationshipsRespondersDataItemsVisitor) + } +} diff --git a/src/datadogV2/model/model_schedule_on_call_responders_data_relationships_responders_data_items_type.rs b/src/datadogV2/model/model_schedule_on_call_responders_data_relationships_responders_data_items_type.rs new file mode 100644 index 0000000000..44f921b085 --- /dev/null +++ b/src/datadogV2/model/model_schedule_on_call_responders_data_relationships_responders_data_items_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 ScheduleOnCallRespondersDataRelationshipsRespondersDataItemsType { + SCHEDULE_ONCALL_RESPONDER, + UnparsedObject(crate::datadog::UnparsedObject), +} + +impl ToString for ScheduleOnCallRespondersDataRelationshipsRespondersDataItemsType { + fn to_string(&self) -> String { + match self { + Self::SCHEDULE_ONCALL_RESPONDER => String::from("schedule_oncall_responder"), + Self::UnparsedObject(v) => v.value.to_string(), + } + } +} + +impl Serialize for ScheduleOnCallRespondersDataRelationshipsRespondersDataItemsType { + 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 ScheduleOnCallRespondersDataRelationshipsRespondersDataItemsType { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + let s: String = String::deserialize(deserializer)?; + Ok(match s.as_str() { + "schedule_oncall_responder" => Self::SCHEDULE_ONCALL_RESPONDER, + _ => Self::UnparsedObject(crate::datadog::UnparsedObject { + value: serde_json::Value::String(s.into()), + }), + }) + } +} diff --git a/src/datadogV2/model/model_schedule_on_call_responders_data_relationships_schedule.rs b/src/datadogV2/model/model_schedule_on_call_responders_data_relationships_schedule.rs new file mode 100644 index 0000000000..39a8c57b04 --- /dev/null +++ b/src/datadogV2/model/model_schedule_on_call_responders_data_relationships_schedule.rs @@ -0,0 +1,111 @@ +// 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}; + +/// Defines the relationship to the schedule this on-call responders lookup was performed for. +#[non_exhaustive] +#[skip_serializing_none] +#[derive(Clone, Debug, PartialEq, Serialize)] +pub struct ScheduleOnCallRespondersDataRelationshipsSchedule { + /// Represents a reference to the schedule this on-call responders lookup was performed for. + #[serde(rename = "data")] + pub data: + Option, + #[serde(flatten)] + pub additional_properties: std::collections::BTreeMap, + #[serde(skip)] + #[serde(default)] + pub(crate) _unparsed: bool, +} + +impl ScheduleOnCallRespondersDataRelationshipsSchedule { + pub fn new() -> ScheduleOnCallRespondersDataRelationshipsSchedule { + ScheduleOnCallRespondersDataRelationshipsSchedule { + data: None, + additional_properties: std::collections::BTreeMap::new(), + _unparsed: false, + } + } + + pub fn data( + mut self, + value: crate::datadogV2::model::ScheduleOnCallRespondersDataRelationshipsScheduleData, + ) -> 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 ScheduleOnCallRespondersDataRelationshipsSchedule { + fn default() -> Self { + Self::new() + } +} + +impl<'de> Deserialize<'de> for ScheduleOnCallRespondersDataRelationshipsSchedule { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + struct ScheduleOnCallRespondersDataRelationshipsScheduleVisitor; + impl<'a> Visitor<'a> for ScheduleOnCallRespondersDataRelationshipsScheduleVisitor { + type Value = ScheduleOnCallRespondersDataRelationshipsSchedule; + + 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< + crate::datadogV2::model::ScheduleOnCallRespondersDataRelationshipsScheduleData, + > = 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 = ScheduleOnCallRespondersDataRelationshipsSchedule { + data, + additional_properties, + _unparsed, + }; + + Ok(content) + } + } + + deserializer.deserialize_any(ScheduleOnCallRespondersDataRelationshipsScheduleVisitor) + } +} diff --git a/src/datadogV2/model/model_schedule_on_call_responders_data_relationships_schedule_data.rs b/src/datadogV2/model/model_schedule_on_call_responders_data_relationships_schedule_data.rs new file mode 100644 index 0000000000..84a190145b --- /dev/null +++ b/src/datadogV2/model/model_schedule_on_call_responders_data_relationships_schedule_data.rs @@ -0,0 +1,113 @@ +// 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}; + +/// Represents a reference to the schedule this on-call responders lookup was performed for. +#[non_exhaustive] +#[skip_serializing_none] +#[derive(Clone, Debug, PartialEq, Serialize)] +pub struct ScheduleOnCallRespondersDataRelationshipsScheduleData { + /// Unique identifier of the schedule. + #[serde(rename = "id")] + pub id: String, + /// Identifies the resource type for the schedule associated with this on-call responders lookup. + #[serde(rename = "type")] + pub type_: crate::datadogV2::model::ScheduleOnCallRespondersDataRelationshipsScheduleDataType, + #[serde(flatten)] + pub additional_properties: std::collections::BTreeMap, + #[serde(skip)] + #[serde(default)] + pub(crate) _unparsed: bool, +} + +impl ScheduleOnCallRespondersDataRelationshipsScheduleData { + pub fn new( + id: String, + type_: crate::datadogV2::model::ScheduleOnCallRespondersDataRelationshipsScheduleDataType, + ) -> ScheduleOnCallRespondersDataRelationshipsScheduleData { + ScheduleOnCallRespondersDataRelationshipsScheduleData { + id, + type_, + 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 ScheduleOnCallRespondersDataRelationshipsScheduleData { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + struct ScheduleOnCallRespondersDataRelationshipsScheduleDataVisitor; + impl<'a> Visitor<'a> for ScheduleOnCallRespondersDataRelationshipsScheduleDataVisitor { + type Value = ScheduleOnCallRespondersDataRelationshipsScheduleData; + + 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 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() { + "id" => { + 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::ScheduleOnCallRespondersDataRelationshipsScheduleDataType::UnparsedObject(_type_) => { + _unparsed = true; + }, + _ => {} + } + } + } + &_ => { + if let Ok(value) = serde_json::from_value(v.clone()) { + additional_properties.insert(k, value); + } + } + } + } + let id = id.ok_or_else(|| M::Error::missing_field("id"))?; + let type_ = type_.ok_or_else(|| M::Error::missing_field("type_"))?; + + let content = ScheduleOnCallRespondersDataRelationshipsScheduleData { + id, + type_, + additional_properties, + _unparsed, + }; + + Ok(content) + } + } + + deserializer.deserialize_any(ScheduleOnCallRespondersDataRelationshipsScheduleDataVisitor) + } +} diff --git a/src/datadogV2/model/model_schedule_on_call_responders_data_relationships_schedule_data_type.rs b/src/datadogV2/model/model_schedule_on_call_responders_data_relationships_schedule_data_type.rs new file mode 100644 index 0000000000..0e90ceaa0e --- /dev/null +++ b/src/datadogV2/model/model_schedule_on_call_responders_data_relationships_schedule_data_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 ScheduleOnCallRespondersDataRelationshipsScheduleDataType { + SCHEDULES, + UnparsedObject(crate::datadog::UnparsedObject), +} + +impl ToString for ScheduleOnCallRespondersDataRelationshipsScheduleDataType { + fn to_string(&self) -> String { + match self { + Self::SCHEDULES => String::from("schedules"), + Self::UnparsedObject(v) => v.value.to_string(), + } + } +} + +impl Serialize for ScheduleOnCallRespondersDataRelationshipsScheduleDataType { + 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 ScheduleOnCallRespondersDataRelationshipsScheduleDataType { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + let s: String = String::deserialize(deserializer)?; + Ok(match s.as_str() { + "schedules" => Self::SCHEDULES, + _ => Self::UnparsedObject(crate::datadog::UnparsedObject { + value: serde_json::Value::String(s.into()), + }), + }) + } +} diff --git a/src/datadogV2/model/model_schedule_on_call_responders_data_type.rs b/src/datadogV2/model/model_schedule_on_call_responders_data_type.rs new file mode 100644 index 0000000000..afacbe27fe --- /dev/null +++ b/src/datadogV2/model/model_schedule_on_call_responders_data_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 ScheduleOnCallRespondersDataType { + SCHEDULE_ONCALL_RESPONDERS, + UnparsedObject(crate::datadog::UnparsedObject), +} + +impl ToString for ScheduleOnCallRespondersDataType { + fn to_string(&self) -> String { + match self { + Self::SCHEDULE_ONCALL_RESPONDERS => String::from("schedule_oncall_responders"), + Self::UnparsedObject(v) => v.value.to_string(), + } + } +} + +impl Serialize for ScheduleOnCallRespondersDataType { + 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 ScheduleOnCallRespondersDataType { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + let s: String = String::deserialize(deserializer)?; + Ok(match s.as_str() { + "schedule_oncall_responders" => Self::SCHEDULE_ONCALL_RESPONDERS, + _ => Self::UnparsedObject(crate::datadog::UnparsedObject { + value: serde_json::Value::String(s.into()), + }), + }) + } +} diff --git a/src/datadogV2/model/model_schedule_on_call_responders_included.rs b/src/datadogV2/model/model_schedule_on_call_responders_included.rs new file mode 100644 index 0000000000..89b03733d4 --- /dev/null +++ b/src/datadogV2/model/model_schedule_on_call_responders_included.rs @@ -0,0 +1,57 @@ +// 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}; + +/// Represents a union of related resources included in the response, such as responder groups, shifts, schedules, and users. +#[non_exhaustive] +#[derive(Clone, Debug, PartialEq, Serialize)] +#[serde(untagged)] +pub enum ScheduleOnCallRespondersIncluded { + ScheduleOnCallResponderData(Box), + ShiftData(Box), + ScheduleData(Box), + User(Box), + UnparsedObject(crate::datadog::UnparsedObject), +} + +impl<'de> Deserialize<'de> for ScheduleOnCallRespondersIncluded { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + let value: serde_json::Value = Deserialize::deserialize(deserializer)?; + if let Ok(_v) = serde_json::from_value::< + Box, + >(value.clone()) + { + if !_v._unparsed { + return Ok(ScheduleOnCallRespondersIncluded::ScheduleOnCallResponderData(_v)); + } + } + if let Ok(_v) = + serde_json::from_value::>(value.clone()) + { + if !_v._unparsed { + return Ok(ScheduleOnCallRespondersIncluded::ShiftData(_v)); + } + } + if let Ok(_v) = + serde_json::from_value::>(value.clone()) + { + if !_v._unparsed { + return Ok(ScheduleOnCallRespondersIncluded::ScheduleData(_v)); + } + } + if let Ok(_v) = serde_json::from_value::>(value.clone()) + { + if !_v._unparsed { + return Ok(ScheduleOnCallRespondersIncluded::User(_v)); + } + } + + return Ok(ScheduleOnCallRespondersIncluded::UnparsedObject( + crate::datadog::UnparsedObject { value }, + )); + } +} diff --git a/tests/scenarios/cassettes/v2/on-call/Get-on-call-responders-for-a-schedule-returns-OK-response.frozen b/tests/scenarios/cassettes/v2/on-call/Get-on-call-responders-for-a-schedule-returns-OK-response.frozen new file mode 100644 index 0000000000..474884360e --- /dev/null +++ b/tests/scenarios/cassettes/v2/on-call/Get-on-call-responders-for-a-schedule-returns-OK-response.frozen @@ -0,0 +1 @@ +2026-07-10T09:31:37.503Z \ No newline at end of file diff --git a/tests/scenarios/cassettes/v2/on-call/Get-on-call-responders-for-a-schedule-returns-OK-response.json b/tests/scenarios/cassettes/v2/on-call/Get-on-call-responders-for-a-schedule-returns-OK-response.json new file mode 100644 index 0000000000..95dda8f811 --- /dev/null +++ b/tests/scenarios/cassettes/v2/on-call/Get-on-call-responders-for-a-schedule-returns-OK-response.json @@ -0,0 +1,149 @@ +{ + "http_interactions": [ + { + "request": { + "body": { + "string": "{\"data\":{\"attributes\":{\"email\":\"Test-Get_on_call_responders_for_a_schedule_returns_OK_response-1783675897@datadoghq.com\",\"title\":\"user title\"},\"type\":\"users\"}}", + "encoding": null + }, + "headers": { + "Accept": [ + "application/json" + ], + "Content-Type": [ + "application/json" + ] + }, + "method": "post", + "uri": "https://api.datadoghq.com/api/v2/users" + }, + "response": { + "body": { + "string": "{\"data\":{\"type\":\"users\",\"id\":\"7f1b523e-fe13-4917-8519-6dd314ef17c0\",\"attributes\":{\"uuid\":\"7f1b523e-fe13-4917-8519-6dd314ef17c0\",\"name\":null,\"handle\":\"test-get_on_call_responders_for_a_schedule_returns_ok_response-1783675897@datadoghq.com\",\"created_at\":\"2026-07-10T09:31:38.042683+00:00\",\"modified_at\":\"2026-07-10T09:31:38.042683+00:00\",\"email\":\"test-get_on_call_responders_for_a_schedule_returns_ok_response-1783675897@datadoghq.com\",\"icon\":\"https://secure.gravatar.com/avatar/22b76633087bc3ee4427cc67e8466d5e?s=48&d=retro\",\"title\":\"user title\",\"verified\":false,\"service_account\":false,\"disabled\":false,\"allowed_login_methods\":[],\"status\":\"Pending\",\"last_login_time\":null},\"relationships\":{\"roles\":{\"data\":[]},\"org\":{\"data\":{\"type\":\"orgs\",\"id\":\"4dee724d-00cc-11ea-a77b-570c9d03c6c5\"}}}}}\n", + "encoding": null + }, + "headers": { + "Content-Type": [ + "application/json" + ] + }, + "status": { + "code": 201, + "message": "Created" + } + }, + "recorded_at": "Fri, 10 Jul 2026 09:31:37 GMT" + }, + { + "request": { + "body": { + "string": "{\"data\":{\"attributes\":{\"layers\":[{\"effective_date\":\"2026-06-30T09:31:37.503Z\",\"end_date\":\"2026-07-20T09:31:37.503Z\",\"interval\":{\"days\":1},\"members\":[{\"user\":{\"id\":\"7f1b523e-fe13-4917-8519-6dd314ef17c0\"}}],\"name\":\"Layer 1\",\"restrictions\":[{\"end_day\":\"friday\",\"end_time\":\"17:00:00\",\"start_day\":\"monday\",\"start_time\":\"09:00:00\"}],\"rotation_start\":\"2026-07-05T09:31:37.503Z\"}],\"name\":\"Test-Get_on_call_responders_for_a_schedule_returns_OK_response-1783675897\",\"time_zone\":\"America/New_York\"},\"relationships\":{\"teams\":{\"data\":[{\"id\":\"65aea9d0-941c-4607-bf8a-14fc0dac2820\",\"type\":\"teams\"}]}},\"type\":\"schedules\"}}", + "encoding": null + }, + "headers": { + "Accept": [ + "application/json" + ], + "Content-Type": [ + "application/json" + ] + }, + "method": "post", + "uri": "https://api.datadoghq.com/api/v2/on-call/schedules" + }, + "response": { + "body": { + "string": "{\"data\":{\"id\":\"23545b48-fa23-4ea9-a331-3a38f81195cd\",\"type\":\"schedules\",\"attributes\":{\"name\":\"Test-Get_on_call_responders_for_a_schedule_returns_OK_response-1783675897\",\"tags\":[],\"time_zone\":\"America/New_York\"},\"relationships\":{\"layers\":{\"data\":[{\"id\":\"03edf431-b1a6-418a-965e-9df50275dc7e\",\"type\":\"layers\"}]},\"teams\":{\"data\":[{\"id\":\"65aea9d0-941c-4607-bf8a-14fc0dac2820\",\"type\":\"teams\"}]}}}}", + "encoding": null + }, + "headers": { + "Content-Type": [ + "application/vnd.api+json" + ] + }, + "status": { + "code": 201, + "message": "Created" + } + }, + "recorded_at": "Fri, 10 Jul 2026 09:31:37 GMT" + }, + { + "request": { + "body": "", + "headers": { + "Accept": [ + "application/json" + ] + }, + "method": "get", + "uri": "https://api.datadoghq.com/api/v2/on-call/schedules/23545b48-fa23-4ea9-a331-3a38f81195cd/responders" + }, + "response": { + "body": { + "string": "{\"data\":{\"id\":\"23545b48-fa23-4ea9-a331-3a38f81195cd-1783675898\",\"type\":\"schedule_oncall_responders\",\"attributes\":{\"scheduled_at\":\"2026-07-10T09:31:38.803561233Z\"},\"relationships\":{\"responders\":{\"data\":[{\"id\":\"23545b48-fa23-4ea9-a331-3a38f81195cd-1783675898-current\",\"type\":\"schedule_oncall_responder\"}]},\"schedule\":{\"data\":{\"id\":\"23545b48-fa23-4ea9-a331-3a38f81195cd\",\"type\":\"schedules\"}}}}}", + "encoding": null + }, + "headers": { + "Content-Type": [ + "application/vnd.api+json" + ] + }, + "status": { + "code": 200, + "message": "OK" + } + }, + "recorded_at": "Fri, 10 Jul 2026 09:31:37 GMT" + }, + { + "request": { + "body": "", + "headers": { + "Accept": [ + "*/*" + ] + }, + "method": "delete", + "uri": "https://api.datadoghq.com/api/v2/on-call/schedules/23545b48-fa23-4ea9-a331-3a38f81195cd" + }, + "response": { + "body": { + "string": "", + "encoding": null + }, + "headers": {}, + "status": { + "code": 204, + "message": "No Content" + } + }, + "recorded_at": "Fri, 10 Jul 2026 09:31:37 GMT" + }, + { + "request": { + "body": "", + "headers": { + "Accept": [ + "*/*" + ] + }, + "method": "delete", + "uri": "https://api.datadoghq.com/api/v2/users/7f1b523e-fe13-4917-8519-6dd314ef17c0" + }, + "response": { + "body": { + "string": "", + "encoding": null + }, + "headers": {}, + "status": { + "code": 204, + "message": "No Content" + } + }, + "recorded_at": "Fri, 10 Jul 2026 09:31:37 GMT" + } + ], + "recorded_with": "VCR 6.0.0" +} \ No newline at end of file diff --git a/tests/scenarios/features/v2/on-call.feature b/tests/scenarios/features/v2/on-call.feature index a4ea9a7c4f..208eca3cb9 100644 --- a/tests/scenarios/features/v2/on-call.feature +++ b/tests/scenarios/features/v2/on-call.feature @@ -290,6 +290,29 @@ Feature: On-Call And the response "data.attributes.category" is equal to "high_urgency" And the response "included" has length 1 + @generated @skip @team:DataDog/on-call + Scenario: Get on-call responders for a schedule returns "Bad Request" response + Given new "GetScheduleOnCallResponders" request + And request contains "schedule_id" parameter from "REPLACE.ME" + When the request is sent + Then the response status is 400 Bad Request + + @generated @skip @team:DataDog/on-call + Scenario: Get on-call responders for a schedule returns "Not Found" response + Given new "GetScheduleOnCallResponders" request + And request contains "schedule_id" parameter from "REPLACE.ME" + When the request is sent + Then the response status is 404 Not Found + + @team:DataDog/on-call + Scenario: Get on-call responders for a schedule returns "OK" response + Given new "GetScheduleOnCallResponders" request + And there is a valid "user" in the system + And there is a valid "schedule" in the system + And request contains "schedule_id" parameter from "schedule.data.id" + When the request is sent + Then the response status is 200 OK + @generated @skip @team:DataDog/on-call Scenario: Get scheduled on-call user returns "Bad Request" response Given new "GetScheduleOnCallUser" request diff --git a/tests/scenarios/features/v2/undo.json b/tests/scenarios/features/v2/undo.json index cbfa3f2078..fcd23cf442 100644 --- a/tests/scenarios/features/v2/undo.json +++ b/tests/scenarios/features/v2/undo.json @@ -5618,6 +5618,12 @@ "type": "safe" } }, + "GetScheduleOnCallResponders": { + "tag": "On-Call", + "undo": { + "type": "safe" + } + }, "GetTeamOnCallUsers": { "tag": "On-Call", "undo": { diff --git a/tests/scenarios/function_mappings.rs b/tests/scenarios/function_mappings.rs index 6a3273dce4..bdecac9587 100644 --- a/tests/scenarios/function_mappings.rs +++ b/tests/scenarios/function_mappings.rs @@ -6175,6 +6175,10 @@ pub fn collect_function_calls(world: &mut DatadogWorld) { "v2.GetScheduleOnCallUser".into(), test_v2_get_schedule_on_call_user, ); + world.function_mappings.insert( + "v2.GetScheduleOnCallResponders".into(), + test_v2_get_schedule_on_call_responders, + ); world.function_mappings.insert( "v2.GetTeamOnCallUsers".into(), test_v2_get_team_on_call_users, @@ -47875,6 +47879,49 @@ fn test_v2_get_schedule_on_call_user( world.response.code = response.status.as_u16(); } +fn test_v2_get_schedule_on_call_responders( + world: &mut DatadogWorld, + _parameters: &HashMap, +) { + let api = world + .api_instances + .v2_api_on_call + .as_ref() + .expect("api instance not found"); + let schedule_id = + serde_json::from_value(_parameters.get("schedule_id").unwrap().clone()).unwrap(); + let include = _parameters + .get("include") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let filter_position = _parameters + .get("filter[position]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let filter_at_ts = _parameters + .get("filter[at_ts]") + .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap())); + let mut params = datadogV2::api_on_call::GetScheduleOnCallRespondersOptionalParams::default(); + params.include = include; + params.filter_position = filter_position; + params.filter_at_ts = filter_at_ts; + let response = + match block_on(api.get_schedule_on_call_responders_with_http_info(schedule_id, 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_get_team_on_call_users(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances