Struct ScheduleCreateRequestDataAttributes

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

Describes the main attributes for creating a new schedule, including name, layers, time zone, and tags.

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<ScheduleCreateRequestDataAttributesLayersItems>

The layers of on-call coverage that define rotation intervals and restrictions.

name: String

A human-readable name for the new schedule.

tags: Option<Vec<String>>

A list of tags for categorizing or filtering the schedule.

time_zone: String

The time zone in which the schedule is defined.

additional_properties: BTreeMap<String, Value>

Implementations

impl ScheduleCreateRequestDataAttributes

pub fn new( layers: Vec<ScheduleCreateRequestDataAttributesLayersItems>, name: String, time_zone: String, ) -> ScheduleCreateRequestDataAttributes

Examples found in repository

examples/v2_on-call_CreateOnCallSchedule.rs (lines 32-74)

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 tags(self, value: Vec<String>) -> Self

Examples found in repository

examples/v2_on-call_CreateOnCallSchedule.rs (line 74)

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 ScheduleCreateRequestDataAttributes

fn clone(&self) -> ScheduleCreateRequestDataAttributes

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for ScheduleCreateRequestDataAttributes

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ScheduleCreateRequestDataAttributes

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

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for ScheduleCreateRequestDataAttributes

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

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 ScheduleCreateRequestDataAttributes