lamprey-common 0.1.1

yet another chat thing?
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
127
128

use serde::{Deserialize, Serialize};
use std::convert::TryFrom;

#[cfg(feature = "utoipa")]
use utoipa::ToSchema;

#[cfg(feature = "validator")]
use validator::{Validate, ValidationErrors};

/// An email address
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(transparent)]
pub struct EmailAddr(String);

#[cfg(feature = "utoipa")]
mod u {
    use utoipa::{openapi::ObjectBuilder, PartialSchema, ToSchema};

    use crate::v1::types::email::EmailAddr;

    impl ToSchema for EmailAddr {}

    impl PartialSchema for EmailAddr {
        fn schema() -> utoipa::openapi::RefOr<utoipa::openapi::schema::Schema> {
            ObjectBuilder::new()
                .schema_type(utoipa::openapi::schema::Type::String)
                .format(Some(utoipa::openapi::SchemaFormat::Custom(
                    "email".to_string(),
                )))
                .description(Some("an email address"))
                .build()
                .into()
        }
    }
}

#[cfg(feature = "validator")]
mod v {
    use validator::{Validate, ValidationError, ValidationErrors};

    use crate::v1::types::email::EmailAddr;

    impl Validate for EmailAddr {
        fn validate(&self) -> Result<(), validator::ValidationErrors> {
            if self.0.contains("@") {
                Ok(())
            } else {
                let mut v = ValidationErrors::new();
                let mut err = ValidationError::new("email");
                err.add_param("email".into(), &"must be an email address");
                v.add("email", err);
                Err(v)
            }
        }
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "utoipa", derive(ToSchema))]
#[cfg_attr(feature = "validator", derive(Validate))]
pub struct EmailInfo {
    #[cfg_attr(feature = "validator", validate(nested))]
    /// the email address itself
    pub email: EmailAddr,

    /// user verified they have access to the email address
    pub is_verified: bool,

    // /// can see by everyone
    // pub is_public: bool,
    /// whether this is the user's primary email address
    pub is_primary: bool,
    // /// can someone with access to email can do
    // pub trust: EmailTrust,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "utoipa", derive(ToSchema))]
#[cfg_attr(feature = "validator", derive(Validate))]
pub struct EmailInfoPatch {
    // /// can see by everyone
    // pub is_public: Option<bool>,
    /// whether this is the user's primary email address
    ///
    /// - there can only be one primary email address
    /// - the primary address has EmailTrust::Full
    pub is_primary: Option<bool>,
    // /// can someone with access to email can do
    // pub trust: Option<EmailTrust>,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[cfg_attr(feature = "utoipa", derive(ToSchema))]
/// what someone can do with this email address
pub enum EmailTrust {
    /// can't be used for any auth
    /// the only trust levels unverified emails can have
    Never,

    /// can be used to log in
    Trusted,

    /// can be used to reset password
    /// receives security notifications
    Full,
}

impl EmailAddr {
    pub fn into_inner(self) -> String {
        self.0
    }
}

impl TryFrom<String> for EmailAddr {
    type Error = ValidationErrors;

    fn try_from(s: String) -> Result<Self, Self::Error> {
        let e = EmailAddr(s);
        e.validate()?;
        Ok(e)
    }
}

impl AsRef<str> for EmailAddr {
    fn as_ref(&self) -> &str {
        &self.0
    }
}