Struct ScheduleUpdateRequestDataAttributes

#[non_exhaustive]
pub struct ScheduleUpdateRequestDataAttributes {
    pub layers: Vec<ScheduleUpdateRequestDataAttributesLayersItems>,
    pub name: String,
    pub tags: Option<Vec<String>>,
    pub time_zone: String,
    pub additional_properties: BTreeMap<String, Value>,
    /* private fields */
}

Defines the updatable attributes for a schedule, such as name, time zone, tags, and layers.

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.

layers: Vec<ScheduleUpdateRequestDataAttributesLayersItems>

The updated list of layers (rotations) for this schedule.

name: String

A short name for the schedule.

tags: Option<Vec<String>>

A list of tags that you can associate with this schedule.

time_zone: String

The time zone used when interpreting rotation times.

additional_properties: BTreeMap<String, Value>

Implementations

impl ScheduleUpdateRequestDataAttributes

pub fn new( layers: Vec<ScheduleUpdateRequestDataAttributesLayersItems>, name: String, time_zone: String, ) -> ScheduleUpdateRequestDataAttributes

Examples found in repository

examples/v2_on-call_UpdateOnCallSchedule.rs (lines 37-85)

async fn main() {
    // there is a valid "schedule" in the system
    let schedule_data_id = std::env::var("SCHEDULE_DATA_ID").unwrap();
    let schedule_data_relationships_layers_data_0_id =
        std::env::var("SCHEDULE_DATA_RELATIONSHIPS_LAYERS_DATA_0_ID").unwrap();

    // 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 =
        ScheduleUpdateRequest::new(
            ScheduleUpdateRequestData::new(
                ScheduleUpdateRequestDataAttributes::new(
                    vec![
                        ScheduleUpdateRequestDataAttributesLayersItems::new()
                            .effective_date(
                                DateTime::parse_from_rfc3339("2021-11-01T11: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),
                            )
                            .id(schedule_data_relationships_layers_data_0_id.clone())
                            .interval(ScheduleUpdateRequestDataAttributesLayersItemsInterval::new().seconds(300))
                            .members(
                                vec![
                                    ScheduleUpdateRequestDataAttributesLayersItemsMembersItems
                                    ::new().user(
                                        ScheduleUpdateRequestDataAttributesLayersItemsMembersItemsUser
                                        ::new().id(user_data_id.clone()),
                                    )
                                ],
                            )
                            .name("Layer 1".to_string())
                            .restrictions(
                                vec![
                                    ScheduleUpdateRequestDataAttributesLayersItemsRestrictionsItems::new()
                                        .end_day(
                                            ScheduleUpdateRequestDataAttributesLayersItemsRestrictionsItemsEndDay
                                            ::FRIDAY,
                                        )
                                        .end_time("17:00:00".to_string())
                                        .start_day(
                                            ScheduleUpdateRequestDataAttributesLayersItemsRestrictionsItemsStartDay
                                            ::MONDAY,
                                        )
                                        .start_time("09:00:00".to_string())
                                ],
                            )
                            .rotation_start(
                                DateTime::parse_from_rfc3339("2021-11-06T11:11:11+00:00")
                                    .expect("Failed to parse datetime")
                                    .with_timezone(&Utc),
                            )
                    ],
                    "Example-On-Call".to_string(),
                    "America/New_York".to_string(),
                ).tags(vec!["tag1".to_string(), "tag2".to_string(), "tag3".to_string()]),
                schedule_data_id.clone(),
                ScheduleUpdateRequestDataType::SCHEDULES,
            ).relationships(
                ScheduleUpdateRequestDataRelationships
                ::new().teams(
                    ScheduleUpdateRequestDataRelationshipsTeams
                    ::new().data(
                        vec![
                            ScheduleUpdateRequestDataRelationshipsTeamsDataItems::new()
                                .id(team_data_id.clone())
                                .type_(ScheduleUpdateRequestDataRelationshipsTeamsDataItemsType::TEAMS)
                        ],
                    ),
                ),
            ),
        );
    let configuration = datadog::Configuration::new();
    let api = OnCallAPI::with_config(configuration);
    let resp = api
        .update_on_call_schedule(
            schedule_data_id.clone(),
            body,
            UpdateOnCallScheduleOptionalParams::default(),
        )
        .await;
    if let Ok(value) = resp {
        println!("{:#?}", value);
    } else {
        println!("{:#?}", resp.unwrap_err());
    }
}

pub fn tags(self, value: Vec<String>) -> Self

Examples found in repository

examples/v2_on-call_UpdateOnCallSchedule.rs (line 85)

async fn main() {
    // there is a valid "schedule" in the system
    let schedule_data_id = std::env::var("SCHEDULE_DATA_ID").unwrap();
    let schedule_data_relationships_layers_data_0_id =
        std::env::var("SCHEDULE_DATA_RELATIONSHIPS_LAYERS_DATA_0_ID").unwrap();

    // 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 =
        ScheduleUpdateRequest::new(
            ScheduleUpdateRequestData::new(
                ScheduleUpdateRequestDataAttributes::new(
                    vec![
                        ScheduleUpdateRequestDataAttributesLayersItems::new()
                            .effective_date(
                                DateTime::parse_from_rfc3339("2021-11-01T11: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),
                            )
                            .id(schedule_data_relationships_layers_data_0_id.clone())
                            .interval(ScheduleUpdateRequestDataAttributesLayersItemsInterval::new().seconds(300))
                            .members(
                                vec![
                                    ScheduleUpdateRequestDataAttributesLayersItemsMembersItems
                                    ::new().user(
                                        ScheduleUpdateRequestDataAttributesLayersItemsMembersItemsUser
                                        ::new().id(user_data_id.clone()),
                                    )
                                ],
                            )
                            .name("Layer 1".to_string())
                            .restrictions(
                                vec![
                                    ScheduleUpdateRequestDataAttributesLayersItemsRestrictionsItems::new()
                                        .end_day(
                                            ScheduleUpdateRequestDataAttributesLayersItemsRestrictionsItemsEndDay
                                            ::FRIDAY,
                                        )
                                        .end_time("17:00:00".to_string())
                                        .start_day(
                                            ScheduleUpdateRequestDataAttributesLayersItemsRestrictionsItemsStartDay
                                            ::MONDAY,
                                        )
                                        .start_time("09:00:00".to_string())
                                ],
                            )
                            .rotation_start(
                                DateTime::parse_from_rfc3339("2021-11-06T11:11:11+00:00")
                                    .expect("Failed to parse datetime")
                                    .with_timezone(&Utc),
                            )
                    ],
                    "Example-On-Call".to_string(),
                    "America/New_York".to_string(),
                ).tags(vec!["tag1".to_string(), "tag2".to_string(), "tag3".to_string()]),
                schedule_data_id.clone(),
                ScheduleUpdateRequestDataType::SCHEDULES,
            ).relationships(
                ScheduleUpdateRequestDataRelationships
                ::new().teams(
                    ScheduleUpdateRequestDataRelationshipsTeams
                    ::new().data(
                        vec![
                            ScheduleUpdateRequestDataRelationshipsTeamsDataItems::new()
                                .id(team_data_id.clone())
                                .type_(ScheduleUpdateRequestDataRelationshipsTeamsDataItemsType::TEAMS)
                        ],
                    ),
                ),
            ),
        );
    let configuration = datadog::Configuration::new();
    let api = OnCallAPI::with_config(configuration);
    let resp = api
        .update_on_call_schedule(
            schedule_data_id.clone(),
            body,
            UpdateOnCallScheduleOptionalParams::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 ScheduleUpdateRequestDataAttributes

fn clone(&self) -> ScheduleUpdateRequestDataAttributes

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for ScheduleUpdateRequestDataAttributes

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ScheduleUpdateRequestDataAttributes

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

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for ScheduleUpdateRequestDataAttributes

fn eq(&self, other: &ScheduleUpdateRequestDataAttributes) -> 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 ScheduleUpdateRequestDataAttributes

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 ScheduleUpdateRequestDataAttributes