1 use crate::structs::RegistrationApplicationView;
7 NullableExpressionMethods,
10 use diesel_async::RunQueryDsl;
11 use lemmy_db_schema::{
12 schema::{local_user, person, registration_application},
14 local_user::LocalUser,
16 registration_application::RegistrationApplication,
19 utils::{get_conn, limit_and_offset, DbPool},
22 type RegistrationApplicationViewTuple =
23 (RegistrationApplication, LocalUser, Person, Option<Person>);
25 impl RegistrationApplicationView {
27 pool: &mut DbPool<'_>,
28 registration_application_id: i32,
29 ) -> Result<Self, Error> {
30 let conn = &mut get_conn(pool).await?;
31 let person_alias_1 = diesel::alias!(person as person1);
33 let (registration_application, creator_local_user, creator, admin) =
34 registration_application::table
35 .find(registration_application_id)
37 local_user::table.on(registration_application::local_user_id.eq(local_user::id)),
39 .inner_join(person::table.on(local_user::person_id.eq(person::id)))
42 .on(registration_application::admin_id.eq(person_alias_1.field(person::id).nullable())),
44 .order_by(registration_application::published.desc())
46 registration_application::all_columns,
47 local_user::all_columns,
49 person_alias_1.fields(person::all_columns).nullable(),
51 .first::<RegistrationApplicationViewTuple>(conn)
54 Ok(RegistrationApplicationView {
55 registration_application,
62 /// Returns the current unread registration_application count
63 pub async fn get_unread_count(
64 pool: &mut DbPool<'_>,
65 verified_email_only: bool,
66 ) -> Result<i64, Error> {
67 let conn = &mut get_conn(pool).await?;
68 let person_alias_1 = diesel::alias!(person as person1);
70 let mut query = registration_application::table
71 .inner_join(local_user::table.on(registration_application::local_user_id.eq(local_user::id)))
72 .inner_join(person::table.on(local_user::person_id.eq(person::id)))
75 .on(registration_application::admin_id.eq(person_alias_1.field(person::id).nullable())),
77 .filter(registration_application::admin_id.is_null())
80 if verified_email_only {
81 query = query.filter(local_user::email_verified.eq(true))
85 .select(count(registration_application::id))
92 pub struct RegistrationApplicationQuery {
93 pub unread_only: Option<bool>,
94 pub verified_email_only: Option<bool>,
95 pub page: Option<i64>,
96 pub limit: Option<i64>,
99 impl RegistrationApplicationQuery {
102 pool: &mut DbPool<'_>,
103 ) -> Result<Vec<RegistrationApplicationView>, Error> {
104 let conn = &mut get_conn(pool).await?;
105 let person_alias_1 = diesel::alias!(person as person1);
107 let mut query = registration_application::table
108 .inner_join(local_user::table.on(registration_application::local_user_id.eq(local_user::id)))
109 .inner_join(person::table.on(local_user::person_id.eq(person::id)))
112 .on(registration_application::admin_id.eq(person_alias_1.field(person::id).nullable())),
114 .order_by(registration_application::published.desc())
116 registration_application::all_columns,
117 local_user::all_columns,
119 person_alias_1.fields(person::all_columns).nullable(),
123 if self.unread_only.unwrap_or(false) {
124 query = query.filter(registration_application::admin_id.is_null())
127 if self.verified_email_only.unwrap_or(false) {
128 query = query.filter(local_user::email_verified.eq(true))
131 let (limit, offset) = limit_and_offset(self.page, self.limit)?;
136 .order_by(registration_application::published.desc());
138 let res = query.load::<RegistrationApplicationViewTuple>(conn).await?;
143 .map(RegistrationApplicationView::from_tuple)
149 impl JoinView for RegistrationApplicationView {
150 type JoinTuple = RegistrationApplicationViewTuple;
151 fn from_tuple(a: Self::JoinTuple) -> Self {
153 registration_application: a.0,
154 creator_local_user: a.1,
163 #![allow(clippy::unwrap_used)]
164 #![allow(clippy::indexing_slicing)]
166 use crate::registration_application_view::{
167 RegistrationApplicationQuery,
168 RegistrationApplicationView,
170 use lemmy_db_schema::{
173 local_user::{LocalUser, LocalUserInsertForm, LocalUserUpdateForm},
174 person::{Person, PersonInsertForm},
175 registration_application::{
176 RegistrationApplication,
177 RegistrationApplicationInsertForm,
178 RegistrationApplicationUpdateForm,
182 utils::build_db_pool_for_tests,
184 use serial_test::serial;
188 async fn test_crud() {
189 let pool = &build_db_pool_for_tests().await;
190 let pool = &mut pool.into();
192 let inserted_instance = Instance::read_or_create(pool, "my_domain.tld".to_string())
196 let timmy_person_form = PersonInsertForm::builder()
197 .name("timmy_rav".into())
199 .public_key("pubkey".to_string())
200 .instance_id(inserted_instance.id)
203 let inserted_timmy_person = Person::create(pool, &timmy_person_form).await.unwrap();
205 let timmy_local_user_form = LocalUserInsertForm::builder()
206 .person_id(inserted_timmy_person.id)
207 .password_encrypted("nada".to_string())
210 let _inserted_timmy_local_user = LocalUser::create(pool, &timmy_local_user_form)
214 let sara_person_form = PersonInsertForm::builder()
215 .name("sara_rav".into())
216 .public_key("pubkey".to_string())
217 .instance_id(inserted_instance.id)
220 let inserted_sara_person = Person::create(pool, &sara_person_form).await.unwrap();
222 let sara_local_user_form = LocalUserInsertForm::builder()
223 .person_id(inserted_sara_person.id)
224 .password_encrypted("nada".to_string())
227 let inserted_sara_local_user = LocalUser::create(pool, &sara_local_user_form)
231 // Sara creates an application
232 let sara_app_form = RegistrationApplicationInsertForm {
233 local_user_id: inserted_sara_local_user.id,
234 answer: "LET ME IIIIINN".to_string(),
237 let sara_app = RegistrationApplication::create(pool, &sara_app_form)
241 let read_sara_app_view = RegistrationApplicationView::read(pool, sara_app.id)
245 let jess_person_form = PersonInsertForm::builder()
246 .name("jess_rav".into())
247 .public_key("pubkey".to_string())
248 .instance_id(inserted_instance.id)
251 let inserted_jess_person = Person::create(pool, &jess_person_form).await.unwrap();
253 let jess_local_user_form = LocalUserInsertForm::builder()
254 .person_id(inserted_jess_person.id)
255 .password_encrypted("nada".to_string())
258 let inserted_jess_local_user = LocalUser::create(pool, &jess_local_user_form)
262 // Sara creates an application
263 let jess_app_form = RegistrationApplicationInsertForm {
264 local_user_id: inserted_jess_local_user.id,
265 answer: "LET ME IIIIINN".to_string(),
268 let jess_app = RegistrationApplication::create(pool, &jess_app_form)
272 let read_jess_app_view = RegistrationApplicationView::read(pool, jess_app.id)
276 let mut expected_sara_app_view = RegistrationApplicationView {
277 registration_application: sara_app.clone(),
278 creator_local_user: LocalUser {
279 id: inserted_sara_local_user.id,
280 person_id: inserted_sara_local_user.person_id,
281 email: inserted_sara_local_user.email,
282 show_nsfw: inserted_sara_local_user.show_nsfw,
283 auto_expand: inserted_sara_local_user.auto_expand,
284 blur_nsfw: inserted_sara_local_user.blur_nsfw,
285 theme: inserted_sara_local_user.theme,
286 default_sort_type: inserted_sara_local_user.default_sort_type,
287 default_listing_type: inserted_sara_local_user.default_listing_type,
288 interface_language: inserted_sara_local_user.interface_language,
289 show_avatars: inserted_sara_local_user.show_avatars,
290 send_notifications_to_email: inserted_sara_local_user.send_notifications_to_email,
291 validator_time: inserted_sara_local_user.validator_time,
292 show_bot_accounts: inserted_sara_local_user.show_bot_accounts,
293 show_scores: inserted_sara_local_user.show_scores,
294 show_read_posts: inserted_sara_local_user.show_read_posts,
295 show_new_post_notifs: inserted_sara_local_user.show_new_post_notifs,
296 email_verified: inserted_sara_local_user.email_verified,
297 accepted_application: inserted_sara_local_user.accepted_application,
298 totp_2fa_secret: inserted_sara_local_user.totp_2fa_secret,
299 totp_2fa_url: inserted_sara_local_user.totp_2fa_url,
300 password_encrypted: inserted_sara_local_user.password_encrypted,
301 open_links_in_new_tab: inserted_sara_local_user.open_links_in_new_tab,
302 infinite_scroll_enabled: inserted_sara_local_user.infinite_scroll_enabled,
305 id: inserted_sara_person.id,
306 name: inserted_sara_person.name.clone(),
308 published: inserted_sara_person.published,
310 actor_id: inserted_sara_person.actor_id.clone(),
320 inbox_url: inserted_sara_person.inbox_url.clone(),
321 shared_inbox_url: None,
322 matrix_user_id: None,
323 instance_id: inserted_instance.id,
324 private_key: inserted_sara_person.private_key,
325 public_key: inserted_sara_person.public_key,
326 last_refreshed_at: inserted_sara_person.last_refreshed_at,
331 assert_eq!(read_sara_app_view, expected_sara_app_view);
333 // Do a batch read of the applications
334 let apps = RegistrationApplicationQuery {
335 unread_only: (Some(true)),
344 [read_jess_app_view.clone(), expected_sara_app_view.clone()]
347 // Make sure the counts are correct
348 let unread_count = RegistrationApplicationView::get_unread_count(pool, false)
351 assert_eq!(unread_count, 2);
353 // Approve the application
354 let approve_form = RegistrationApplicationUpdateForm {
355 admin_id: Some(Some(inserted_timmy_person.id)),
359 RegistrationApplication::update(pool, sara_app.id, &approve_form)
363 // Update the local_user row
364 let approve_local_user_form = LocalUserUpdateForm::builder()
365 .accepted_application(Some(true))
368 LocalUser::update(pool, inserted_sara_local_user.id, &approve_local_user_form)
372 let read_sara_app_view_after_approve = RegistrationApplicationView::read(pool, sara_app.id)
376 // Make sure the columns changed
377 expected_sara_app_view
379 .accepted_application = true;
380 expected_sara_app_view.registration_application.admin_id = Some(inserted_timmy_person.id);
382 expected_sara_app_view.admin = Some(Person {
383 id: inserted_timmy_person.id,
384 name: inserted_timmy_person.name.clone(),
386 published: inserted_timmy_person.published,
388 actor_id: inserted_timmy_person.actor_id.clone(),
398 inbox_url: inserted_timmy_person.inbox_url.clone(),
399 shared_inbox_url: None,
400 matrix_user_id: None,
401 instance_id: inserted_instance.id,
402 private_key: inserted_timmy_person.private_key,
403 public_key: inserted_timmy_person.public_key,
404 last_refreshed_at: inserted_timmy_person.last_refreshed_at,
406 assert_eq!(read_sara_app_view_after_approve, expected_sara_app_view);
408 // Do a batch read of apps again
409 // It should show only jessicas which is unresolved
410 let apps_after_resolve = RegistrationApplicationQuery {
411 unread_only: (Some(true)),
417 assert_eq!(apps_after_resolve, vec![read_jess_app_view]);
419 // Make sure the counts are correct
420 let unread_count_after_approve = RegistrationApplicationView::get_unread_count(pool, false)
423 assert_eq!(unread_count_after_approve, 1);
425 // Make sure the not undenied_only has all the apps
426 let all_apps = RegistrationApplicationQuery::default()
430 assert_eq!(all_apps.len(), 2);
432 Person::delete(pool, inserted_timmy_person.id)
435 Person::delete(pool, inserted_sara_person.id).await.unwrap();
436 Person::delete(pool, inserted_jess_person.id).await.unwrap();
437 Instance::delete(pool, inserted_instance.id).await.unwrap();