Skip to main content

systemprompt_users/repository/user/
find.rs

1use systemprompt_identifiers::UserId;
2
3use crate::error::Result;
4use crate::models::{User, UserRole, UserStatus};
5use crate::repository::UserRepository;
6
7impl UserRepository {
8    pub async fn find_by_id(&self, id: &UserId) -> Result<Option<User>> {
9        let deleted_status = UserStatus::Deleted.as_str();
10        let row = sqlx::query_as!(
11            User,
12            r#"
13            SELECT id, name, email, full_name, display_name, status, email_verified,
14                   roles, avatar_url, is_bot, is_scanner, created_at, updated_at
15            FROM users
16            WHERE id = $1 AND status != $2
17            "#,
18            id.as_str(),
19            deleted_status
20        )
21        .fetch_optional(&*self.pool)
22        .await?;
23
24        Ok(row)
25    }
26
27    pub async fn find_by_email(&self, email: &str) -> Result<Option<User>> {
28        let deleted_status = UserStatus::Deleted.as_str();
29        let row = sqlx::query_as!(
30            User,
31            r#"
32            SELECT id, name, email, full_name, display_name, status, email_verified,
33                   roles, avatar_url, is_bot, is_scanner, created_at, updated_at
34            FROM users
35            WHERE email = $1 AND status != $2
36            "#,
37            email,
38            deleted_status
39        )
40        .fetch_optional(&*self.pool)
41        .await?;
42
43        Ok(row)
44    }
45
46    pub async fn find_by_name(&self, name: &str) -> Result<Option<User>> {
47        let deleted_status = UserStatus::Deleted.as_str();
48        let row = sqlx::query_as!(
49            User,
50            r#"
51            SELECT id, name, email, full_name, display_name, status, email_verified,
52                   roles, avatar_url, is_bot, is_scanner, created_at, updated_at
53            FROM users
54            WHERE name = $1 AND status != $2
55            "#,
56            name,
57            deleted_status
58        )
59        .fetch_optional(&*self.pool)
60        .await?;
61
62        Ok(row)
63    }
64
65    pub async fn find_by_role(&self, role: UserRole) -> Result<Vec<User>> {
66        let deleted_status = UserStatus::Deleted.as_str();
67        let rows = sqlx::query_as!(
68            User,
69            r#"
70            SELECT id, name, email, full_name, display_name, status, email_verified,
71                   roles, avatar_url, is_bot, is_scanner, created_at, updated_at
72            FROM users
73            WHERE $1 = ANY(roles) AND status != $2
74            ORDER BY created_at DESC
75            "#,
76            role.as_str(),
77            deleted_status
78        )
79        .fetch_all(&*self.pool)
80        .await?;
81
82        Ok(rows)
83    }
84
85    pub async fn find_first_user(&self) -> Result<Option<User>> {
86        let deleted_status = UserStatus::Deleted.as_str();
87        let row = sqlx::query_as!(
88            User,
89            r#"
90            SELECT id, name, email, full_name, display_name, status, email_verified,
91                   roles, avatar_url, is_bot, is_scanner, created_at, updated_at
92            FROM users
93            WHERE status != $1
94            ORDER BY created_at ASC
95            LIMIT 1
96            "#,
97            deleted_status
98        )
99        .fetch_optional(&*self.pool)
100        .await?;
101
102        Ok(row)
103    }
104
105    pub async fn find_first_admin(&self) -> Result<Option<User>> {
106        let deleted_status = UserStatus::Deleted.as_str();
107        let admin_role = UserRole::Admin.as_str();
108        let row = sqlx::query_as!(
109            User,
110            r#"
111            SELECT id, name, email, full_name, display_name, status, email_verified,
112                   roles, avatar_url, is_bot, is_scanner, created_at, updated_at
113            FROM users
114            WHERE $1 = ANY(roles) AND status != $2
115            ORDER BY created_at ASC
116            LIMIT 1
117            "#,
118            admin_role,
119            deleted_status
120        )
121        .fetch_optional(&*self.pool)
122        .await?;
123
124        Ok(row)
125    }
126
127    pub async fn find_authenticated_user(&self, user_id: &UserId) -> Result<Option<User>> {
128        let active_status = UserStatus::Active.as_str();
129        let row = sqlx::query_as!(
130            User,
131            r#"
132            SELECT id, name, email, full_name, display_name, status, email_verified,
133                   roles, avatar_url, is_bot, is_scanner, created_at, updated_at
134            FROM users
135            WHERE id = $1 AND status = $2
136            "#,
137            user_id.as_str(),
138            active_status
139        )
140        .fetch_optional(&*self.pool)
141        .await?;
142
143        Ok(row)
144    }
145}