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, LocalUserSettings},
15 person::{Person, PersonSafe},
16 registration_application::RegistrationApplication,
18 traits::{ToSafe, ToSafeSettings, ViewToVec},
19 utils::{get_conn, limit_and_offset, DbPool},
21 use typed_builder::TypedBuilder;
23 type RegistrationApplicationViewTuple = (
24 RegistrationApplication,
30 impl RegistrationApplicationView {
31 pub async fn read(pool: &DbPool, registration_application_id: i32) -> Result<Self, Error> {
32 let conn = &mut get_conn(pool).await?;
33 let person_alias_1 = diesel::alias!(person as person1);
35 let (registration_application, creator_local_user, creator, admin) =
36 registration_application::table
37 .find(registration_application_id)
39 local_user::table.on(registration_application::local_user_id.eq(local_user::id)),
41 .inner_join(person::table.on(local_user::person_id.eq(person::id)))
44 .on(registration_application::admin_id.eq(person_alias_1.field(person::id).nullable())),
46 .order_by(registration_application::published.desc())
48 registration_application::all_columns,
49 LocalUser::safe_settings_columns_tuple(),
50 Person::safe_columns_tuple(),
52 .fields(Person::safe_columns_tuple())
55 .first::<RegistrationApplicationViewTuple>(conn)
58 Ok(RegistrationApplicationView {
59 registration_application,
66 /// Returns the current unread registration_application count
67 pub async fn get_unread_count(pool: &DbPool, verified_email_only: bool) -> Result<i64, Error> {
68 let conn = &mut get_conn(pool).await?;
69 let person_alias_1 = diesel::alias!(person as person1);
71 let mut query = registration_application::table
72 .inner_join(local_user::table.on(registration_application::local_user_id.eq(local_user::id)))
73 .inner_join(person::table.on(local_user::person_id.eq(person::id)))
76 .on(registration_application::admin_id.eq(person_alias_1.field(person::id).nullable())),
78 .filter(registration_application::admin_id.is_null())
81 if verified_email_only {
82 query = query.filter(local_user::email_verified.eq(true))
86 .select(count(registration_application::id))
92 #[derive(TypedBuilder)]
93 #[builder(field_defaults(default))]
94 pub struct RegistrationApplicationQuery<'a> {
97 unread_only: Option<bool>,
98 verified_email_only: Option<bool>,
103 impl<'a> RegistrationApplicationQuery<'a> {
104 pub async fn list(self) -> Result<Vec<RegistrationApplicationView>, Error> {
105 let conn = &mut get_conn(self.pool).await?;
106 let person_alias_1 = diesel::alias!(person as person1);
108 let mut query = registration_application::table
109 .inner_join(local_user::table.on(registration_application::local_user_id.eq(local_user::id)))
110 .inner_join(person::table.on(local_user::person_id.eq(person::id)))
113 .on(registration_application::admin_id.eq(person_alias_1.field(person::id).nullable())),
115 .order_by(registration_application::published.desc())
117 registration_application::all_columns,
118 LocalUser::safe_settings_columns_tuple(),
119 Person::safe_columns_tuple(),
121 .fields(Person::safe_columns_tuple())
126 if self.unread_only.unwrap_or(false) {
127 query = query.filter(registration_application::admin_id.is_null())
130 if self.verified_email_only.unwrap_or(false) {
131 query = query.filter(local_user::email_verified.eq(true))
134 let (limit, offset) = limit_and_offset(self.page, self.limit)?;
139 .order_by(registration_application::published.desc());
141 let res = query.load::<RegistrationApplicationViewTuple>(conn).await?;
143 Ok(RegistrationApplicationView::from_tuple_to_vec(res))
147 impl ViewToVec for RegistrationApplicationView {
148 type DbTuple = RegistrationApplicationViewTuple;
149 fn from_tuple_to_vec(items: Vec<Self::DbTuple>) -> Vec<Self> {
153 registration_application: a.0,
154 creator_local_user: a.1,
158 .collect::<Vec<Self>>()
164 use crate::registration_application_view::{
165 RegistrationApplicationQuery,
166 RegistrationApplicationView,
168 use lemmy_db_schema::{
171 local_user::{LocalUser, LocalUserInsertForm, LocalUserSettings, LocalUserUpdateForm},
173 registration_application::{
174 RegistrationApplication,
175 RegistrationApplicationInsertForm,
176 RegistrationApplicationUpdateForm,
180 utils::build_db_pool_for_tests,
182 use serial_test::serial;
186 async fn test_crud() {
187 let pool = &build_db_pool_for_tests().await;
189 let inserted_instance = Instance::create(pool, "my_domain.tld").await.unwrap();
191 let timmy_person_form = PersonInsertForm::builder()
192 .name("timmy_rav".into())
194 .public_key("pubkey".to_string())
195 .instance_id(inserted_instance.id)
198 let inserted_timmy_person = Person::create(pool, &timmy_person_form).await.unwrap();
200 let timmy_local_user_form = LocalUserInsertForm::builder()
201 .person_id(inserted_timmy_person.id)
202 .password_encrypted("nada".to_string())
205 let _inserted_timmy_local_user = LocalUser::create(pool, &timmy_local_user_form)
209 let sara_person_form = PersonInsertForm::builder()
210 .name("sara_rav".into())
211 .public_key("pubkey".to_string())
212 .instance_id(inserted_instance.id)
215 let inserted_sara_person = Person::create(pool, &sara_person_form).await.unwrap();
217 let sara_local_user_form = LocalUserInsertForm::builder()
218 .person_id(inserted_sara_person.id)
219 .password_encrypted("nada".to_string())
222 let inserted_sara_local_user = LocalUser::create(pool, &sara_local_user_form)
226 // Sara creates an application
227 let sara_app_form = RegistrationApplicationInsertForm {
228 local_user_id: inserted_sara_local_user.id,
229 answer: "LET ME IIIIINN".to_string(),
232 let sara_app = RegistrationApplication::create(pool, &sara_app_form)
236 let read_sara_app_view = RegistrationApplicationView::read(pool, sara_app.id)
240 let jess_person_form = PersonInsertForm::builder()
241 .name("jess_rav".into())
242 .public_key("pubkey".to_string())
243 .instance_id(inserted_instance.id)
246 let inserted_jess_person = Person::create(pool, &jess_person_form).await.unwrap();
248 let jess_local_user_form = LocalUserInsertForm::builder()
249 .person_id(inserted_jess_person.id)
250 .password_encrypted("nada".to_string())
253 let inserted_jess_local_user = LocalUser::create(pool, &jess_local_user_form)
257 // Sara creates an application
258 let jess_app_form = RegistrationApplicationInsertForm {
259 local_user_id: inserted_jess_local_user.id,
260 answer: "LET ME IIIIINN".to_string(),
263 let jess_app = RegistrationApplication::create(pool, &jess_app_form)
267 let read_jess_app_view = RegistrationApplicationView::read(pool, jess_app.id)
271 let mut expected_sara_app_view = RegistrationApplicationView {
272 registration_application: sara_app.to_owned(),
273 creator_local_user: LocalUserSettings {
274 id: inserted_sara_local_user.id,
275 person_id: inserted_sara_local_user.person_id,
276 email: inserted_sara_local_user.email,
277 show_nsfw: inserted_sara_local_user.show_nsfw,
278 theme: inserted_sara_local_user.theme,
279 default_sort_type: inserted_sara_local_user.default_sort_type,
280 default_listing_type: inserted_sara_local_user.default_listing_type,
281 interface_language: inserted_sara_local_user.interface_language,
282 show_avatars: inserted_sara_local_user.show_avatars,
283 send_notifications_to_email: inserted_sara_local_user.send_notifications_to_email,
284 validator_time: inserted_sara_local_user.validator_time,
285 show_bot_accounts: inserted_sara_local_user.show_bot_accounts,
286 show_scores: inserted_sara_local_user.show_scores,
287 show_read_posts: inserted_sara_local_user.show_read_posts,
288 show_new_post_notifs: inserted_sara_local_user.show_new_post_notifs,
289 email_verified: inserted_sara_local_user.email_verified,
290 accepted_application: inserted_sara_local_user.accepted_application,
292 creator: PersonSafe {
293 id: inserted_sara_person.id,
294 name: inserted_sara_person.name.to_owned(),
296 published: inserted_sara_person.published,
298 actor_id: inserted_sara_person.actor_id.to_owned(),
308 inbox_url: inserted_sara_person.inbox_url.to_owned(),
309 shared_inbox_url: None,
310 matrix_user_id: None,
311 instance_id: inserted_instance.id,
316 assert_eq!(read_sara_app_view, expected_sara_app_view);
318 // Do a batch read of the applications
319 let apps = RegistrationApplicationQuery::builder()
321 .unread_only(Some(true))
330 read_jess_app_view.to_owned(),
331 expected_sara_app_view.to_owned()
335 // Make sure the counts are correct
336 let unread_count = RegistrationApplicationView::get_unread_count(pool, false)
339 assert_eq!(unread_count, 2);
341 // Approve the application
342 let approve_form = RegistrationApplicationUpdateForm {
343 admin_id: Some(Some(inserted_timmy_person.id)),
347 RegistrationApplication::update(pool, sara_app.id, &approve_form)
351 // Update the local_user row
352 let approve_local_user_form = LocalUserUpdateForm::builder()
353 .accepted_application(Some(true))
356 LocalUser::update(pool, inserted_sara_local_user.id, &approve_local_user_form)
360 let read_sara_app_view_after_approve = RegistrationApplicationView::read(pool, sara_app.id)
364 // Make sure the columns changed
365 expected_sara_app_view
367 .accepted_application = true;
368 expected_sara_app_view.registration_application.admin_id = Some(inserted_timmy_person.id);
370 expected_sara_app_view.admin = Some(PersonSafe {
371 id: inserted_timmy_person.id,
372 name: inserted_timmy_person.name.to_owned(),
374 published: inserted_timmy_person.published,
376 actor_id: inserted_timmy_person.actor_id.to_owned(),
386 inbox_url: inserted_timmy_person.inbox_url.to_owned(),
387 shared_inbox_url: None,
388 matrix_user_id: None,
389 instance_id: inserted_instance.id,
391 assert_eq!(read_sara_app_view_after_approve, expected_sara_app_view);
393 // Do a batch read of apps again
394 // It should show only jessicas which is unresolved
395 let apps_after_resolve = RegistrationApplicationQuery::builder()
397 .unread_only(Some(true))
402 assert_eq!(apps_after_resolve, vec![read_jess_app_view]);
404 // Make sure the counts are correct
405 let unread_count_after_approve = RegistrationApplicationView::get_unread_count(pool, false)
408 assert_eq!(unread_count_after_approve, 1);
410 // Make sure the not undenied_only has all the apps
411 let all_apps = RegistrationApplicationQuery::builder()
417 assert_eq!(all_apps.len(), 2);
419 Person::delete(pool, inserted_timmy_person.id)
422 Person::delete(pool, inserted_sara_person.id).await.unwrap();
423 Person::delete(pool, inserted_jess_person.id).await.unwrap();
424 Instance::delete(pool, inserted_instance.id).await.unwrap();