Struct ScheduleCreateRequest

#[non_exhaustive]
pub struct ScheduleCreateRequest {
    pub data: ScheduleCreateRequestData,
    pub additional_properties: BTreeMap<String, Value>,
    /* private fields */
}

The top-level request body for schedule creation, wrapping a data object.

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

data: ScheduleCreateRequestData

The core data wrapper for creating a schedule, encompassing attributes, relationships, and the resource type.

additional_properties: BTreeMap<String, Value>

Implementations

impl ScheduleCreateRequest

pub fn new(data: ScheduleCreateRequestData) -> ScheduleCreateRequest

Examples found in repository

examples/v2_on-call_CreateOnCallSchedule.rs (lines 30-89)

async fn main() {
    // there is a valid "user" in the system
    let user_data_id = std::env::var("USER_DATA_ID").unwrap();

    // there is a valid "team" in the system
    let team_data_id = std::env::var("TEAM_DATA_ID").unwrap();
    let body =
        ScheduleCreateRequest::new(
            ScheduleCreateRequestData::new(
                ScheduleCreateRequestDataAttributes::new(
                    vec![
                        ScheduleCreateRequestDataAttributesLayersItems::new(
                            DateTime::parse_from_rfc3339("2021-11-01T11:11:11+00:00")
                                .expect("Failed to parse datetime")
                                .with_timezone(&Utc),
                            ScheduleCreateRequestDataAttributesLayersItemsInterval::new().days(1),
                            vec![
                                ScheduleCreateRequestDataAttributesLayersItemsMembersItems
                                ::new().user(
                                    ScheduleCreateRequestDataAttributesLayersItemsMembersItemsUser
                                    ::new().id(user_data_id.clone()),
                                )
                            ],
                            "Layer 1".to_string(),
                            DateTime::parse_from_rfc3339("2021-11-06T11:11:11+00:00")
                                .expect("Failed to parse datetime")
                                .with_timezone(&Utc),
                        )
                            .end_date(
                                DateTime::parse_from_rfc3339("2021-11-21T11:11:11+00:00")
                                    .expect("Failed to parse datetime")
                                    .with_timezone(&Utc),
                            )
                            .restrictions(
                                vec![
                                    ScheduleCreateRequestDataAttributesLayersItemsRestrictionsItems::new()
                                        .end_day(
                                            ScheduleCreateRequestDataAttributesLayersItemsRestrictionsItemsEndDay
                                            ::FRIDAY,
                                        )
                                        .end_time("17:00:00".to_string())
                                        .start_day(
                                            ScheduleCreateRequestDataAttributesLayersItemsRestrictionsItemsStartDay
                                            ::MONDAY,
                                        )
                                        .start_time("09:00:00".to_string())
                                ],
                            )
                    ],
                    "Example-On-Call".to_string(),
                    "America/New_York".to_string(),
                ).tags(vec!["tag1".to_string(), "tag2".to_string()]),
                ScheduleCreateRequestDataType::SCHEDULES,
            ).relationships(
                ScheduleCreateRequestDataRelationships
                ::new().teams(
                    ScheduleCreateRequestDataRelationshipsTeams
                    ::new().data(
                        vec![
                            ScheduleCreateRequestDataRelationshipsTeamsDataItems::new()
                                .id(team_data_id.clone())
                                .type_(ScheduleCreateRequestDataRelationshipsTeamsDataItemsType::TEAMS)
                        ],
                    ),
                ),
            ),
        );
    let configuration = datadog::Configuration::new();
    let api = OnCallAPI::with_config(configuration);
    let resp = api
        .create_on_call_schedule(body, CreateOnCallScheduleOptionalParams::default())
        .await;
    if let Ok(value) = resp {
        println!("{:#?}", value);
    } else {
        println!("{:#?}", resp.unwrap_err());
    }
}

pub fn additional_properties(self, value: BTreeMap<String, Value>) -> Self

Trait Implementations

impl Clone for ScheduleCreateRequest

fn clone(&self) -> ScheduleCreateRequest

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ScheduleCreateRequest

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ScheduleCreateRequest

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for ScheduleCreateRequest

fn eq(&self, other: &ScheduleCreateRequest) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for ScheduleCreateRequest

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for ScheduleCreateRequest