praiya 0.4.0

An async PagerDuty API client
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82

//! This example will fetch all users and check their notification rules

use futures_util::TryStreamExt;
use praiya::Praiya;

use praiya::api::users::ListUsersParamsBuilder;
use praiya::models::{ContactMethod, ContactMethodTypeEnum, NotificationRule, User, UserRoleEnum};
use praiya::ParamsBuilder;

// Replace with appropriate values...
const PAGERDUTY_TOKEN: &str = "";

#[tokio::main]
async fn main() -> Result<(), praiya::errors::Error> {
    let pagerduty = Praiya::new(PAGERDUTY_TOKEN);

    let params = {
        let mut option = ListUsersParamsBuilder::new();
        let include = vec!["notification_rules"];

        option.include(include);
        option.build()
    };

    let users: Vec<User> = pagerduty
        .users()
        .list_users(params)
        .try_collect()
        .await
        .expect("failed to fetch users");

    let default_contact_types = vec![
        ContactMethodTypeEnum::EMAIL_CONTACT_METHOD,
        ContactMethodTypeEnum::SMS_CONTACT_METHOD,
        ContactMethodTypeEnum::PHONE_CONTACT_METHOD,
    ];

    for user in &users {
        match user {
            User {
                role: Some(role),
                notification_rules: Some(rules),
                summary: Some(summary),
                ..
            } if !vec![
                UserRoleEnum::READ_ONLY_USER,
                UserRoleEnum::READ_ONLY_LIMITED_USER,
            ]
            .iter()
            .any(|r| r == role)
                && default_contact_types.iter().all(|c| {
                    rules.iter().any(|r| match r {
                        NotificationRule {
                            contact_method: Some(ContactMethod { _type, .. }),
                            ..
                        } if c == _type => true,
                        _ => false,
                    })
                }) =>
            {
                println!("User is valid: {}", &summary);
            }
            User {
                summary: Some(summary),
                role: Some(role),
                notification_rules: Some(notification_rules),
                ..
            } => println!(
                "User is not a responder, or missing notification rules: {:?}, {:?}, {:?}",
                summary,
                role,
                notification_rules
                    .iter()
                    .map(|n| n.contact_method.as_ref().unwrap()._type.as_ref())
                    .collect::<Vec<&str>>()
            ),
            _ => println!("Failed to parse user {:?}", user),
        }
    }

    Ok(())
}