four_iam 0.0.6

framework for creating AWS CloudFormation template
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
83
84

use serde::Serialize;

use crate::property::{action::Action, effect::Effect, principal::Principal};

#[derive(Debug, Clone, Serialize)]
#[serde(rename_all = "PascalCase")]
pub struct Statement {
    effect: Effect,

    #[serde(flatten)]
    action: ActionOr,

    #[serde(flatten)]
    principal: PrincipalOr,
}

impl Statement {
    pub fn allow() -> StatementBuilder1 {
        StatementBuilder1 {
            effect: Effect::Allow,
        }
    }

    pub fn deny() -> StatementBuilder1 {
        StatementBuilder1 {
            effect: Effect::Deny,
        }
    }
}

pub struct StatementBuilder1 {
    effect: Effect,
}

impl StatementBuilder1 {
    pub fn action(self, action: Vec<Box<dyn Action>>) -> StatementBuilder2 {
        StatementBuilder2 {
            effect: self.effect,
            action: ActionOr::Action(action),
        }
    }

    pub fn not_action(self, action: Vec<Box<dyn Action>>) -> StatementBuilder2 {
        StatementBuilder2 {
            effect: self.effect,
            action: ActionOr::NotAction(action),
        }
    }
}

pub struct StatementBuilder2 {
    effect: Effect,
    action: ActionOr,
}

impl StatementBuilder2 {
    pub fn principal(self, principal: Principal) -> Statement {
        Statement {
            effect: self.effect,
            action: self.action,
            principal: PrincipalOr::Principal(principal),
        }
    }

    pub fn no_principal(self, principal: Principal) -> Statement {
        Statement {
            effect: self.effect,
            action: self.action,
            principal: PrincipalOr::NotPrincipal(principal),
        }
    }
}

#[derive(Debug, Clone, Serialize)]
pub enum ActionOr {
    Action(Vec<Box<dyn Action>>),
    NotAction(Vec<Box<dyn Action>>),
}

#[derive(Debug, Clone, Serialize)]
pub enum PrincipalOr {
    Principal(Principal),
    NotPrincipal(Principal),
}