next_web_dev/security/
auth_group.rs

1use hashbrown::HashSet;
2
3#[derive(Default, Clone)]
4pub struct AuthGroup {
5    role_group: Option<Vec<String>>,
6    permission_group: Option<Vec<String>>,
7    combination: Option<CombinationGroup>,
8    is_combination: bool,
9}
10
11impl AuthGroup {
12    pub fn new(
13        role_group: Option<Vec<String>>,
14        permission_group: Option<Vec<String>>,
15        combination: Option<CombinationGroup>,
16    ) -> Self {
17        Self {
18            role_group,
19            permission_group,
20            combination,
21            is_combination: false,
22        }
23    }
24
25    pub fn roles(&self) -> Option<Vec<String>> {
26        if self.is_combination {
27            return self
28                .combination
29                .as_ref()
30                .map(|v| v.role())
31                .unwrap_or_default();
32        }
33        self.role_group.clone()
34    }
35
36    pub fn permissions(&self) -> Option<Vec<String>> {
37        if self.is_combination {
38            return self
39                .combination
40                .as_ref()
41                .map(|v| v.permission())
42                .unwrap_or_default();
43        }
44       self.permission_group.clone()
45    }
46
47    pub fn mode(&self) -> Option<CombinationMode> {
48        if self.is_combination {
49            return self
50                .combination
51                .as_ref()
52                .map(|v| v.mode.clone());
53        }
54        None
55    }
56
57    pub fn combination(&self) -> Option<CombinationGroup> {
58        self.combination.clone()
59    }
60
61    pub fn is_combination(&self) -> bool {
62        self.combination.is_some()
63    }
64
65    pub fn combination_valid(&self) -> bool {
66        if let Some(combination) = &self.combination {
67            let var1 = combination.role_group.as_ref().map(|v| v.len() == 0)
68                == combination
69                    .permission_group
70                    .as_ref()
71                    .map(|v| v.len() == 0);
72            return var1;
73        }
74        false
75    }
76
77    pub fn set_combination(&mut self, flag: bool) {
78        self.is_combination = flag;
79    }
80
81    pub fn match_value(
82        &self,
83        var1: Vec<String>,
84        var2: Vec<String>,
85        mode: Option<&CombinationMode>,
86    ) -> bool {
87        let var3 = var2.len() == 1 && var2[0] == "*";
88        if var3 {
89            return true;
90        }
91        if self.is_combination {
92            match mode {
93                Some(CombinationMode::And) => {
94                    if var1.len() != var2.len() {
95                        return false;
96                    }
97                    let var4: HashSet<String> = var1.into_iter().collect();
98                    let var5: HashSet<String> = var2.into_iter().collect();
99                    return var4 == var5;
100                }
101                Some(CombinationMode::Or) => {
102                    return var1.iter().any(|v| var2.contains(v));
103                }
104                None => {}
105            }
106        } else {
107            if var1.len() != var2.len() {
108                return false;
109            }
110            let var4: HashSet<String> = var1.into_iter().collect();
111            let var5: HashSet<String> = var2.into_iter().collect();
112            return var4 == var5;
113        }
114        false
115    }
116}
117
118#[derive(Clone)]
119pub struct CombinationGroup {
120    role_group: Option<(Vec<String>)>,
121    permission_group: Option<Vec<String>>,
122    mode: CombinationMode
123}
124
125impl CombinationGroup {
126    pub fn new(
127        role_group: Option<Vec<String>>,
128        permission_group: Option<Vec<String>>,
129        mode: CombinationMode
130    ) -> Self {
131        Self {
132            role_group,
133            permission_group,
134            mode,
135        }
136    }
137
138    pub fn role_group(&self) -> Option<Vec<String>> {
139        self.role_group.clone()
140    }
141
142    pub fn permission_group(&self) -> Option<Vec<String>> {
143        self.permission_group.clone()
144    }
145
146    fn role(&self) -> Option<Vec<String>> {
147        self.role_group()
148            .map(|n| Some(n.clone()))
149            .unwrap_or_default()
150    }
151
152    fn permission(&self) -> Option<Vec<String>> {
153        self.permission_group()
154            .map(|n| Some(n.clone()))
155            .unwrap_or_default()
156    }
157}
158
159#[derive(Debug, PartialEq, Eq, Clone, serde::Deserialize)]
160pub enum CombinationMode {
161    And,
162    Or,
163}
next_web_dev/security/auth_group.rs

next_web_dev/security/
auth_group.rs
