Add GetScheduleOnCallUser specs (#649)

Co-authored-by: ci.datadog-api-spec <[email protected]>

Author: api-clients-generation-pipeline[bot]

.apigentools-info

@@ -4,13 +4,13 @@
     "spec_versions": {
         "v1": {
             "apigentools_version": "1.6.6",
-            "regenerated": "2025-05-12 09:40:10.231223",
-            "spec_repo_commit": "c4d0aeef"
+            "regenerated": "2025-05-13 01:19:31.172553",
+            "spec_repo_commit": "dc3b522f"
         },
         "v2": {
             "apigentools_version": "1.6.6",
-            "regenerated": "2025-05-12 09:40:10.247293",
-            "spec_repo_commit": "c4d0aeef"
+            "regenerated": "2025-05-13 01:19:31.189716",
+            "spec_repo_commit": "dc3b522f"
         }
     }
 }

.generator/schemas/v2/openapi.yaml

@@ -36060,6 +36060,115 @@ components:
           description: Link to the Incident created on ServiceNow
           type: string
       type: object
+    Shift:
+      description: The definition of `Shift` object.
+      example:
+        data:
+          attributes:
+            end: '2025-05-07T03:53:01.206662873Z'
+            start: '2025-05-07T02:53:01.206662814Z'
+          id: 00000000-0000-0000-0000-000000000000
+          relationships:
+            user:
+              data:
+                id: 00000000-aba1-0000-0000-000000000000
+                type: users
+          type: shifts
+        included:
+        - attributes:
+            email: [email protected]
+            name: User 1
+            status: ''
+          id: 00000000-aba1-0000-0000-000000000000
+          type: users
+      properties:
+        data:
+          $ref: '#/components/schemas/ShiftData'
+          nullable: true
+        included:
+          description: The `Shift` `included`.
+          items:
+            $ref: '#/components/schemas/ShiftIncluded'
+          type: array
+      type: object
+    ShiftData:
+      description: The definition of `ShiftData` object.
+      properties:
+        attributes:
+          $ref: '#/components/schemas/ShiftDataAttributes'
+        id:
+          description: The `ShiftData` `id`.
+          type: string
+        relationships:
+          $ref: '#/components/schemas/ShiftDataRelationships'
+        type:
+          $ref: '#/components/schemas/ShiftDataType'
+      required:
+      - type
+      type: object
+    ShiftDataAttributes:
+      description: The definition of `ShiftDataAttributes` object.
+      properties:
+        end:
+          description: The end time of the shift.
+          format: date-time
+          type: string
+        start:
+          description: The start time of the shift.
+          format: date-time
+          type: string
+      type: object
+    ShiftDataRelationships:
+      description: The definition of `ShiftDataRelationships` object.
+      properties:
+        user:
+          $ref: '#/components/schemas/ShiftDataRelationshipsUser'
+      type: object
+    ShiftDataRelationshipsUser:
+      description: Defines the relationship between a shift and the user who is working
+        that shift.
+      properties:
+        data:
+          $ref: '#/components/schemas/ShiftDataRelationshipsUserData'
+      required:
+      - data
+      type: object
+    ShiftDataRelationshipsUserData:
+      description: Represents a reference to the user assigned to this shift, containing
+        the user's ID and resource type.
+      properties:
+        id:
+          description: Specifies the unique identifier of the user.
+          example: 00000000-0000-0000-0000-000000000000
+          type: string
+        type:
+          $ref: '#/components/schemas/ShiftDataRelationshipsUserDataType'
+      required:
+      - type
+      - id
+      type: object
+    ShiftDataRelationshipsUserDataType:
+      default: users
+      description: Indicates that the related resource is of type 'users'.
+      enum:
+      - users
+      example: users
+      type: string
+      x-enum-varnames:
+      - USERS
+    ShiftDataType:
+      default: shifts
+      description: Indicates that the resource is of type 'shifts'.
+      enum:
+      - shifts
+      example: shifts
+      type: string
+      x-enum-varnames:
+      - SHIFTS
+    ShiftIncluded:
+      description: The definition of `ShiftIncluded` object.
+      oneOf:
+      - $ref: '#/components/schemas/ScheduleUser'
     SingleAggregatedConnectionResponseArray:
       description: List of aggregated connections.
       example:
@@ -51922,6 +52031,56 @@ paths:
         operator: AND
         permissions:
         - 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.
+      operationId: GetScheduleOnCallUser
+      parameters:
+      - description: 'Specifies related resources to include in the response as a
+          comma-separated list. Allowed value: `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: Retrieves the on-call user at the given timestamp (ISO-8601).
+          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:
+              schema:
+                $ref: '#/components/schemas/Shift'
+          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 the schedule of an on-call user
+      tags:
+      - On-Call
   /api/v2/on-call/teams/{team_id}/routing-rules:
     get:
       description: Get a team's on-call routing rules

examples/v2_on-call_GetScheduleOnCallUser.rs

@@ -0,0 +1,23 @@
+// Get the schedule of an on-call user returns "OK" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_on_call::GetScheduleOnCallUserOptionalParams;
+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_user(
+            schedule_data_id.clone(),
+            GetScheduleOnCallUserOptionalParams::default(),
+        )
+        .await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

src/datadogV2/api/api_on_call.rs

@@ -90,6 +90,29 @@ impl GetOnCallTeamRoutingRulesOptionalParams {
     }
 }
 
+/// GetScheduleOnCallUserOptionalParams is a struct for passing parameters to the method [`OnCallAPI::get_schedule_on_call_user`]
+#[non_exhaustive]
+#[derive(Clone, Default, Debug)]
+pub struct GetScheduleOnCallUserOptionalParams {
+    /// Specifies related resources to include in the response as a comma-separated list. Allowed value: `user`.
+    pub include: Option<String>,
+    /// Retrieves the on-call user at the given timestamp (ISO-8601). Defaults to the current time if omitted."
+    pub filter_at_ts: Option<String>,
+}
+
+impl GetScheduleOnCallUserOptionalParams {
+    /// Specifies related resources to include in the response as a comma-separated list. Allowed value: `user`.
+    pub fn include(mut self, value: String) -> Self {
+        self.include = Some(value);
+        self
+    }
+    /// Retrieves the on-call user at the given timestamp (ISO-8601). Defaults to the current time if omitted."
+    pub fn filter_at_ts(mut self, value: String) -> Self {
+        self.filter_at_ts = Some(value);
+        self
+    }
+}
+
 /// SetOnCallTeamRoutingRulesOptionalParams is a struct for passing parameters to the method [`OnCallAPI::set_on_call_team_routing_rules`]
 #[non_exhaustive]
 #[derive(Clone, Default, Debug)]
@@ -194,6 +217,14 @@ pub enum GetOnCallTeamRoutingRulesError {
     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)]
+pub enum GetScheduleOnCallUserError {
+    APIErrorResponse(crate::datadogV2::model::APIErrorResponse),
+    UnknownValue(serde_json::Value),
+}
+
 /// SetOnCallTeamRoutingRulesError is a struct for typed errors of method [`OnCallAPI::set_on_call_team_routing_rules`]
 #[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(untagged)]
@@ -1154,6 +1185,128 @@ impl OnCallAPI {
         }
     }
 
+    /// Retrieves the user who is on-call for the specified schedule at a given time.
+    pub async fn get_schedule_on_call_user(
+        &self,
+        schedule_id: String,
+        params: GetScheduleOnCallUserOptionalParams,
+    ) -> Result<crate::datadogV2::model::Shift, datadog::Error<GetScheduleOnCallUserError>> {
+        match self
+            .get_schedule_on_call_user_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 user who is on-call for the specified schedule at a given time.
+    pub async fn get_schedule_on_call_user_with_http_info(
+        &self,
+        schedule_id: String,
+        params: GetScheduleOnCallUserOptionalParams,
+    ) -> Result<
+        datadog::ResponseContent<crate::datadogV2::model::Shift>,
+        datadog::Error<GetScheduleOnCallUserError>,
+    > {
+        let local_configuration = &self.config;
+        let operation_id = "v2.get_schedule_on_call_user";
+
+        // unbox and build optional parameters
+        let include = params.include;
+        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}/on-call",
+            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_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::<crate::datadogV2::model::Shift>(&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<GetScheduleOnCallUserError> =
+                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))
+        }
+    }
+
     /// Set a team's on-call routing rules
     pub async fn set_on_call_team_routing_rules(
         &self,