]> Untitled Git - lemmy.git/blob - crates/db_views/src/local_user_view.rs
A first pass.
[lemmy.git] / crates / db_views / src / local_user_view.rs
1 use diesel::{result::Error, *};
2 use lemmy_db_queries::{aggregates::person_aggregates::PersonAggregates, ToSafe, ToSafeSettings};
3 use lemmy_db_schema::{
4   schema::{local_user, person, person_aggregates},
5   source::{
6     local_user::{LocalUser, LocalUserSettings},
7     person::{Person, PersonSafe},
8   },
9 };
10 use serde::Serialize;
11
12 #[derive(Debug, Serialize, Clone)]
13 pub struct LocalUserView {
14   pub person: Person,
15   pub counts: PersonAggregates,
16   pub local_user: LocalUser,
17 }
18
19 type LocalUserViewTuple = (Person, PersonAggregates, LocalUser);
20
21 impl LocalUserView {
22   pub fn read_person(conn: &PgConnection, person_id: i32) -> Result<Self, Error> {
23     let (person, counts, local_user) = person::table
24       .find(person_id)
25       .inner_join(person_aggregates::table)
26       .inner_join(local_user::table)
27       .select((
28         person::all_columns,
29         person_aggregates::all_columns,
30         local_user::all_columns,
31       ))
32       .first::<LocalUserViewTuple>(conn)?;
33     Ok(Self {
34       person,
35       counts,
36       local_user,
37     })
38   }
39
40   // TODO check where this is used
41   pub fn read_from_name(conn: &PgConnection, name: &str) -> Result<Self, Error> {
42     let (person, counts, local_user) = person::table
43       .filter(person::name.eq(name))
44       .inner_join(person_aggregates::table)
45       .inner_join(local_user::table)
46       .select((
47         person::all_columns,
48         person_aggregates::all_columns,
49         local_user::all_columns,
50       ))
51       .first::<LocalUserViewTuple>(conn)?;
52     Ok(Self {
53       person,
54       counts,
55       local_user,
56     })
57   }
58
59   pub fn find_by_email_or_name(conn: &PgConnection, name_or_email: &str) -> Result<Self, Error> {
60     let (person, counts, local_user) = person::table
61       .inner_join(person_aggregates::table)
62       .inner_join(local_user::table)
63       .filter(
64         person::name
65           .ilike(name_or_email)
66           .or(local_user::email.ilike(name_or_email)),
67       )
68       .select((
69         person::all_columns,
70         person_aggregates::all_columns,
71         local_user::all_columns,
72       ))
73       .first::<LocalUserViewTuple>(conn)?;
74     Ok(Self {
75       person,
76       counts,
77       local_user,
78     })
79   }
80
81   pub fn find_by_email(conn: &PgConnection, from_email: &str) -> Result<Self, Error> {
82     let (person, counts, local_user) = person::table
83       .inner_join(person_aggregates::table)
84       .inner_join(local_user::table)
85       .filter(local_user::email.eq(from_email))
86       .select((
87         person::all_columns,
88         person_aggregates::all_columns,
89         local_user::all_columns,
90       ))
91       .first::<LocalUserViewTuple>(conn)?;
92     Ok(Self {
93       person,
94       counts,
95       local_user,
96     })
97   }
98 }
99
100 #[derive(Debug, Serialize, Clone)]
101 pub struct LocalUserSettingsView {
102   pub person: PersonSafe,
103   pub counts: PersonAggregates,
104   pub local_user: LocalUserSettings,
105 }
106
107 type LocalUserSettingsViewTuple = (PersonSafe, PersonAggregates, LocalUserSettings);
108
109 impl LocalUserSettingsView {
110   pub fn read(conn: &PgConnection, person_id: i32) -> Result<Self, Error> {
111     let (person, counts, local_user) = person::table
112       .find(person_id)
113       .inner_join(person_aggregates::table)
114       .inner_join(local_user::table)
115       .select((
116         Person::safe_columns_tuple(),
117         person_aggregates::all_columns,
118         LocalUser::safe_settings_columns_tuple(),
119       ))
120       .first::<LocalUserSettingsViewTuple>(conn)?;
121     Ok(Self {
122       person,
123       counts,
124       local_user,
125     })
126   }
127 }