shield_sea_orm/
user.rs

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
use async_trait::async_trait;
use sea_orm::{prelude::Uuid, DatabaseConnection, ModelTrait};
use shield::{EmailAddress, StorageError};

#[cfg(feature = "entity")]
use crate::entities::entity;
use crate::entities::{email_address, user};

#[derive(Clone, Debug)]
pub struct User {
    database: DatabaseConnection,
    user: user::Model,
    #[cfg(feature = "entity")]
    entity: entity::Model,
}

impl User {
    pub(crate) fn new(
        database: DatabaseConnection,
        user: user::Model,
        #[cfg(feature = "entity")] entity: entity::Model,
    ) -> Self {
        Self {
            database,
            user,
            #[cfg(feature = "entity")]
            entity,
        }
    }
}

#[async_trait]
impl shield::User for User {
    fn id(&self) -> String {
        self.user.id.to_string()
    }

    fn name(&self) -> Option<String> {
        #[cfg(feature = "entity")]
        {
            Some(self.entity.name.clone())
        }

        #[cfg(not(feature = "entity"))]
        {
            Some(self.user.name.clone())
        }
    }

    async fn email_addresses(&self) -> Result<Vec<EmailAddress>, StorageError> {
        #[cfg(feature = "entity")]
        {
            self.entity
                .find_related(email_address::Entity)
                .all(&self.database)
                .await
                .map_err(|err| StorageError::Engine(err.to_string()))
                .map(|email_addresses| {
                    email_addresses
                        .into_iter()
                        .map(|email_address| {
                            EmailAddress::from(EmailAddressWithUserId(email_address, self.user.id))
                        })
                        .collect()
                })
        }

        #[cfg(not(feature = "entity"))]
        {
            self.user
                .find_related(email_address::Entity)
                .all(&self.database)
                .await
                .map_err(|err| StorageError::Engine(err.to_string()))
                .map(|email_addresses| {
                    email_addresses
                        .into_iter()
                        .map(EmailAddress::from)
                        .collect()
                })
        }
    }
}

#[cfg(not(feature = "entity"))]
impl From<email_address::Model> for EmailAddress {
    fn from(value: email_address::Model) -> Self {
        Self {
            id: value.id.to_string(),
            email: value.email,
            is_primary: value.is_primary,
            is_verified: value.is_verified,
            verification_token: value.verification_token,
            verification_token_expired_at: value.verification_token_expired_at,
            verified_at: value.verified_at,
            user_id: value.user_id.to_string(),
        }
    }
}

struct EmailAddressWithUserId(email_address::Model, Uuid);

impl From<EmailAddressWithUserId> for EmailAddress {
    fn from(EmailAddressWithUserId(value, user_id): EmailAddressWithUserId) -> Self {
        Self {
            id: value.id.to_string(),
            email: value.email,
            is_primary: value.is_primary,
            is_verified: value.is_verified,
            verification_token: value.verification_token,
            verification_token_expired_at: value.verification_token_expired_at,
            verified_at: value.verified_at,
            user_id: user_id.to_string(),
        }
    }
}