1 use crate::structs::RegistrationApplicationView;
2 use diesel::{dsl::count, result::Error, *};
4 schema::{local_user, person, person_alias_1, registration_application},
6 local_user::{LocalUser, LocalUserSettings},
7 person::{Person, PersonAlias1, PersonSafe, PersonSafeAlias1},
8 registration_application::RegistrationApplication,
10 traits::{ToSafe, ToSafeSettings, ViewToVec},
11 utils::limit_and_offset,
13 use typed_builder::TypedBuilder;
15 type RegistrationApplicationViewTuple = (
16 RegistrationApplication,
19 Option<PersonSafeAlias1>,
22 impl RegistrationApplicationView {
23 pub fn read(conn: &PgConnection, registration_application_id: i32) -> Result<Self, Error> {
24 let (registration_application, creator_local_user, creator, admin) =
25 registration_application::table
26 .find(registration_application_id)
28 local_user::table.on(registration_application::local_user_id.eq(local_user::id)),
30 .inner_join(person::table.on(local_user::person_id.eq(person::id)))
33 .on(registration_application::admin_id.eq(person_alias_1::id.nullable())),
35 .order_by(registration_application::published.desc())
37 registration_application::all_columns,
38 LocalUser::safe_settings_columns_tuple(),
39 Person::safe_columns_tuple(),
40 PersonAlias1::safe_columns_tuple().nullable(),
42 .first::<RegistrationApplicationViewTuple>(conn)?;
44 Ok(RegistrationApplicationView {
45 registration_application,
52 /// Returns the current unread registration_application count
53 pub fn get_unread_count(conn: &PgConnection, verified_email_only: bool) -> Result<i64, Error> {
54 let mut query = registration_application::table
55 .inner_join(local_user::table.on(registration_application::local_user_id.eq(local_user::id)))
56 .inner_join(person::table.on(local_user::person_id.eq(person::id)))
59 .on(registration_application::admin_id.eq(person_alias_1::id.nullable())),
61 .filter(registration_application::admin_id.is_null())
64 if verified_email_only {
65 query = query.filter(local_user::email_verified.eq(true))
69 .select(count(registration_application::id))
74 #[derive(TypedBuilder)]
75 #[builder(field_defaults(default))]
76 pub struct RegistrationApplicationQuery<'a> {
78 conn: &'a PgConnection,
79 unread_only: Option<bool>,
80 verified_email_only: Option<bool>,
85 impl<'a> RegistrationApplicationQuery<'a> {
86 pub fn list(self) -> Result<Vec<RegistrationApplicationView>, Error> {
87 let mut query = registration_application::table
88 .inner_join(local_user::table.on(registration_application::local_user_id.eq(local_user::id)))
89 .inner_join(person::table.on(local_user::person_id.eq(person::id)))
92 .on(registration_application::admin_id.eq(person_alias_1::id.nullable())),
94 .order_by(registration_application::published.desc())
96 registration_application::all_columns,
97 LocalUser::safe_settings_columns_tuple(),
98 Person::safe_columns_tuple(),
99 PersonAlias1::safe_columns_tuple().nullable(),
103 if self.unread_only.unwrap_or(false) {
104 query = query.filter(registration_application::admin_id.is_null())
107 if self.verified_email_only.unwrap_or(false) {
108 query = query.filter(local_user::email_verified.eq(true))
111 let (limit, offset) = limit_and_offset(self.page, self.limit)?;
116 .order_by(registration_application::published.desc());
118 let res = query.load::<RegistrationApplicationViewTuple>(self.conn)?;
120 Ok(RegistrationApplicationView::from_tuple_to_vec(res))
124 impl ViewToVec for RegistrationApplicationView {
125 type DbTuple = RegistrationApplicationViewTuple;
126 fn from_tuple_to_vec(items: Vec<Self::DbTuple>) -> Vec<Self> {
130 registration_application: a.0,
131 creator_local_user: a.1,
135 .collect::<Vec<Self>>()
141 use crate::registration_application_view::{
142 RegistrationApplicationQuery,
143 RegistrationApplicationView,
145 use lemmy_db_schema::{
147 local_user::{LocalUser, LocalUserForm, LocalUserSettings},
149 registration_application::{RegistrationApplication, RegistrationApplicationForm},
152 utils::establish_unpooled_connection,
154 use serial_test::serial;
159 let conn = establish_unpooled_connection();
161 let timmy_person_form = PersonForm {
162 name: "timmy_rav".into(),
164 public_key: Some("pubkey".to_string()),
165 ..PersonForm::default()
168 let inserted_timmy_person = Person::create(&conn, &timmy_person_form).unwrap();
170 let timmy_local_user_form = LocalUserForm {
171 person_id: Some(inserted_timmy_person.id),
172 password_encrypted: Some("nada".to_string()),
173 ..LocalUserForm::default()
176 let _inserted_timmy_local_user = LocalUser::create(&conn, &timmy_local_user_form).unwrap();
178 let sara_person_form = PersonForm {
179 name: "sara_rav".into(),
180 public_key: Some("pubkey".to_string()),
181 ..PersonForm::default()
184 let inserted_sara_person = Person::create(&conn, &sara_person_form).unwrap();
186 let sara_local_user_form = LocalUserForm {
187 person_id: Some(inserted_sara_person.id),
188 password_encrypted: Some("nada".to_string()),
189 ..LocalUserForm::default()
192 let inserted_sara_local_user = LocalUser::create(&conn, &sara_local_user_form).unwrap();
194 // Sara creates an application
195 let sara_app_form = RegistrationApplicationForm {
196 local_user_id: Some(inserted_sara_local_user.id),
197 answer: Some("LET ME IIIIINN".to_string()),
198 ..RegistrationApplicationForm::default()
201 let sara_app = RegistrationApplication::create(&conn, &sara_app_form).unwrap();
203 let read_sara_app_view = RegistrationApplicationView::read(&conn, sara_app.id).unwrap();
205 let jess_person_form = PersonForm {
206 name: "jess_rav".into(),
207 public_key: Some("pubkey".to_string()),
208 ..PersonForm::default()
211 let inserted_jess_person = Person::create(&conn, &jess_person_form).unwrap();
213 let jess_local_user_form = LocalUserForm {
214 person_id: Some(inserted_jess_person.id),
215 password_encrypted: Some("nada".to_string()),
216 ..LocalUserForm::default()
219 let inserted_jess_local_user = LocalUser::create(&conn, &jess_local_user_form).unwrap();
221 // Sara creates an application
222 let jess_app_form = RegistrationApplicationForm {
223 local_user_id: Some(inserted_jess_local_user.id),
224 answer: Some("LET ME IIIIINN".to_string()),
225 ..RegistrationApplicationForm::default()
228 let jess_app = RegistrationApplication::create(&conn, &jess_app_form).unwrap();
230 let read_jess_app_view = RegistrationApplicationView::read(&conn, jess_app.id).unwrap();
232 let mut expected_sara_app_view = RegistrationApplicationView {
233 registration_application: sara_app.to_owned(),
234 creator_local_user: LocalUserSettings {
235 id: inserted_sara_local_user.id,
236 person_id: inserted_sara_local_user.person_id,
237 email: inserted_sara_local_user.email,
238 show_nsfw: inserted_sara_local_user.show_nsfw,
239 theme: inserted_sara_local_user.theme,
240 default_sort_type: inserted_sara_local_user.default_sort_type,
241 default_listing_type: inserted_sara_local_user.default_listing_type,
242 lang: inserted_sara_local_user.lang,
243 show_avatars: inserted_sara_local_user.show_avatars,
244 send_notifications_to_email: inserted_sara_local_user.send_notifications_to_email,
245 validator_time: inserted_sara_local_user.validator_time,
246 show_bot_accounts: inserted_sara_local_user.show_bot_accounts,
247 show_scores: inserted_sara_local_user.show_scores,
248 show_read_posts: inserted_sara_local_user.show_read_posts,
249 show_new_post_notifs: inserted_sara_local_user.show_new_post_notifs,
250 email_verified: inserted_sara_local_user.email_verified,
251 accepted_application: inserted_sara_local_user.accepted_application,
253 creator: PersonSafe {
254 id: inserted_sara_person.id,
255 name: inserted_sara_person.name.to_owned(),
257 published: inserted_sara_person.published,
259 actor_id: inserted_sara_person.actor_id.to_owned(),
269 inbox_url: inserted_sara_person.inbox_url.to_owned(),
270 shared_inbox_url: None,
271 matrix_user_id: None,
276 assert_eq!(read_sara_app_view, expected_sara_app_view);
278 // Do a batch read of the applications
279 let apps = RegistrationApplicationQuery::builder()
281 .unread_only(Some(true))
289 read_jess_app_view.to_owned(),
290 expected_sara_app_view.to_owned()
294 // Make sure the counts are correct
295 let unread_count = RegistrationApplicationView::get_unread_count(&conn, false).unwrap();
296 assert_eq!(unread_count, 2);
298 // Approve the application
299 let approve_form = RegistrationApplicationForm {
300 admin_id: Some(inserted_timmy_person.id),
302 ..RegistrationApplicationForm::default()
305 RegistrationApplication::update(&conn, sara_app.id, &approve_form).unwrap();
307 // Update the local_user row
308 let approve_local_user_form = LocalUserForm {
309 accepted_application: Some(true),
310 ..LocalUserForm::default()
313 LocalUser::update(&conn, inserted_sara_local_user.id, &approve_local_user_form).unwrap();
315 let read_sara_app_view_after_approve =
316 RegistrationApplicationView::read(&conn, sara_app.id).unwrap();
318 // Make sure the columns changed
319 expected_sara_app_view
321 .accepted_application = true;
322 expected_sara_app_view.registration_application.admin_id = Some(inserted_timmy_person.id);
324 expected_sara_app_view.admin = Some(PersonSafeAlias1 {
325 id: inserted_timmy_person.id,
326 name: inserted_timmy_person.name.to_owned(),
328 published: inserted_timmy_person.published,
330 actor_id: inserted_timmy_person.actor_id.to_owned(),
340 inbox_url: inserted_timmy_person.inbox_url.to_owned(),
341 shared_inbox_url: None,
342 matrix_user_id: None,
344 assert_eq!(read_sara_app_view_after_approve, expected_sara_app_view);
346 // Do a batch read of apps again
347 // It should show only jessicas which is unresolved
348 let apps_after_resolve = RegistrationApplicationQuery::builder()
350 .unread_only(Some(true))
354 assert_eq!(apps_after_resolve, vec![read_jess_app_view]);
356 // Make sure the counts are correct
357 let unread_count_after_approve =
358 RegistrationApplicationView::get_unread_count(&conn, false).unwrap();
359 assert_eq!(unread_count_after_approve, 1);
361 // Make sure the not undenied_only has all the apps
362 let all_apps = RegistrationApplicationQuery::builder()
367 assert_eq!(all_apps.len(), 2);
369 Person::delete(&conn, inserted_timmy_person.id).unwrap();
370 Person::delete(&conn, inserted_sara_person.id).unwrap();
371 Person::delete(&conn, inserted_jess_person.id).unwrap();