1 use crate::structs::RegistrationApplicationView;
8 NullableExpressionMethods,
11 use diesel_async::RunQueryDsl;
12 use lemmy_db_schema::{
14 schema::{local_user, person, registration_application},
16 local_user::LocalUser,
18 registration_application::RegistrationApplication,
21 utils::{get_conn, limit_and_offset, DbConn, DbPool, ListFn, Queries, ReadFn},
24 type RegistrationApplicationViewTuple =
25 (RegistrationApplication, LocalUser, Person, Option<Person>);
27 fn queries<'a>() -> Queries<
28 impl ReadFn<'a, RegistrationApplicationView, i32>,
29 impl ListFn<'a, RegistrationApplicationView, RegistrationApplicationQuery>,
31 let all_joins = |query: registration_application::BoxedQuery<'a, Pg>| {
33 .inner_join(local_user::table.on(registration_application::local_user_id.eq(local_user::id)))
34 .inner_join(person::table.on(local_user::person_id.eq(person::id)))
37 .on(registration_application::admin_id.eq(aliases::person1.field(person::id).nullable())),
39 .order_by(registration_application::published.desc())
41 registration_application::all_columns,
42 local_user::all_columns,
44 aliases::person1.fields(person::all_columns).nullable(),
48 let read = move |mut conn: DbConn<'a>, registration_application_id: i32| async move {
50 registration_application::table
51 .find(registration_application_id)
54 .first::<RegistrationApplicationViewTuple>(&mut conn)
58 let list = move |mut conn: DbConn<'a>, options: RegistrationApplicationQuery| async move {
59 let mut query = all_joins(registration_application::table.into_boxed());
61 if options.unread_only {
62 query = query.filter(registration_application::admin_id.is_null())
65 if options.verified_email_only {
66 query = query.filter(local_user::email_verified.eq(true))
69 let (limit, offset) = limit_and_offset(options.page, options.limit)?;
74 .order_by(registration_application::published.desc());
77 .load::<RegistrationApplicationViewTuple>(&mut conn)
81 Queries::new(read, list)
84 impl RegistrationApplicationView {
86 pool: &mut DbPool<'_>,
87 registration_application_id: i32,
88 ) -> Result<Self, Error> {
89 queries().read(pool, registration_application_id).await
92 /// Returns the current unread registration_application count
93 pub async fn get_unread_count(
94 pool: &mut DbPool<'_>,
95 verified_email_only: bool,
96 ) -> Result<i64, Error> {
97 let conn = &mut get_conn(pool).await?;
98 let person_alias_1 = diesel::alias!(person as person1);
100 let mut query = registration_application::table
101 .inner_join(local_user::table.on(registration_application::local_user_id.eq(local_user::id)))
102 .inner_join(person::table.on(local_user::person_id.eq(person::id)))
105 .on(registration_application::admin_id.eq(person_alias_1.field(person::id).nullable())),
107 .filter(registration_application::admin_id.is_null())
110 if verified_email_only {
111 query = query.filter(local_user::email_verified.eq(true))
115 .select(count(registration_application::id))
122 pub struct RegistrationApplicationQuery {
123 pub unread_only: bool,
124 pub verified_email_only: bool,
125 pub page: Option<i64>,
126 pub limit: Option<i64>,
129 impl RegistrationApplicationQuery {
132 pool: &mut DbPool<'_>,
133 ) -> Result<Vec<RegistrationApplicationView>, Error> {
134 queries().list(pool, self).await
138 impl JoinView for RegistrationApplicationView {
139 type JoinTuple = RegistrationApplicationViewTuple;
140 fn from_tuple(a: Self::JoinTuple) -> Self {
142 registration_application: a.0,
143 creator_local_user: a.1,
152 #![allow(clippy::unwrap_used)]
153 #![allow(clippy::indexing_slicing)]
155 use crate::registration_application_view::{
156 RegistrationApplicationQuery,
157 RegistrationApplicationView,
159 use lemmy_db_schema::{
162 local_user::{LocalUser, LocalUserInsertForm, LocalUserUpdateForm},
163 person::{Person, PersonInsertForm},
164 registration_application::{
165 RegistrationApplication,
166 RegistrationApplicationInsertForm,
167 RegistrationApplicationUpdateForm,
171 utils::build_db_pool_for_tests,
173 use serial_test::serial;
177 async fn test_crud() {
178 let pool = &build_db_pool_for_tests().await;
179 let pool = &mut pool.into();
181 let inserted_instance = Instance::read_or_create(pool, "my_domain.tld".to_string())
185 let timmy_person_form = PersonInsertForm::builder()
186 .name("timmy_rav".into())
188 .public_key("pubkey".to_string())
189 .instance_id(inserted_instance.id)
192 let inserted_timmy_person = Person::create(pool, &timmy_person_form).await.unwrap();
194 let timmy_local_user_form = LocalUserInsertForm::builder()
195 .person_id(inserted_timmy_person.id)
196 .password_encrypted("nada".to_string())
199 let _inserted_timmy_local_user = LocalUser::create(pool, &timmy_local_user_form)
203 let sara_person_form = PersonInsertForm::builder()
204 .name("sara_rav".into())
205 .public_key("pubkey".to_string())
206 .instance_id(inserted_instance.id)
209 let inserted_sara_person = Person::create(pool, &sara_person_form).await.unwrap();
211 let sara_local_user_form = LocalUserInsertForm::builder()
212 .person_id(inserted_sara_person.id)
213 .password_encrypted("nada".to_string())
216 let inserted_sara_local_user = LocalUser::create(pool, &sara_local_user_form)
220 // Sara creates an application
221 let sara_app_form = RegistrationApplicationInsertForm {
222 local_user_id: inserted_sara_local_user.id,
223 answer: "LET ME IIIIINN".to_string(),
226 let sara_app = RegistrationApplication::create(pool, &sara_app_form)
230 let read_sara_app_view = RegistrationApplicationView::read(pool, sara_app.id)
234 let jess_person_form = PersonInsertForm::builder()
235 .name("jess_rav".into())
236 .public_key("pubkey".to_string())
237 .instance_id(inserted_instance.id)
240 let inserted_jess_person = Person::create(pool, &jess_person_form).await.unwrap();
242 let jess_local_user_form = LocalUserInsertForm::builder()
243 .person_id(inserted_jess_person.id)
244 .password_encrypted("nada".to_string())
247 let inserted_jess_local_user = LocalUser::create(pool, &jess_local_user_form)
251 // Sara creates an application
252 let jess_app_form = RegistrationApplicationInsertForm {
253 local_user_id: inserted_jess_local_user.id,
254 answer: "LET ME IIIIINN".to_string(),
257 let jess_app = RegistrationApplication::create(pool, &jess_app_form)
261 let read_jess_app_view = RegistrationApplicationView::read(pool, jess_app.id)
265 let mut expected_sara_app_view = RegistrationApplicationView {
266 registration_application: sara_app.clone(),
267 creator_local_user: LocalUser {
268 id: inserted_sara_local_user.id,
269 person_id: inserted_sara_local_user.person_id,
270 email: inserted_sara_local_user.email,
271 show_nsfw: inserted_sara_local_user.show_nsfw,
272 auto_expand: inserted_sara_local_user.auto_expand,
273 blur_nsfw: inserted_sara_local_user.blur_nsfw,
274 theme: inserted_sara_local_user.theme,
275 default_sort_type: inserted_sara_local_user.default_sort_type,
276 default_listing_type: inserted_sara_local_user.default_listing_type,
277 interface_language: inserted_sara_local_user.interface_language,
278 show_avatars: inserted_sara_local_user.show_avatars,
279 send_notifications_to_email: inserted_sara_local_user.send_notifications_to_email,
280 validator_time: inserted_sara_local_user.validator_time,
281 show_bot_accounts: inserted_sara_local_user.show_bot_accounts,
282 show_scores: inserted_sara_local_user.show_scores,
283 show_read_posts: inserted_sara_local_user.show_read_posts,
284 show_new_post_notifs: inserted_sara_local_user.show_new_post_notifs,
285 email_verified: inserted_sara_local_user.email_verified,
286 accepted_application: inserted_sara_local_user.accepted_application,
287 totp_2fa_secret: inserted_sara_local_user.totp_2fa_secret,
288 totp_2fa_url: inserted_sara_local_user.totp_2fa_url,
289 password_encrypted: inserted_sara_local_user.password_encrypted,
290 open_links_in_new_tab: inserted_sara_local_user.open_links_in_new_tab,
291 infinite_scroll_enabled: inserted_sara_local_user.infinite_scroll_enabled,
294 id: inserted_sara_person.id,
295 name: inserted_sara_person.name.clone(),
297 published: inserted_sara_person.published,
299 actor_id: inserted_sara_person.actor_id.clone(),
309 inbox_url: inserted_sara_person.inbox_url.clone(),
310 shared_inbox_url: None,
311 matrix_user_id: None,
312 instance_id: inserted_instance.id,
313 private_key: inserted_sara_person.private_key,
314 public_key: inserted_sara_person.public_key,
315 last_refreshed_at: inserted_sara_person.last_refreshed_at,
320 assert_eq!(read_sara_app_view, expected_sara_app_view);
322 // Do a batch read of the applications
323 let apps = RegistrationApplicationQuery {
333 [read_jess_app_view.clone(), expected_sara_app_view.clone()]
336 // Make sure the counts are correct
337 let unread_count = RegistrationApplicationView::get_unread_count(pool, false)
340 assert_eq!(unread_count, 2);
342 // Approve the application
343 let approve_form = RegistrationApplicationUpdateForm {
344 admin_id: Some(Some(inserted_timmy_person.id)),
348 RegistrationApplication::update(pool, sara_app.id, &approve_form)
352 // Update the local_user row
353 let approve_local_user_form = LocalUserUpdateForm {
354 accepted_application: Some(true),
358 LocalUser::update(pool, inserted_sara_local_user.id, &approve_local_user_form)
362 let read_sara_app_view_after_approve = RegistrationApplicationView::read(pool, sara_app.id)
366 // Make sure the columns changed
367 expected_sara_app_view
369 .accepted_application = true;
370 expected_sara_app_view.registration_application.admin_id = Some(inserted_timmy_person.id);
372 expected_sara_app_view.admin = Some(Person {
373 id: inserted_timmy_person.id,
374 name: inserted_timmy_person.name.clone(),
376 published: inserted_timmy_person.published,
378 actor_id: inserted_timmy_person.actor_id.clone(),
388 inbox_url: inserted_timmy_person.inbox_url.clone(),
389 shared_inbox_url: None,
390 matrix_user_id: None,
391 instance_id: inserted_instance.id,
392 private_key: inserted_timmy_person.private_key,
393 public_key: inserted_timmy_person.public_key,
394 last_refreshed_at: inserted_timmy_person.last_refreshed_at,
396 assert_eq!(read_sara_app_view_after_approve, expected_sara_app_view);
398 // Do a batch read of apps again
399 // It should show only jessicas which is unresolved
400 let apps_after_resolve = RegistrationApplicationQuery {
407 assert_eq!(apps_after_resolve, vec![read_jess_app_view]);
409 // Make sure the counts are correct
410 let unread_count_after_approve = RegistrationApplicationView::get_unread_count(pool, false)
413 assert_eq!(unread_count_after_approve, 1);
415 // Make sure the not undenied_only has all the apps
416 let all_apps = RegistrationApplicationQuery::default()
420 assert_eq!(all_apps.len(), 2);
422 Person::delete(pool, inserted_timmy_person.id)
425 Person::delete(pool, inserted_sara_person.id).await.unwrap();
426 Person::delete(pool, inserted_jess_person.id).await.unwrap();
427 Instance::delete(pool, inserted_instance.id).await.unwrap();