framework-web 26.8.150

lingting framework
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

use serde::{Deserialize, Serialize};

#[derive(Clone, Debug, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct AuthRule {
    pub anonymous: Option<bool>,
    pub organizations: Option<Vec<String>>,
    pub organizations_any: Option<Vec<String>>,
    pub permissions: Option<Vec<String>>,
    pub permissions_any: Option<Vec<String>>,
    pub roles: Option<Vec<String>>,
    pub roles_any: Option<Vec<String>>,
    pub rules: Option<Vec<AuthRule>>,
    pub rules_any: Option<Vec<AuthRule>>,
}

impl AuthRule {
    pub fn anonymous() -> Self {
        Self {
            anonymous: Some(true),
            ..Default::default()
        }
    }

    pub fn login() -> Self {
        Self {
            anonymous: Some(false),
            ..Default::default()
        }
    }

    pub fn check(
        &self,
        organizations: Option<&[String]>,
        permissions: Option<&[String]>,
        roles: Option<&[String]>,
    ) -> bool {
        if self.anonymous == Some(true) {
            return true;
        }
        self.check_organization(organizations)
            && self.check_permission(permissions)
            && self.check_role(roles)
            && self.rules.as_ref().is_none_or(|rules| {
                rules
                    .iter()
                    .all(|rule| rule.check(organizations, permissions, roles))
            })
            && self.rules_any.as_ref().is_none_or(|rules| {
                rules
                    .iter()
                    .any(|rule| rule.check(organizations, permissions, roles))
            })
    }

    pub fn check_organization(&self, value: Option<&[String]>) -> bool {
        contains_none(&self.organizations, &self.organizations_any, value)
    }

    pub fn check_permission(&self, value: Option<&[String]>) -> bool {
        contains_none(&self.permissions, &self.permissions_any, value)
    }

    pub fn check_role(&self, value: Option<&[String]>) -> bool {
        contains_none(&self.roles, &self.roles_any, value)
    }
}

fn contains_none(
    all: &Option<Vec<String>>,
    any: &Option<Vec<String>>,
    value: Option<&[String]>,
) -> bool {
    let has = all.is_some() || any.is_some();
    let value = match value {
        Some(v) => v,
        None => {
            return !has;
        }
    };

    if value.is_empty() && has {
        return false;
    }

    contains_all(all, value) && contains_any(any, value)
}

fn contains_all(required: &Option<Vec<String>>, actual: &[String]) -> bool {
    required
        .as_ref()
        .is_none_or(|items| items.iter().all(|item| actual.contains(item)))
}

fn contains_any(required: &Option<Vec<String>>, actual: &[String]) -> bool {
    required
        .as_ref()
        .is_none_or(|items| items.iter().any(|item| actual.contains(item)))
}