TimeRestriction

datadog_api_client::datadogV2::model::model_time_restriction

Struct TimeRestriction 

Source 
#[non_exhaustive]
pub struct TimeRestriction {
    pub end_day: Option<Weekday>,
    pub end_time: Option<String>,
    pub start_day: Option<Weekday>,
    pub start_time: Option<String>,
    pub additional_properties: BTreeMap<String, Value>,
    /* private fields */
}
Expand description

Defines a single time restriction rule with start and end times and the applicable weekdays.

Fields (Non-exhaustive)§

This struct is marked as 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.
§end_day: Option<Weekday>

A day of the week.

§end_time: Option<String>

Specifies the ending time for this restriction.

§start_day: Option<Weekday>

A day of the week.

§start_time: Option<String>

Specifies the starting time for this restriction.

§additional_properties: BTreeMap<String, Value>

Implementations§

Source§

impl TimeRestriction

Source

pub fn new() -> TimeRestriction

Examples found in repository?
examples/v2_on-call_CreateOnCallSchedule.rs (line 52)
22async fn main() {
23    // there is a valid "user" in the system
24    let user_data_id = std::env::var("USER_DATA_ID").unwrap();
25
26    // there is a valid "dd_team" in the system
27    let dd_team_data_id = std::env::var("DD_TEAM_DATA_ID").unwrap();
28    let body = ScheduleCreateRequest::new(
29        ScheduleCreateRequestData::new(
30            ScheduleCreateRequestDataAttributes::new(
31                vec![ScheduleCreateRequestDataAttributesLayersItems::new(
32                    DateTime::parse_from_rfc3339("2021-11-01T11:11:11+00:00")
33                        .expect("Failed to parse datetime")
34                        .with_timezone(&Utc),
35                    LayerAttributesInterval::new().days(1),
36                    vec![
37                        ScheduleRequestDataAttributesLayersItemsMembersItems::new().user(
38                            ScheduleRequestDataAttributesLayersItemsMembersItemsUser::new()
39                                .id(user_data_id.clone()),
40                        ),
41                    ],
42                    "Layer 1".to_string(),
43                    DateTime::parse_from_rfc3339("2021-11-06T11:11:11+00:00")
44                        .expect("Failed to parse datetime")
45                        .with_timezone(&Utc),
46                )
47                .end_date(
48                    DateTime::parse_from_rfc3339("2021-11-21T11:11:11+00:00")
49                        .expect("Failed to parse datetime")
50                        .with_timezone(&Utc),
51                )
52                .restrictions(vec![TimeRestriction::new()
53                    .end_day(Weekday::FRIDAY)
54                    .end_time("17:00:00".to_string())
55                    .start_day(Weekday::MONDAY)
56                    .start_time("09:00:00".to_string())])],
57                "Example-On-Call".to_string(),
58                "America/New_York".to_string(),
59            ),
60            ScheduleCreateRequestDataType::SCHEDULES,
61        )
62        .relationships(ScheduleCreateRequestDataRelationships::new().teams(
63            DataRelationshipsTeams::new().data(vec![DataRelationshipsTeamsDataItems::new(
64                dd_team_data_id.clone(),
65                DataRelationshipsTeamsDataItemsType::TEAMS,
66            )]),
67        )),
68    );
69    let configuration = datadog::Configuration::new();
70    let api = OnCallAPI::with_config(configuration);
71    let resp = api
72        .create_on_call_schedule(body, CreateOnCallScheduleOptionalParams::default())
73        .await;
74    if let Ok(value) = resp {
75        println!("{:#?}", value);
76    } else {
77        println!("{:#?}", resp.unwrap_err());
78    }
79}
More examples
Hide additional examples
examples/v2_on-call_UpdateOnCallSchedule.rs (line 58)
22async fn main() {
23    // there is a valid "schedule" in the system
24    let schedule_data_id = std::env::var("SCHEDULE_DATA_ID").unwrap();
25    let schedule_data_relationships_layers_data_0_id =
26        std::env::var("SCHEDULE_DATA_RELATIONSHIPS_LAYERS_DATA_0_ID").unwrap();
27
28    // there is a valid "user" in the system
29    let user_data_id = std::env::var("USER_DATA_ID").unwrap();
30
31    // there is a valid "dd_team" in the system
32    let dd_team_data_id = std::env::var("DD_TEAM_DATA_ID").unwrap();
33    let body = ScheduleUpdateRequest::new(
34        ScheduleUpdateRequestData::new(
35            ScheduleUpdateRequestDataAttributes::new(
36                vec![ScheduleUpdateRequestDataAttributesLayersItems::new(
37                    DateTime::parse_from_rfc3339("2021-11-01T11:11:11+00:00")
38                        .expect("Failed to parse datetime")
39                        .with_timezone(&Utc),
40                    LayerAttributesInterval::new().seconds(3600),
41                    vec![
42                        ScheduleRequestDataAttributesLayersItemsMembersItems::new().user(
43                            ScheduleRequestDataAttributesLayersItemsMembersItemsUser::new()
44                                .id(user_data_id.clone()),
45                        ),
46                    ],
47                    "Layer 1".to_string(),
48                    DateTime::parse_from_rfc3339("2021-11-06T11:11:11+00:00")
49                        .expect("Failed to parse datetime")
50                        .with_timezone(&Utc),
51                )
52                .end_date(
53                    DateTime::parse_from_rfc3339("2021-11-21T11:11:11+00:00")
54                        .expect("Failed to parse datetime")
55                        .with_timezone(&Utc),
56                )
57                .id(schedule_data_relationships_layers_data_0_id.clone())
58                .restrictions(vec![TimeRestriction::new()
59                    .end_day(Weekday::FRIDAY)
60                    .end_time("17:00:00".to_string())
61                    .start_day(Weekday::MONDAY)
62                    .start_time("09:00:00".to_string())])],
63                "Example-On-Call".to_string(),
64                "America/New_York".to_string(),
65            ),
66            schedule_data_id.clone(),
67            ScheduleUpdateRequestDataType::SCHEDULES,
68        )
69        .relationships(ScheduleUpdateRequestDataRelationships::new().teams(
70            DataRelationshipsTeams::new().data(vec![DataRelationshipsTeamsDataItems::new(
71                dd_team_data_id.clone(),
72                DataRelationshipsTeamsDataItemsType::TEAMS,
73            )]),
74        )),
75    );
76    let configuration = datadog::Configuration::new();
77    let api = OnCallAPI::with_config(configuration);
78    let resp = api
79        .update_on_call_schedule(
80            schedule_data_id.clone(),
81            body,
82            UpdateOnCallScheduleOptionalParams::default(),
83        )
84        .await;
85    if let Ok(value) = resp {
86        println!("{:#?}", value);
87    } else {
88        println!("{:#?}", resp.unwrap_err());
89    }
90}
examples/v2_on-call_SetOnCallTeamRoutingRules.rs (line 46)
19async fn main() {
20    // there is a valid "dd_team" in the system
21    let dd_team_data_id = std::env::var("DD_TEAM_DATA_ID").unwrap();
22
23    // there is a valid "escalation_policy" in the system
24    let escalation_policy_data_id = std::env::var("ESCALATION_POLICY_DATA_ID").unwrap();
25    let body = TeamRoutingRulesRequest::new().data(
26        TeamRoutingRulesRequestData::new(TeamRoutingRulesRequestDataType::TEAM_ROUTING_RULES)
27            .attributes(TeamRoutingRulesRequestDataAttributes::new().rules(vec![
28                            TeamRoutingRulesRequestRule::new()
29                                .actions(
30                                    vec![
31                                        RoutingRuleAction::SendSlackMessageAction(
32                                            Box::new(
33                                                SendSlackMessageAction::new(
34                                                    "channel".to_string(),
35                                                    SendSlackMessageActionType::SEND_SLACK_MESSAGE,
36                                                    "workspace".to_string(),
37                                                ),
38                                            ),
39                                        )
40                                    ],
41                                )
42                                .query("tags.service:test".to_string())
43                                .time_restriction(
44                                    TimeRestrictions::new(
45                                        vec![
46                                            TimeRestriction::new()
47                                                .end_day(Weekday::MONDAY)
48                                                .end_time("17:00:00".to_string())
49                                                .start_day(Weekday::MONDAY)
50                                                .start_time("09:00:00".to_string()),
51                                            TimeRestriction::new()
52                                                .end_day(Weekday::TUESDAY)
53                                                .end_time("17:00:00".to_string())
54                                                .start_day(Weekday::TUESDAY)
55                                                .start_time("09:00:00".to_string())
56                                        ],
57                                        "Europe/Paris".to_string(),
58                                    ),
59                                ),
60                            TeamRoutingRulesRequestRule::new()
61                                .policy_id(escalation_policy_data_id.clone())
62                                .query("".to_string())
63                                .urgency(Urgency::LOW)
64                        ]))
65            .id(dd_team_data_id.clone()),
66    );
67    let configuration = datadog::Configuration::new();
68    let api = OnCallAPI::with_config(configuration);
69    let resp = api
70        .set_on_call_team_routing_rules(
71            dd_team_data_id.clone(),
72            body,
73            SetOnCallTeamRoutingRulesOptionalParams::default().include("rules".to_string()),
74        )
75        .await;
76    if let Ok(value) = resp {
77        println!("{:#?}", value);
78    } else {
79        println!("{:#?}", resp.unwrap_err());
80    }
81}
Source

pub fn end_day(self, value: Weekday) -> Self

Examples found in repository?
examples/v2_on-call_CreateOnCallSchedule.rs (line 53)
22async fn main() {
23    // there is a valid "user" in the system
24    let user_data_id = std::env::var("USER_DATA_ID").unwrap();
25
26    // there is a valid "dd_team" in the system
27    let dd_team_data_id = std::env::var("DD_TEAM_DATA_ID").unwrap();
28    let body = ScheduleCreateRequest::new(
29        ScheduleCreateRequestData::new(
30            ScheduleCreateRequestDataAttributes::new(
31                vec![ScheduleCreateRequestDataAttributesLayersItems::new(
32                    DateTime::parse_from_rfc3339("2021-11-01T11:11:11+00:00")
33                        .expect("Failed to parse datetime")
34                        .with_timezone(&Utc),
35                    LayerAttributesInterval::new().days(1),
36                    vec![
37                        ScheduleRequestDataAttributesLayersItemsMembersItems::new().user(
38                            ScheduleRequestDataAttributesLayersItemsMembersItemsUser::new()
39                                .id(user_data_id.clone()),
40                        ),
41                    ],
42                    "Layer 1".to_string(),
43                    DateTime::parse_from_rfc3339("2021-11-06T11:11:11+00:00")
44                        .expect("Failed to parse datetime")
45                        .with_timezone(&Utc),
46                )
47                .end_date(
48                    DateTime::parse_from_rfc3339("2021-11-21T11:11:11+00:00")
49                        .expect("Failed to parse datetime")
50                        .with_timezone(&Utc),
51                )
52                .restrictions(vec![TimeRestriction::new()
53                    .end_day(Weekday::FRIDAY)
54                    .end_time("17:00:00".to_string())
55                    .start_day(Weekday::MONDAY)
56                    .start_time("09:00:00".to_string())])],
57                "Example-On-Call".to_string(),
58                "America/New_York".to_string(),
59            ),
60            ScheduleCreateRequestDataType::SCHEDULES,
61        )
62        .relationships(ScheduleCreateRequestDataRelationships::new().teams(
63            DataRelationshipsTeams::new().data(vec![DataRelationshipsTeamsDataItems::new(
64                dd_team_data_id.clone(),
65                DataRelationshipsTeamsDataItemsType::TEAMS,
66            )]),
67        )),
68    );
69    let configuration = datadog::Configuration::new();
70    let api = OnCallAPI::with_config(configuration);
71    let resp = api
72        .create_on_call_schedule(body, CreateOnCallScheduleOptionalParams::default())
73        .await;
74    if let Ok(value) = resp {
75        println!("{:#?}", value);
76    } else {
77        println!("{:#?}", resp.unwrap_err());
78    }
79}
More examples
Hide additional examples
examples/v2_on-call_UpdateOnCallSchedule.rs (line 59)
22async fn main() {
23    // there is a valid "schedule" in the system
24    let schedule_data_id = std::env::var("SCHEDULE_DATA_ID").unwrap();
25    let schedule_data_relationships_layers_data_0_id =
26        std::env::var("SCHEDULE_DATA_RELATIONSHIPS_LAYERS_DATA_0_ID").unwrap();
27
28    // there is a valid "user" in the system
29    let user_data_id = std::env::var("USER_DATA_ID").unwrap();
30
31    // there is a valid "dd_team" in the system
32    let dd_team_data_id = std::env::var("DD_TEAM_DATA_ID").unwrap();
33    let body = ScheduleUpdateRequest::new(
34        ScheduleUpdateRequestData::new(
35            ScheduleUpdateRequestDataAttributes::new(
36                vec![ScheduleUpdateRequestDataAttributesLayersItems::new(
37                    DateTime::parse_from_rfc3339("2021-11-01T11:11:11+00:00")
38                        .expect("Failed to parse datetime")
39                        .with_timezone(&Utc),
40                    LayerAttributesInterval::new().seconds(3600),
41                    vec![
42                        ScheduleRequestDataAttributesLayersItemsMembersItems::new().user(
43                            ScheduleRequestDataAttributesLayersItemsMembersItemsUser::new()
44                                .id(user_data_id.clone()),
45                        ),
46                    ],
47                    "Layer 1".to_string(),
48                    DateTime::parse_from_rfc3339("2021-11-06T11:11:11+00:00")
49                        .expect("Failed to parse datetime")
50                        .with_timezone(&Utc),
51                )
52                .end_date(
53                    DateTime::parse_from_rfc3339("2021-11-21T11:11:11+00:00")
54                        .expect("Failed to parse datetime")
55                        .with_timezone(&Utc),
56                )
57                .id(schedule_data_relationships_layers_data_0_id.clone())
58                .restrictions(vec![TimeRestriction::new()
59                    .end_day(Weekday::FRIDAY)
60                    .end_time("17:00:00".to_string())
61                    .start_day(Weekday::MONDAY)
62                    .start_time("09:00:00".to_string())])],
63                "Example-On-Call".to_string(),
64                "America/New_York".to_string(),
65            ),
66            schedule_data_id.clone(),
67            ScheduleUpdateRequestDataType::SCHEDULES,
68        )
69        .relationships(ScheduleUpdateRequestDataRelationships::new().teams(
70            DataRelationshipsTeams::new().data(vec![DataRelationshipsTeamsDataItems::new(
71                dd_team_data_id.clone(),
72                DataRelationshipsTeamsDataItemsType::TEAMS,
73            )]),
74        )),
75    );
76    let configuration = datadog::Configuration::new();
77    let api = OnCallAPI::with_config(configuration);
78    let resp = api
79        .update_on_call_schedule(
80            schedule_data_id.clone(),
81            body,
82            UpdateOnCallScheduleOptionalParams::default(),
83        )
84        .await;
85    if let Ok(value) = resp {
86        println!("{:#?}", value);
87    } else {
88        println!("{:#?}", resp.unwrap_err());
89    }
90}
examples/v2_on-call_SetOnCallTeamRoutingRules.rs (line 47)
19async fn main() {
20    // there is a valid "dd_team" in the system
21    let dd_team_data_id = std::env::var("DD_TEAM_DATA_ID").unwrap();
22
23    // there is a valid "escalation_policy" in the system
24    let escalation_policy_data_id = std::env::var("ESCALATION_POLICY_DATA_ID").unwrap();
25    let body = TeamRoutingRulesRequest::new().data(
26        TeamRoutingRulesRequestData::new(TeamRoutingRulesRequestDataType::TEAM_ROUTING_RULES)
27            .attributes(TeamRoutingRulesRequestDataAttributes::new().rules(vec![
28                            TeamRoutingRulesRequestRule::new()
29                                .actions(
30                                    vec![
31                                        RoutingRuleAction::SendSlackMessageAction(
32                                            Box::new(
33                                                SendSlackMessageAction::new(
34                                                    "channel".to_string(),
35                                                    SendSlackMessageActionType::SEND_SLACK_MESSAGE,
36                                                    "workspace".to_string(),
37                                                ),
38                                            ),
39                                        )
40                                    ],
41                                )
42                                .query("tags.service:test".to_string())
43                                .time_restriction(
44                                    TimeRestrictions::new(
45                                        vec![
46                                            TimeRestriction::new()
47                                                .end_day(Weekday::MONDAY)
48                                                .end_time("17:00:00".to_string())
49                                                .start_day(Weekday::MONDAY)
50                                                .start_time("09:00:00".to_string()),
51                                            TimeRestriction::new()
52                                                .end_day(Weekday::TUESDAY)
53                                                .end_time("17:00:00".to_string())
54                                                .start_day(Weekday::TUESDAY)
55                                                .start_time("09:00:00".to_string())
56                                        ],
57                                        "Europe/Paris".to_string(),
58                                    ),
59                                ),
60                            TeamRoutingRulesRequestRule::new()
61                                .policy_id(escalation_policy_data_id.clone())
62                                .query("".to_string())
63                                .urgency(Urgency::LOW)
64                        ]))
65            .id(dd_team_data_id.clone()),
66    );
67    let configuration = datadog::Configuration::new();
68    let api = OnCallAPI::with_config(configuration);
69    let resp = api
70        .set_on_call_team_routing_rules(
71            dd_team_data_id.clone(),
72            body,
73            SetOnCallTeamRoutingRulesOptionalParams::default().include("rules".to_string()),
74        )
75        .await;
76    if let Ok(value) = resp {
77        println!("{:#?}", value);
78    } else {
79        println!("{:#?}", resp.unwrap_err());
80    }
81}
Source

pub fn end_time(self, value: String) -> Self

Examples found in repository?
examples/v2_on-call_CreateOnCallSchedule.rs (line 54)
22async fn main() {
23    // there is a valid "user" in the system
24    let user_data_id = std::env::var("USER_DATA_ID").unwrap();
25
26    // there is a valid "dd_team" in the system
27    let dd_team_data_id = std::env::var("DD_TEAM_DATA_ID").unwrap();
28    let body = ScheduleCreateRequest::new(
29        ScheduleCreateRequestData::new(
30            ScheduleCreateRequestDataAttributes::new(
31                vec![ScheduleCreateRequestDataAttributesLayersItems::new(
32                    DateTime::parse_from_rfc3339("2021-11-01T11:11:11+00:00")
33                        .expect("Failed to parse datetime")
34                        .with_timezone(&Utc),
35                    LayerAttributesInterval::new().days(1),
36                    vec![
37                        ScheduleRequestDataAttributesLayersItemsMembersItems::new().user(
38                            ScheduleRequestDataAttributesLayersItemsMembersItemsUser::new()
39                                .id(user_data_id.clone()),
40                        ),
41                    ],
42                    "Layer 1".to_string(),
43                    DateTime::parse_from_rfc3339("2021-11-06T11:11:11+00:00")
44                        .expect("Failed to parse datetime")
45                        .with_timezone(&Utc),
46                )
47                .end_date(
48                    DateTime::parse_from_rfc3339("2021-11-21T11:11:11+00:00")
49                        .expect("Failed to parse datetime")
50                        .with_timezone(&Utc),
51                )
52                .restrictions(vec![TimeRestriction::new()
53                    .end_day(Weekday::FRIDAY)
54                    .end_time("17:00:00".to_string())
55                    .start_day(Weekday::MONDAY)
56                    .start_time("09:00:00".to_string())])],
57                "Example-On-Call".to_string(),
58                "America/New_York".to_string(),
59            ),
60            ScheduleCreateRequestDataType::SCHEDULES,
61        )
62        .relationships(ScheduleCreateRequestDataRelationships::new().teams(
63            DataRelationshipsTeams::new().data(vec![DataRelationshipsTeamsDataItems::new(
64                dd_team_data_id.clone(),
65                DataRelationshipsTeamsDataItemsType::TEAMS,
66            )]),
67        )),
68    );
69    let configuration = datadog::Configuration::new();
70    let api = OnCallAPI::with_config(configuration);
71    let resp = api
72        .create_on_call_schedule(body, CreateOnCallScheduleOptionalParams::default())
73        .await;
74    if let Ok(value) = resp {
75        println!("{:#?}", value);
76    } else {
77        println!("{:#?}", resp.unwrap_err());
78    }
79}
More examples
Hide additional examples
examples/v2_on-call_UpdateOnCallSchedule.rs (line 60)
22async fn main() {
23    // there is a valid "schedule" in the system
24    let schedule_data_id = std::env::var("SCHEDULE_DATA_ID").unwrap();
25    let schedule_data_relationships_layers_data_0_id =
26        std::env::var("SCHEDULE_DATA_RELATIONSHIPS_LAYERS_DATA_0_ID").unwrap();
27
28    // there is a valid "user" in the system
29    let user_data_id = std::env::var("USER_DATA_ID").unwrap();
30
31    // there is a valid "dd_team" in the system
32    let dd_team_data_id = std::env::var("DD_TEAM_DATA_ID").unwrap();
33    let body = ScheduleUpdateRequest::new(
34        ScheduleUpdateRequestData::new(
35            ScheduleUpdateRequestDataAttributes::new(
36                vec![ScheduleUpdateRequestDataAttributesLayersItems::new(
37                    DateTime::parse_from_rfc3339("2021-11-01T11:11:11+00:00")
38                        .expect("Failed to parse datetime")
39                        .with_timezone(&Utc),
40                    LayerAttributesInterval::new().seconds(3600),
41                    vec![
42                        ScheduleRequestDataAttributesLayersItemsMembersItems::new().user(
43                            ScheduleRequestDataAttributesLayersItemsMembersItemsUser::new()
44                                .id(user_data_id.clone()),
45                        ),
46                    ],
47                    "Layer 1".to_string(),
48                    DateTime::parse_from_rfc3339("2021-11-06T11:11:11+00:00")
49                        .expect("Failed to parse datetime")
50                        .with_timezone(&Utc),
51                )
52                .end_date(
53                    DateTime::parse_from_rfc3339("2021-11-21T11:11:11+00:00")
54                        .expect("Failed to parse datetime")
55                        .with_timezone(&Utc),
56                )
57                .id(schedule_data_relationships_layers_data_0_id.clone())
58                .restrictions(vec![TimeRestriction::new()
59                    .end_day(Weekday::FRIDAY)
60                    .end_time("17:00:00".to_string())
61                    .start_day(Weekday::MONDAY)
62                    .start_time("09:00:00".to_string())])],
63                "Example-On-Call".to_string(),
64                "America/New_York".to_string(),
65            ),
66            schedule_data_id.clone(),
67            ScheduleUpdateRequestDataType::SCHEDULES,
68        )
69        .relationships(ScheduleUpdateRequestDataRelationships::new().teams(
70            DataRelationshipsTeams::new().data(vec![DataRelationshipsTeamsDataItems::new(
71                dd_team_data_id.clone(),
72                DataRelationshipsTeamsDataItemsType::TEAMS,
73            )]),
74        )),
75    );
76    let configuration = datadog::Configuration::new();
77    let api = OnCallAPI::with_config(configuration);
78    let resp = api
79        .update_on_call_schedule(
80            schedule_data_id.clone(),
81            body,
82            UpdateOnCallScheduleOptionalParams::default(),
83        )
84        .await;
85    if let Ok(value) = resp {
86        println!("{:#?}", value);
87    } else {
88        println!("{:#?}", resp.unwrap_err());
89    }
90}
examples/v2_on-call_SetOnCallTeamRoutingRules.rs (line 48)
19async fn main() {
20    // there is a valid "dd_team" in the system
21    let dd_team_data_id = std::env::var("DD_TEAM_DATA_ID").unwrap();
22
23    // there is a valid "escalation_policy" in the system
24    let escalation_policy_data_id = std::env::var("ESCALATION_POLICY_DATA_ID").unwrap();
25    let body = TeamRoutingRulesRequest::new().data(
26        TeamRoutingRulesRequestData::new(TeamRoutingRulesRequestDataType::TEAM_ROUTING_RULES)
27            .attributes(TeamRoutingRulesRequestDataAttributes::new().rules(vec![
28                            TeamRoutingRulesRequestRule::new()
29                                .actions(
30                                    vec![
31                                        RoutingRuleAction::SendSlackMessageAction(
32                                            Box::new(
33                                                SendSlackMessageAction::new(
34                                                    "channel".to_string(),
35                                                    SendSlackMessageActionType::SEND_SLACK_MESSAGE,
36                                                    "workspace".to_string(),
37                                                ),
38                                            ),
39                                        )
40                                    ],
41                                )
42                                .query("tags.service:test".to_string())
43                                .time_restriction(
44                                    TimeRestrictions::new(
45                                        vec![
46                                            TimeRestriction::new()
47                                                .end_day(Weekday::MONDAY)
48                                                .end_time("17:00:00".to_string())
49                                                .start_day(Weekday::MONDAY)
50                                                .start_time("09:00:00".to_string()),
51                                            TimeRestriction::new()
52                                                .end_day(Weekday::TUESDAY)
53                                                .end_time("17:00:00".to_string())
54                                                .start_day(Weekday::TUESDAY)
55                                                .start_time("09:00:00".to_string())
56                                        ],
57                                        "Europe/Paris".to_string(),
58                                    ),
59                                ),
60                            TeamRoutingRulesRequestRule::new()
61                                .policy_id(escalation_policy_data_id.clone())
62                                .query("".to_string())
63                                .urgency(Urgency::LOW)
64                        ]))
65            .id(dd_team_data_id.clone()),
66    );
67    let configuration = datadog::Configuration::new();
68    let api = OnCallAPI::with_config(configuration);
69    let resp = api
70        .set_on_call_team_routing_rules(
71            dd_team_data_id.clone(),
72            body,
73            SetOnCallTeamRoutingRulesOptionalParams::default().include("rules".to_string()),
74        )
75        .await;
76    if let Ok(value) = resp {
77        println!("{:#?}", value);
78    } else {
79        println!("{:#?}", resp.unwrap_err());
80    }
81}
Source

pub fn start_day(self, value: Weekday) -> Self

Examples found in repository?
examples/v2_on-call_CreateOnCallSchedule.rs (line 55)
22async fn main() {
23    // there is a valid "user" in the system
24    let user_data_id = std::env::var("USER_DATA_ID").unwrap();
25
26    // there is a valid "dd_team" in the system
27    let dd_team_data_id = std::env::var("DD_TEAM_DATA_ID").unwrap();
28    let body = ScheduleCreateRequest::new(
29        ScheduleCreateRequestData::new(
30            ScheduleCreateRequestDataAttributes::new(
31                vec![ScheduleCreateRequestDataAttributesLayersItems::new(
32                    DateTime::parse_from_rfc3339("2021-11-01T11:11:11+00:00")
33                        .expect("Failed to parse datetime")
34                        .with_timezone(&Utc),
35                    LayerAttributesInterval::new().days(1),
36                    vec![
37                        ScheduleRequestDataAttributesLayersItemsMembersItems::new().user(
38                            ScheduleRequestDataAttributesLayersItemsMembersItemsUser::new()
39                                .id(user_data_id.clone()),
40                        ),
41                    ],
42                    "Layer 1".to_string(),
43                    DateTime::parse_from_rfc3339("2021-11-06T11:11:11+00:00")
44                        .expect("Failed to parse datetime")
45                        .with_timezone(&Utc),
46                )
47                .end_date(
48                    DateTime::parse_from_rfc3339("2021-11-21T11:11:11+00:00")
49                        .expect("Failed to parse datetime")
50                        .with_timezone(&Utc),
51                )
52                .restrictions(vec![TimeRestriction::new()
53                    .end_day(Weekday::FRIDAY)
54                    .end_time("17:00:00".to_string())
55                    .start_day(Weekday::MONDAY)
56                    .start_time("09:00:00".to_string())])],
57                "Example-On-Call".to_string(),
58                "America/New_York".to_string(),
59            ),
60            ScheduleCreateRequestDataType::SCHEDULES,
61        )
62        .relationships(ScheduleCreateRequestDataRelationships::new().teams(
63            DataRelationshipsTeams::new().data(vec![DataRelationshipsTeamsDataItems::new(
64                dd_team_data_id.clone(),
65                DataRelationshipsTeamsDataItemsType::TEAMS,
66            )]),
67        )),
68    );
69    let configuration = datadog::Configuration::new();
70    let api = OnCallAPI::with_config(configuration);
71    let resp = api
72        .create_on_call_schedule(body, CreateOnCallScheduleOptionalParams::default())
73        .await;
74    if let Ok(value) = resp {
75        println!("{:#?}", value);
76    } else {
77        println!("{:#?}", resp.unwrap_err());
78    }
79}
More examples
Hide additional examples
examples/v2_on-call_UpdateOnCallSchedule.rs (line 61)
22async fn main() {
23    // there is a valid "schedule" in the system
24    let schedule_data_id = std::env::var("SCHEDULE_DATA_ID").unwrap();
25    let schedule_data_relationships_layers_data_0_id =
26        std::env::var("SCHEDULE_DATA_RELATIONSHIPS_LAYERS_DATA_0_ID").unwrap();
27
28    // there is a valid "user" in the system
29    let user_data_id = std::env::var("USER_DATA_ID").unwrap();
30
31    // there is a valid "dd_team" in the system
32    let dd_team_data_id = std::env::var("DD_TEAM_DATA_ID").unwrap();
33    let body = ScheduleUpdateRequest::new(
34        ScheduleUpdateRequestData::new(
35            ScheduleUpdateRequestDataAttributes::new(
36                vec![ScheduleUpdateRequestDataAttributesLayersItems::new(
37                    DateTime::parse_from_rfc3339("2021-11-01T11:11:11+00:00")
38                        .expect("Failed to parse datetime")
39                        .with_timezone(&Utc),
40                    LayerAttributesInterval::new().seconds(3600),
41                    vec![
42                        ScheduleRequestDataAttributesLayersItemsMembersItems::new().user(
43                            ScheduleRequestDataAttributesLayersItemsMembersItemsUser::new()
44                                .id(user_data_id.clone()),
45                        ),
46                    ],
47                    "Layer 1".to_string(),
48                    DateTime::parse_from_rfc3339("2021-11-06T11:11:11+00:00")
49                        .expect("Failed to parse datetime")
50                        .with_timezone(&Utc),
51                )
52                .end_date(
53                    DateTime::parse_from_rfc3339("2021-11-21T11:11:11+00:00")
54                        .expect("Failed to parse datetime")
55                        .with_timezone(&Utc),
56                )
57                .id(schedule_data_relationships_layers_data_0_id.clone())
58                .restrictions(vec![TimeRestriction::new()
59                    .end_day(Weekday::FRIDAY)
60                    .end_time("17:00:00".to_string())
61                    .start_day(Weekday::MONDAY)
62                    .start_time("09:00:00".to_string())])],
63                "Example-On-Call".to_string(),
64                "America/New_York".to_string(),
65            ),
66            schedule_data_id.clone(),
67            ScheduleUpdateRequestDataType::SCHEDULES,
68        )
69        .relationships(ScheduleUpdateRequestDataRelationships::new().teams(
70            DataRelationshipsTeams::new().data(vec![DataRelationshipsTeamsDataItems::new(
71                dd_team_data_id.clone(),
72                DataRelationshipsTeamsDataItemsType::TEAMS,
73            )]),
74        )),
75    );
76    let configuration = datadog::Configuration::new();
77    let api = OnCallAPI::with_config(configuration);
78    let resp = api
79        .update_on_call_schedule(
80            schedule_data_id.clone(),
81            body,
82            UpdateOnCallScheduleOptionalParams::default(),
83        )
84        .await;
85    if let Ok(value) = resp {
86        println!("{:#?}", value);
87    } else {
88        println!("{:#?}", resp.unwrap_err());
89    }
90}
examples/v2_on-call_SetOnCallTeamRoutingRules.rs (line 49)
19async fn main() {
20    // there is a valid "dd_team" in the system
21    let dd_team_data_id = std::env::var("DD_TEAM_DATA_ID").unwrap();
22
23    // there is a valid "escalation_policy" in the system
24    let escalation_policy_data_id = std::env::var("ESCALATION_POLICY_DATA_ID").unwrap();
25    let body = TeamRoutingRulesRequest::new().data(
26        TeamRoutingRulesRequestData::new(TeamRoutingRulesRequestDataType::TEAM_ROUTING_RULES)
27            .attributes(TeamRoutingRulesRequestDataAttributes::new().rules(vec![
28                            TeamRoutingRulesRequestRule::new()
29                                .actions(
30                                    vec![
31                                        RoutingRuleAction::SendSlackMessageAction(
32                                            Box::new(
33                                                SendSlackMessageAction::new(
34                                                    "channel".to_string(),
35                                                    SendSlackMessageActionType::SEND_SLACK_MESSAGE,
36                                                    "workspace".to_string(),
37                                                ),
38                                            ),
39                                        )
40                                    ],
41                                )
42                                .query("tags.service:test".to_string())
43                                .time_restriction(
44                                    TimeRestrictions::new(
45                                        vec![
46                                            TimeRestriction::new()
47                                                .end_day(Weekday::MONDAY)
48                                                .end_time("17:00:00".to_string())
49                                                .start_day(Weekday::MONDAY)
50                                                .start_time("09:00:00".to_string()),
51                                            TimeRestriction::new()
52                                                .end_day(Weekday::TUESDAY)
53                                                .end_time("17:00:00".to_string())
54                                                .start_day(Weekday::TUESDAY)
55                                                .start_time("09:00:00".to_string())
56                                        ],
57                                        "Europe/Paris".to_string(),
58                                    ),
59                                ),
60                            TeamRoutingRulesRequestRule::new()
61                                .policy_id(escalation_policy_data_id.clone())
62                                .query("".to_string())
63                                .urgency(Urgency::LOW)
64                        ]))
65            .id(dd_team_data_id.clone()),
66    );
67    let configuration = datadog::Configuration::new();
68    let api = OnCallAPI::with_config(configuration);
69    let resp = api
70        .set_on_call_team_routing_rules(
71            dd_team_data_id.clone(),
72            body,
73            SetOnCallTeamRoutingRulesOptionalParams::default().include("rules".to_string()),
74        )
75        .await;
76    if let Ok(value) = resp {
77        println!("{:#?}", value);
78    } else {
79        println!("{:#?}", resp.unwrap_err());
80    }
81}
Source

pub fn start_time(self, value: String) -> Self

Examples found in repository?
examples/v2_on-call_CreateOnCallSchedule.rs (line 56)
22async fn main() {
23    // there is a valid "user" in the system
24    let user_data_id = std::env::var("USER_DATA_ID").unwrap();
25
26    // there is a valid "dd_team" in the system
27    let dd_team_data_id = std::env::var("DD_TEAM_DATA_ID").unwrap();
28    let body = ScheduleCreateRequest::new(
29        ScheduleCreateRequestData::new(
30            ScheduleCreateRequestDataAttributes::new(
31                vec![ScheduleCreateRequestDataAttributesLayersItems::new(
32                    DateTime::parse_from_rfc3339("2021-11-01T11:11:11+00:00")
33                        .expect("Failed to parse datetime")
34                        .with_timezone(&Utc),
35                    LayerAttributesInterval::new().days(1),
36                    vec![
37                        ScheduleRequestDataAttributesLayersItemsMembersItems::new().user(
38                            ScheduleRequestDataAttributesLayersItemsMembersItemsUser::new()
39                                .id(user_data_id.clone()),
40                        ),
41                    ],
42                    "Layer 1".to_string(),
43                    DateTime::parse_from_rfc3339("2021-11-06T11:11:11+00:00")
44                        .expect("Failed to parse datetime")
45                        .with_timezone(&Utc),
46                )
47                .end_date(
48                    DateTime::parse_from_rfc3339("2021-11-21T11:11:11+00:00")
49                        .expect("Failed to parse datetime")
50                        .with_timezone(&Utc),
51                )
52                .restrictions(vec![TimeRestriction::new()
53                    .end_day(Weekday::FRIDAY)
54                    .end_time("17:00:00".to_string())
55                    .start_day(Weekday::MONDAY)
56                    .start_time("09:00:00".to_string())])],
57                "Example-On-Call".to_string(),
58                "America/New_York".to_string(),
59            ),
60            ScheduleCreateRequestDataType::SCHEDULES,
61        )
62        .relationships(ScheduleCreateRequestDataRelationships::new().teams(
63            DataRelationshipsTeams::new().data(vec![DataRelationshipsTeamsDataItems::new(
64                dd_team_data_id.clone(),
65                DataRelationshipsTeamsDataItemsType::TEAMS,
66            )]),
67        )),
68    );
69    let configuration = datadog::Configuration::new();
70    let api = OnCallAPI::with_config(configuration);
71    let resp = api
72        .create_on_call_schedule(body, CreateOnCallScheduleOptionalParams::default())
73        .await;
74    if let Ok(value) = resp {
75        println!("{:#?}", value);
76    } else {
77        println!("{:#?}", resp.unwrap_err());
78    }
79}
More examples
Hide additional examples
examples/v2_on-call_UpdateOnCallSchedule.rs (line 62)
22async fn main() {
23    // there is a valid "schedule" in the system
24    let schedule_data_id = std::env::var("SCHEDULE_DATA_ID").unwrap();
25    let schedule_data_relationships_layers_data_0_id =
26        std::env::var("SCHEDULE_DATA_RELATIONSHIPS_LAYERS_DATA_0_ID").unwrap();
27
28    // there is a valid "user" in the system
29    let user_data_id = std::env::var("USER_DATA_ID").unwrap();
30
31    // there is a valid "dd_team" in the system
32    let dd_team_data_id = std::env::var("DD_TEAM_DATA_ID").unwrap();
33    let body = ScheduleUpdateRequest::new(
34        ScheduleUpdateRequestData::new(
35            ScheduleUpdateRequestDataAttributes::new(
36                vec![ScheduleUpdateRequestDataAttributesLayersItems::new(
37                    DateTime::parse_from_rfc3339("2021-11-01T11:11:11+00:00")
38                        .expect("Failed to parse datetime")
39                        .with_timezone(&Utc),
40                    LayerAttributesInterval::new().seconds(3600),
41                    vec![
42                        ScheduleRequestDataAttributesLayersItemsMembersItems::new().user(
43                            ScheduleRequestDataAttributesLayersItemsMembersItemsUser::new()
44                                .id(user_data_id.clone()),
45                        ),
46                    ],
47                    "Layer 1".to_string(),
48                    DateTime::parse_from_rfc3339("2021-11-06T11:11:11+00:00")
49                        .expect("Failed to parse datetime")
50                        .with_timezone(&Utc),
51                )
52                .end_date(
53                    DateTime::parse_from_rfc3339("2021-11-21T11:11:11+00:00")
54                        .expect("Failed to parse datetime")
55                        .with_timezone(&Utc),
56                )
57                .id(schedule_data_relationships_layers_data_0_id.clone())
58                .restrictions(vec![TimeRestriction::new()
59                    .end_day(Weekday::FRIDAY)
60                    .end_time("17:00:00".to_string())
61                    .start_day(Weekday::MONDAY)
62                    .start_time("09:00:00".to_string())])],
63                "Example-On-Call".to_string(),
64                "America/New_York".to_string(),
65            ),
66            schedule_data_id.clone(),
67            ScheduleUpdateRequestDataType::SCHEDULES,
68        )
69        .relationships(ScheduleUpdateRequestDataRelationships::new().teams(
70            DataRelationshipsTeams::new().data(vec![DataRelationshipsTeamsDataItems::new(
71                dd_team_data_id.clone(),
72                DataRelationshipsTeamsDataItemsType::TEAMS,
73            )]),
74        )),
75    );
76    let configuration = datadog::Configuration::new();
77    let api = OnCallAPI::with_config(configuration);
78    let resp = api
79        .update_on_call_schedule(
80            schedule_data_id.clone(),
81            body,
82            UpdateOnCallScheduleOptionalParams::default(),
83        )
84        .await;
85    if let Ok(value) = resp {
86        println!("{:#?}", value);
87    } else {
88        println!("{:#?}", resp.unwrap_err());
89    }
90}
examples/v2_on-call_SetOnCallTeamRoutingRules.rs (line 50)
19async fn main() {
20    // there is a valid "dd_team" in the system
21    let dd_team_data_id = std::env::var("DD_TEAM_DATA_ID").unwrap();
22
23    // there is a valid "escalation_policy" in the system
24    let escalation_policy_data_id = std::env::var("ESCALATION_POLICY_DATA_ID").unwrap();
25    let body = TeamRoutingRulesRequest::new().data(
26        TeamRoutingRulesRequestData::new(TeamRoutingRulesRequestDataType::TEAM_ROUTING_RULES)
27            .attributes(TeamRoutingRulesRequestDataAttributes::new().rules(vec![
28                            TeamRoutingRulesRequestRule::new()
29                                .actions(
30                                    vec![
31                                        RoutingRuleAction::SendSlackMessageAction(
32                                            Box::new(
33                                                SendSlackMessageAction::new(
34                                                    "channel".to_string(),
35                                                    SendSlackMessageActionType::SEND_SLACK_MESSAGE,
36                                                    "workspace".to_string(),
37                                                ),
38                                            ),
39                                        )
40                                    ],
41                                )
42                                .query("tags.service:test".to_string())
43                                .time_restriction(
44                                    TimeRestrictions::new(
45                                        vec![
46                                            TimeRestriction::new()
47                                                .end_day(Weekday::MONDAY)
48                                                .end_time("17:00:00".to_string())
49                                                .start_day(Weekday::MONDAY)
50                                                .start_time("09:00:00".to_string()),
51                                            TimeRestriction::new()
52                                                .end_day(Weekday::TUESDAY)
53                                                .end_time("17:00:00".to_string())
54                                                .start_day(Weekday::TUESDAY)
55                                                .start_time("09:00:00".to_string())
56                                        ],
57                                        "Europe/Paris".to_string(),
58                                    ),
59                                ),
60                            TeamRoutingRulesRequestRule::new()
61                                .policy_id(escalation_policy_data_id.clone())
62                                .query("".to_string())
63                                .urgency(Urgency::LOW)
64                        ]))
65            .id(dd_team_data_id.clone()),
66    );
67    let configuration = datadog::Configuration::new();
68    let api = OnCallAPI::with_config(configuration);
69    let resp = api
70        .set_on_call_team_routing_rules(
71            dd_team_data_id.clone(),
72            body,
73            SetOnCallTeamRoutingRulesOptionalParams::default().include("rules".to_string()),
74        )
75        .await;
76    if let Ok(value) = resp {
77        println!("{:#?}", value);
78    } else {
79        println!("{:#?}", resp.unwrap_err());
80    }
81}
Source

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

Trait Implementations§

Source§

impl Clone for TimeRestriction

Source§

fn clone(&self) -> TimeRestriction

Returns a duplicate of the value. Read more
1.0.0 · Source§

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

Performs copy-assignment from source. Read more
Source§

impl Debug for TimeRestriction

Source§

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

Formats the value using the given formatter. Read more
Source§

impl Default for TimeRestriction

Source§

fn default() -> Self

Returns the “default value” for a type. Read more
Source§

impl<'de> Deserialize<'de> for TimeRestriction

Source§

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more
Source§

impl PartialEq for TimeRestriction

Source§

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

Tests for self and other values to be equal, and is used by ==.
1.0.0 · Source§

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

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

impl Serialize for TimeRestriction

Source§

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

Serialize this value into the given Serde serializer. Read more
Source§

impl StructuralPartialEq for TimeRestriction

Auto Trait Implementations§

Blanket Implementations§

Source§

impl<T> Any for T
where T: 'static + ?Sized,

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

impl<T> Borrow<T> for T
where T: ?Sized,

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
Source§

impl<T> CloneToUninit for T
where T: Clone,

Source§

unsafe fn clone_to_uninit(&self, dest: *mut u8)

🔬This is a nightly-only experimental API. (clone_to_uninit)
Performs copy-assignment from self to dest. Read more
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

Source§

impl<T> Instrument for T

Source§

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more
Source§

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an Instrumented wrapper. Read more
Source§

impl<T, U> Into<U> for T
where U: From<T>,

Source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source§

impl<T> ToOwned for T
where T: Clone,

Source§

type Owned = T

The resulting type after obtaining ownership.
Source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
Source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
Source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

type Error = Infallible

The type returned in the event of a conversion error.
Source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
Source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
Source§

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

Source§

fn vzip(self) -> V

Source§

impl<T> WithSubscriber for T

Source§

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a WithDispatch wrapper. Read more
Source§

fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default Subscriber to this type, returning a WithDispatch wrapper. Read more
Source§

impl<T> DeserializeOwned for T
where T: for<'de> Deserialize<'de>,

Source§

impl<T> ErasedDestructor for T
where T: 'static,