four 0.0.13

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
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126

use crate::iam::property::{action::Action, effect::Effect, principal::Principal};
use serde::{ser::SerializeMap, Serialize};

#[derive(Debug, Clone)]
pub struct Statement {
    effect: Effect,
    action: ActionOr,
    principal: Option<PrincipalOr>,
    resource: Option<String>,
}

impl Statement {
    pub fn allow_actions(actions: Vec<Box<dyn Action>>) -> StatementBuilder {
        StatementBuilder {
            effect: Effect::Allow,
            action: ActionOr::Action(actions),
            principal: None,
            resource: None,
        }
    }

    pub fn deny_actions(actions: Vec<Box<dyn Action>>) -> StatementBuilder {
        StatementBuilder {
            effect: Effect::Deny,
            action: ActionOr::Action(actions),
            principal: None,
            resource: None,
        }
    }

    pub fn allow_no_actions(actions: Vec<Box<dyn Action>>) -> StatementBuilder {
        StatementBuilder {
            effect: Effect::Allow,
            action: ActionOr::NotAction(actions),
            principal: None,
            resource: None,
        }
    }

    pub fn deny_no_actions(actions: Vec<Box<dyn Action>>) -> StatementBuilder {
        StatementBuilder {
            effect: Effect::Deny,
            action: ActionOr::NotAction(actions),
            principal: None,
            resource: None,
        }
    }
}

impl Serialize for Statement {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        let mut map = serializer.serialize_map(None)?;
        map.serialize_entry("Effect", &self.effect)?;
        match &self.action {
            ActionOr::Action(action) => map.serialize_entry("Action", action)?,
            ActionOr::NotAction(action) => map.serialize_entry("NotAction", action)?,
        }
        if let Some(principal) = self.principal.as_ref() {
            match principal {
                PrincipalOr::Principal(p) => map.serialize_entry("Principal", p)?,
                PrincipalOr::NotPrincipal(p) => map.serialize_entry("NotPrincipal", p)?,
            }
        }
        if let Some(resource) = self.resource.as_ref() {
            map.serialize_entry("Resource", resource)?;
        }

        map.end()
    }
}

#[derive(Debug)]
pub struct StatementBuilder {
    effect: Effect,
    action: ActionOr,
    principal: Option<PrincipalOr>,
    resource: Option<String>,
}

impl StatementBuilder {
    pub fn build(self) -> Result<Statement, StatementBuildError> {
        // TODO: ERROR

        let statement = Statement {
            effect: self.effect,
            action: self.action,
            principal: self.principal,
            resource: self.resource,
        };

        Ok(statement)
    }

    pub fn principal(mut self, principal: Principal) -> Self {
        self.principal = Some(PrincipalOr::Principal(principal));
        self
    }

    pub fn no_principal(mut self, principal: Principal) -> Self {
        self.principal = Some(PrincipalOr::NotPrincipal(principal));
        self
    }

    pub fn resource(mut self, resource: &str) -> Self {
        self.resource = Some(resource.to_string());
        self
    }
}

#[derive(Debug, thiserror::Error)]
pub enum StatementBuildError {}

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

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