myc-core 8.3.0+beta

Provide base features of the Mycelium project as s and Use-cases.
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

use super::guest_role::Permission;

use serde::{Deserialize, Serialize};
use utoipa::{ToResponse, ToSchema};

#[derive(
    Debug,
    Default,
    Clone,
    Deserialize,
    Serialize,
    PartialEq,
    Eq,
    ToSchema,
    ToResponse,
)]
#[serde(rename_all = "camelCase")]
pub struct PermissionedRole {
    #[serde(alias = "slug")]
    pub name: String,

    #[serde(default = "default_permission")]
    pub permission: Option<Permission>,
}

fn default_permission() -> Option<Permission> {
    Some(Permission::Read)
}

impl ToString for PermissionedRole {
    fn to_string(&self) -> String {
        format!(
            "{}:{}",
            self.name,
            self.permission.clone().unwrap_or_default().to_i32()
        )
    }
}

pub type PermissionedRoles = Vec<(String, Permission)>;

#[derive(
    Debug, Clone, Deserialize, Serialize, PartialEq, Eq, ToSchema, ToResponse,
)]
#[serde(rename_all = "camelCase")]
pub enum SecurityGroup {
    ///
    /// Allow public access to the route
    ///
    Public,
    ///
    /// Users should be only authenticated with a valid API token
    ///
    Authenticated,
    ///
    /// Protect the route with the full user profile
    ///
    Protected,
    ///
    /// Protect the route with the user profile filtered by roles
    ///
    #[serde(rename_all = "camelCase")]
    ProtectedByRoles(Vec<PermissionedRole>),
}

impl ToString for SecurityGroup {
    fn to_string(&self) -> String {
        match self {
            SecurityGroup::Public => "public".to_string(),
            SecurityGroup::Authenticated => "authenticated".to_string(),
            SecurityGroup::Protected => "protected".to_string(),
            SecurityGroup::ProtectedByRoles(roles) => {
                format!(
                    "protected_by_roles({})",
                    roles
                        .iter()
                        .map(|permissioned_role| format!(
                            "{}: {}",
                            permissioned_role.name,
                            permissioned_role
                                .permission
                                .as_ref()
                                .cloned()
                                .unwrap_or_default()
                                .to_i32()
                        ))
                        .collect::<Vec<String>>()
                        .join(", ")
                )
            }
        }
    }
}