X-Git-Url: http://these/git/?a=blobdiff_plain;f=crates%2Fdb_views%2Fsrc%2Fregistration_application_view.rs;h=46556317f4bae9b26617fb076d1c9ebb22d3c59d;hb=c8063f3267cf2b3622f1fdc69128c6b55feefbbc;hp=1a5fc9bbbb0c695cf12ddb768075e2a7b81d8c2b;hpb=c883a49a4096b171f324d44c9fcacda55ed361ee;p=lemmy.git diff --git a/crates/db_views/src/registration_application_view.rs b/crates/db_views/src/registration_application_view.rs index 1a5fc9bb..46556317 100644 --- a/crates/db_views/src/registration_application_view.rs +++ b/crates/db_views/src/registration_application_view.rs @@ -1,276 +1,280 @@ -use diesel::{dsl::count, result::Error, *}; +use crate::structs::RegistrationApplicationView; +use diesel::{ + dsl::count, + pg::Pg, + result::Error, + ExpressionMethods, + JoinOnDsl, + NullableExpressionMethods, + QueryDsl, +}; +use diesel_async::RunQueryDsl; use lemmy_db_schema::{ - limit_and_offset, - schema::{local_user, person, person_alias_1, registration_application}, + aliases, + schema::{local_user, person, registration_application}, source::{ - local_user::{LocalUser, LocalUserSettings}, - person::{Person, PersonAlias1, PersonSafe, PersonSafeAlias1}, + local_user::LocalUser, + person::Person, registration_application::RegistrationApplication, }, - traits::{MaybeOptional, ToSafe, ToSafeSettings, ViewToVec}, + traits::JoinView, + utils::{get_conn, limit_and_offset, DbConn, DbPool, ListFn, Queries, ReadFn}, }; -use serde::{Deserialize, Serialize}; - -#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)] -pub struct RegistrationApplicationView { - pub registration_application: RegistrationApplication, - pub creator_local_user: LocalUserSettings, - pub creator: PersonSafe, - pub admin: Option, -} - -type RegistrationApplicationViewTuple = ( - RegistrationApplication, - LocalUserSettings, - PersonSafe, - Option, -); -impl RegistrationApplicationView { - pub fn read(conn: &PgConnection, registration_application_id: i32) -> Result { - let (registration_application, creator_local_user, creator, admin) = - registration_application::table - .find(registration_application_id) - .inner_join( - local_user::table.on(registration_application::local_user_id.eq(local_user::id)), - ) - .inner_join(person::table.on(local_user::person_id.eq(person::id))) - .left_join( - person_alias_1::table - .on(registration_application::admin_id.eq(person_alias_1::id.nullable())), - ) - .order_by(registration_application::published.desc()) - .select(( - registration_application::all_columns, - LocalUser::safe_settings_columns_tuple(), - Person::safe_columns_tuple(), - PersonAlias1::safe_columns_tuple().nullable(), - )) - .first::(conn)?; - - Ok(RegistrationApplicationView { - registration_application, - creator_local_user, - creator, - admin, - }) - } +type RegistrationApplicationViewTuple = + (RegistrationApplication, LocalUser, Person, Option); - /// Returns the current unread registration_application count - pub fn get_unread_count(conn: &PgConnection, verified_email_only: bool) -> Result { - let mut query = registration_application::table +fn queries<'a>() -> Queries< + impl ReadFn<'a, RegistrationApplicationView, i32>, + impl ListFn<'a, RegistrationApplicationView, RegistrationApplicationQuery>, +> { + let all_joins = |query: registration_application::BoxedQuery<'a, Pg>| { + query .inner_join(local_user::table.on(registration_application::local_user_id.eq(local_user::id))) .inner_join(person::table.on(local_user::person_id.eq(person::id))) .left_join( - person_alias_1::table - .on(registration_application::admin_id.eq(person_alias_1::id.nullable())), + aliases::person1 + .on(registration_application::admin_id.eq(aliases::person1.field(person::id).nullable())), ) - .filter(registration_application::admin_id.is_null()) - .into_boxed(); + .order_by(registration_application::published.desc()) + .select(( + registration_application::all_columns, + local_user::all_columns, + person::all_columns, + aliases::person1.fields(person::all_columns).nullable(), + )) + }; - if verified_email_only { - query = query.filter(local_user::email_verified.eq(true)) - } + let read = move |mut conn: DbConn<'a>, registration_application_id: i32| async move { + all_joins( + registration_application::table + .find(registration_application_id) + .into_boxed(), + ) + .first::(&mut conn) + .await + }; - query - .select(count(registration_application::id)) - .first::(conn) - } -} + let list = move |mut conn: DbConn<'a>, options: RegistrationApplicationQuery| async move { + let mut query = all_joins(registration_application::table.into_boxed()); -pub struct RegistrationApplicationQueryBuilder<'a> { - conn: &'a PgConnection, - unread_only: Option, - verified_email_only: Option, - page: Option, - limit: Option, -} + if options.unread_only { + query = query.filter(registration_application::admin_id.is_null()) + } -impl<'a> RegistrationApplicationQueryBuilder<'a> { - pub fn create(conn: &'a PgConnection) -> Self { - RegistrationApplicationQueryBuilder { - conn, - unread_only: None, - verified_email_only: None, - page: None, - limit: None, + if options.verified_email_only { + query = query.filter(local_user::email_verified.eq(true)) } - } - pub fn unread_only>(mut self, unread_only: T) -> Self { - self.unread_only = unread_only.get_optional(); - self - } + let (limit, offset) = limit_and_offset(options.page, options.limit)?; - pub fn verified_email_only>(mut self, verified_email_only: T) -> Self { - self.verified_email_only = verified_email_only.get_optional(); - self - } + query = query + .limit(limit) + .offset(offset) + .order_by(registration_application::published.desc()); - pub fn page>(mut self, page: T) -> Self { - self.page = page.get_optional(); - self - } + query + .load::(&mut conn) + .await + }; - pub fn limit>(mut self, limit: T) -> Self { - self.limit = limit.get_optional(); - self + Queries::new(read, list) +} + +impl RegistrationApplicationView { + pub async fn read( + pool: &mut DbPool<'_>, + registration_application_id: i32, + ) -> Result { + queries().read(pool, registration_application_id).await } - pub fn list(self) -> Result, Error> { + /// Returns the current unread registration_application count + pub async fn get_unread_count( + pool: &mut DbPool<'_>, + verified_email_only: bool, + ) -> Result { + let conn = &mut get_conn(pool).await?; + let person_alias_1 = diesel::alias!(person as person1); + let mut query = registration_application::table .inner_join(local_user::table.on(registration_application::local_user_id.eq(local_user::id))) .inner_join(person::table.on(local_user::person_id.eq(person::id))) .left_join( - person_alias_1::table - .on(registration_application::admin_id.eq(person_alias_1::id.nullable())), + person_alias_1 + .on(registration_application::admin_id.eq(person_alias_1.field(person::id).nullable())), ) - .order_by(registration_application::published.desc()) - .select(( - registration_application::all_columns, - LocalUser::safe_settings_columns_tuple(), - Person::safe_columns_tuple(), - PersonAlias1::safe_columns_tuple().nullable(), - )) + .filter(registration_application::admin_id.is_null()) .into_boxed(); - if self.unread_only.unwrap_or(false) { - query = query.filter(registration_application::admin_id.is_null()) - } - - if self.verified_email_only.unwrap_or(false) { + if verified_email_only { query = query.filter(local_user::email_verified.eq(true)) } - let (limit, offset) = limit_and_offset(self.page, self.limit); - - query = query - .limit(limit) - .offset(offset) - .order_by(registration_application::published.desc()); + query + .select(count(registration_application::id)) + .first::(conn) + .await + } +} - let res = query.load::(self.conn)?; +#[derive(Default)] +pub struct RegistrationApplicationQuery { + pub unread_only: bool, + pub verified_email_only: bool, + pub page: Option, + pub limit: Option, +} - Ok(RegistrationApplicationView::from_tuple_to_vec(res)) +impl RegistrationApplicationQuery { + pub async fn list( + self, + pool: &mut DbPool<'_>, + ) -> Result, Error> { + queries().list(pool, self).await } } -impl ViewToVec for RegistrationApplicationView { - type DbTuple = RegistrationApplicationViewTuple; - fn from_tuple_to_vec(items: Vec) -> Vec { - items - .iter() - .map(|a| Self { - registration_application: a.0.to_owned(), - creator_local_user: a.1.to_owned(), - creator: a.2.to_owned(), - admin: a.3.to_owned(), - }) - .collect::>() +impl JoinView for RegistrationApplicationView { + type JoinTuple = RegistrationApplicationViewTuple; + fn from_tuple(a: Self::JoinTuple) -> Self { + Self { + registration_application: a.0, + creator_local_user: a.1, + creator: a.2, + admin: a.3, + } } } #[cfg(test)] mod tests { + #![allow(clippy::unwrap_used)] + #![allow(clippy::indexing_slicing)] + use crate::registration_application_view::{ - RegistrationApplicationQueryBuilder, + RegistrationApplicationQuery, RegistrationApplicationView, }; use lemmy_db_schema::{ - establish_unpooled_connection, source::{ - local_user::{LocalUser, LocalUserForm, LocalUserSettings}, - person::*, - registration_application::{RegistrationApplication, RegistrationApplicationForm}, + instance::Instance, + local_user::{LocalUser, LocalUserInsertForm, LocalUserUpdateForm}, + person::{Person, PersonInsertForm}, + registration_application::{ + RegistrationApplication, + RegistrationApplicationInsertForm, + RegistrationApplicationUpdateForm, + }, }, traits::Crud, + utils::build_db_pool_for_tests, }; use serial_test::serial; - #[test] + #[tokio::test] #[serial] - fn test_crud() { - let conn = establish_unpooled_connection(); + async fn test_crud() { + let pool = &build_db_pool_for_tests().await; + let pool = &mut pool.into(); - let timmy_person_form = PersonForm { - name: "timmy_rav".into(), - admin: Some(true), - ..PersonForm::default() - }; + let inserted_instance = Instance::read_or_create(pool, "my_domain.tld".to_string()) + .await + .unwrap(); - let inserted_timmy_person = Person::create(&conn, &timmy_person_form).unwrap(); + let timmy_person_form = PersonInsertForm::builder() + .name("timmy_rav".into()) + .admin(Some(true)) + .public_key("pubkey".to_string()) + .instance_id(inserted_instance.id) + .build(); - let timmy_local_user_form = LocalUserForm { - person_id: Some(inserted_timmy_person.id), - password_encrypted: Some("nada".to_string()), - ..LocalUserForm::default() - }; + let inserted_timmy_person = Person::create(pool, &timmy_person_form).await.unwrap(); - let _inserted_timmy_local_user = LocalUser::create(&conn, &timmy_local_user_form).unwrap(); + let timmy_local_user_form = LocalUserInsertForm::builder() + .person_id(inserted_timmy_person.id) + .password_encrypted("nada".to_string()) + .build(); - let sara_person_form = PersonForm { - name: "sara_rav".into(), - ..PersonForm::default() - }; + let _inserted_timmy_local_user = LocalUser::create(pool, &timmy_local_user_form) + .await + .unwrap(); - let inserted_sara_person = Person::create(&conn, &sara_person_form).unwrap(); + let sara_person_form = PersonInsertForm::builder() + .name("sara_rav".into()) + .public_key("pubkey".to_string()) + .instance_id(inserted_instance.id) + .build(); - let sara_local_user_form = LocalUserForm { - person_id: Some(inserted_sara_person.id), - password_encrypted: Some("nada".to_string()), - ..LocalUserForm::default() - }; + let inserted_sara_person = Person::create(pool, &sara_person_form).await.unwrap(); + + let sara_local_user_form = LocalUserInsertForm::builder() + .person_id(inserted_sara_person.id) + .password_encrypted("nada".to_string()) + .build(); - let inserted_sara_local_user = LocalUser::create(&conn, &sara_local_user_form).unwrap(); + let inserted_sara_local_user = LocalUser::create(pool, &sara_local_user_form) + .await + .unwrap(); // Sara creates an application - let sara_app_form = RegistrationApplicationForm { - local_user_id: Some(inserted_sara_local_user.id), - answer: Some("LET ME IIIIINN".to_string()), - ..RegistrationApplicationForm::default() + let sara_app_form = RegistrationApplicationInsertForm { + local_user_id: inserted_sara_local_user.id, + answer: "LET ME IIIIINN".to_string(), }; - let sara_app = RegistrationApplication::create(&conn, &sara_app_form).unwrap(); + let sara_app = RegistrationApplication::create(pool, &sara_app_form) + .await + .unwrap(); - let read_sara_app_view = RegistrationApplicationView::read(&conn, sara_app.id).unwrap(); + let read_sara_app_view = RegistrationApplicationView::read(pool, sara_app.id) + .await + .unwrap(); - let jess_person_form = PersonForm { - name: "jess_rav".into(), - ..PersonForm::default() - }; + let jess_person_form = PersonInsertForm::builder() + .name("jess_rav".into()) + .public_key("pubkey".to_string()) + .instance_id(inserted_instance.id) + .build(); - let inserted_jess_person = Person::create(&conn, &jess_person_form).unwrap(); + let inserted_jess_person = Person::create(pool, &jess_person_form).await.unwrap(); - let jess_local_user_form = LocalUserForm { - person_id: Some(inserted_jess_person.id), - password_encrypted: Some("nada".to_string()), - ..LocalUserForm::default() - }; + let jess_local_user_form = LocalUserInsertForm::builder() + .person_id(inserted_jess_person.id) + .password_encrypted("nada".to_string()) + .build(); - let inserted_jess_local_user = LocalUser::create(&conn, &jess_local_user_form).unwrap(); + let inserted_jess_local_user = LocalUser::create(pool, &jess_local_user_form) + .await + .unwrap(); // Sara creates an application - let jess_app_form = RegistrationApplicationForm { - local_user_id: Some(inserted_jess_local_user.id), - answer: Some("LET ME IIIIINN".to_string()), - ..RegistrationApplicationForm::default() + let jess_app_form = RegistrationApplicationInsertForm { + local_user_id: inserted_jess_local_user.id, + answer: "LET ME IIIIINN".to_string(), }; - let jess_app = RegistrationApplication::create(&conn, &jess_app_form).unwrap(); + let jess_app = RegistrationApplication::create(pool, &jess_app_form) + .await + .unwrap(); - let read_jess_app_view = RegistrationApplicationView::read(&conn, jess_app.id).unwrap(); + let read_jess_app_view = RegistrationApplicationView::read(pool, jess_app.id) + .await + .unwrap(); let mut expected_sara_app_view = RegistrationApplicationView { - registration_application: sara_app.to_owned(), - creator_local_user: LocalUserSettings { + registration_application: sara_app.clone(), + creator_local_user: LocalUser { id: inserted_sara_local_user.id, person_id: inserted_sara_local_user.person_id, email: inserted_sara_local_user.email, show_nsfw: inserted_sara_local_user.show_nsfw, + auto_expand: inserted_sara_local_user.auto_expand, + blur_nsfw: inserted_sara_local_user.blur_nsfw, theme: inserted_sara_local_user.theme, default_sort_type: inserted_sara_local_user.default_sort_type, default_listing_type: inserted_sara_local_user.default_listing_type, - lang: inserted_sara_local_user.lang, + interface_language: inserted_sara_local_user.interface_language, show_avatars: inserted_sara_local_user.show_avatars, send_notifications_to_email: inserted_sara_local_user.send_notifications_to_email, validator_time: inserted_sara_local_user.validator_time, @@ -280,25 +284,35 @@ mod tests { show_new_post_notifs: inserted_sara_local_user.show_new_post_notifs, email_verified: inserted_sara_local_user.email_verified, accepted_application: inserted_sara_local_user.accepted_application, + totp_2fa_secret: inserted_sara_local_user.totp_2fa_secret, + totp_2fa_url: inserted_sara_local_user.totp_2fa_url, + password_encrypted: inserted_sara_local_user.password_encrypted, + open_links_in_new_tab: inserted_sara_local_user.open_links_in_new_tab, + infinite_scroll_enabled: inserted_sara_local_user.infinite_scroll_enabled, }, - creator: PersonSafe { + creator: Person { id: inserted_sara_person.id, - name: inserted_sara_person.name.to_owned(), + name: inserted_sara_person.name.clone(), display_name: None, published: inserted_sara_person.published, avatar: None, - actor_id: inserted_sara_person.actor_id.to_owned(), + actor_id: inserted_sara_person.actor_id.clone(), local: true, banned: false, + ban_expires: None, deleted: false, admin: false, bot_account: false, bio: None, banner: None, updated: None, - inbox_url: inserted_sara_person.inbox_url.to_owned(), + inbox_url: inserted_sara_person.inbox_url.clone(), shared_inbox_url: None, matrix_user_id: None, + instance_id: inserted_instance.id, + private_key: inserted_sara_person.private_key, + public_key: inserted_sara_person.public_key, + last_refreshed_at: inserted_sara_person.last_refreshed_at, }, admin: None, }; @@ -306,42 +320,48 @@ mod tests { assert_eq!(read_sara_app_view, expected_sara_app_view); // Do a batch read of the applications - let apps = RegistrationApplicationQueryBuilder::create(&conn) - .unread_only(true) - .list() - .unwrap(); + let apps = RegistrationApplicationQuery { + unread_only: (true), + ..Default::default() + } + .list(pool) + .await + .unwrap(); assert_eq!( apps, - [ - read_jess_app_view.to_owned(), - expected_sara_app_view.to_owned() - ] + [read_jess_app_view.clone(), expected_sara_app_view.clone()] ); // Make sure the counts are correct - let unread_count = RegistrationApplicationView::get_unread_count(&conn, false).unwrap(); + let unread_count = RegistrationApplicationView::get_unread_count(pool, false) + .await + .unwrap(); assert_eq!(unread_count, 2); // Approve the application - let approve_form = RegistrationApplicationForm { - admin_id: Some(inserted_timmy_person.id), + let approve_form = RegistrationApplicationUpdateForm { + admin_id: Some(Some(inserted_timmy_person.id)), deny_reason: None, - ..RegistrationApplicationForm::default() }; - RegistrationApplication::update(&conn, sara_app.id, &approve_form).unwrap(); + RegistrationApplication::update(pool, sara_app.id, &approve_form) + .await + .unwrap(); // Update the local_user row - let approve_local_user_form = LocalUserForm { + let approve_local_user_form = LocalUserUpdateForm { accepted_application: Some(true), - ..LocalUserForm::default() + ..Default::default() }; - LocalUser::update(&conn, inserted_sara_local_user.id, &approve_local_user_form).unwrap(); + LocalUser::update(pool, inserted_sara_local_user.id, &approve_local_user_form) + .await + .unwrap(); - let read_sara_app_view_after_approve = - RegistrationApplicationView::read(&conn, sara_app.id).unwrap(); + let read_sara_app_view_after_approve = RegistrationApplicationView::read(pool, sara_app.id) + .await + .unwrap(); // Make sure the columns changed expected_sara_app_view @@ -349,48 +369,61 @@ mod tests { .accepted_application = true; expected_sara_app_view.registration_application.admin_id = Some(inserted_timmy_person.id); - expected_sara_app_view.admin = Some(PersonSafeAlias1 { + expected_sara_app_view.admin = Some(Person { id: inserted_timmy_person.id, - name: inserted_timmy_person.name.to_owned(), + name: inserted_timmy_person.name.clone(), display_name: None, published: inserted_timmy_person.published, avatar: None, - actor_id: inserted_timmy_person.actor_id.to_owned(), + actor_id: inserted_timmy_person.actor_id.clone(), local: true, banned: false, + ban_expires: None, deleted: false, admin: true, bot_account: false, bio: None, banner: None, updated: None, - inbox_url: inserted_timmy_person.inbox_url.to_owned(), + inbox_url: inserted_timmy_person.inbox_url.clone(), shared_inbox_url: None, matrix_user_id: None, + instance_id: inserted_instance.id, + private_key: inserted_timmy_person.private_key, + public_key: inserted_timmy_person.public_key, + last_refreshed_at: inserted_timmy_person.last_refreshed_at, }); assert_eq!(read_sara_app_view_after_approve, expected_sara_app_view); // Do a batch read of apps again // It should show only jessicas which is unresolved - let apps_after_resolve = RegistrationApplicationQueryBuilder::create(&conn) - .unread_only(true) - .list() - .unwrap(); + let apps_after_resolve = RegistrationApplicationQuery { + unread_only: (true), + ..Default::default() + } + .list(pool) + .await + .unwrap(); assert_eq!(apps_after_resolve, vec![read_jess_app_view]); // Make sure the counts are correct - let unread_count_after_approve = - RegistrationApplicationView::get_unread_count(&conn, false).unwrap(); + let unread_count_after_approve = RegistrationApplicationView::get_unread_count(pool, false) + .await + .unwrap(); assert_eq!(unread_count_after_approve, 1); // Make sure the not undenied_only has all the apps - let all_apps = RegistrationApplicationQueryBuilder::create(&conn) - .list() + let all_apps = RegistrationApplicationQuery::default() + .list(pool) + .await .unwrap(); assert_eq!(all_apps.len(), 2); - Person::delete(&conn, inserted_timmy_person.id).unwrap(); - Person::delete(&conn, inserted_sara_person.id).unwrap(); - Person::delete(&conn, inserted_jess_person.id).unwrap(); + Person::delete(pool, inserted_timmy_person.id) + .await + .unwrap(); + Person::delete(pool, inserted_sara_person.id).await.unwrap(); + Person::delete(pool, inserted_jess_person.id).await.unwrap(); + Instance::delete(pool, inserted_instance.id).await.unwrap(); } }