crates/db_views/src/registration_application_view.rs

   1 use crate::structs::RegistrationApplicationView;
   2 use diesel::{
   3   dsl::count,
   4   result::Error,
   5   ExpressionMethods,
   6   JoinOnDsl,
   7   NullableExpressionMethods,
   8   QueryDsl,
   9 };
  10 use diesel_async::RunQueryDsl;
  11 use lemmy_db_schema::{
  12   schema::{local_user, person, registration_application},
  13   source::{
  14     local_user::LocalUser,
  15     person::Person,
  16     registration_application::RegistrationApplication,
  17   },
  18   traits::JoinView,
  19   utils::{get_conn, limit_and_offset, DbPool},
  20 };
  21
  22 type RegistrationApplicationViewTuple =
  23   (RegistrationApplication, LocalUser, Person, Option<Person>);
  24
  25 impl RegistrationApplicationView {
  26   pub async fn read(
  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);
  32
  33     let (registration_application, creator_local_user, creator, admin) =
  34       registration_application::table
  35         .find(registration_application_id)
  36         .inner_join(
  37           local_user::table.on(registration_application::local_user_id.eq(local_user::id)),
  38         )
  39         .inner_join(person::table.on(local_user::person_id.eq(person::id)))
  40         .left_join(
  41           person_alias_1
  42             .on(registration_application::admin_id.eq(person_alias_1.field(person::id).nullable())),
  43         )
  44         .order_by(registration_application::published.desc())
  45         .select((
  46           registration_application::all_columns,
  47           local_user::all_columns,
  48           person::all_columns,
  49           person_alias_1.fields(person::all_columns).nullable(),
  50         ))
  51         .first::<RegistrationApplicationViewTuple>(conn)
  52         .await?;
  53
  54     Ok(RegistrationApplicationView {
  55       registration_application,
  56       creator_local_user,
  57       creator,
  58       admin,
  59     })
  60   }
  61
  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);
  69
  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)))
  73       .left_join(
  74         person_alias_1
  75           .on(registration_application::admin_id.eq(person_alias_1.field(person::id).nullable())),
  76       )
  77       .filter(registration_application::admin_id.is_null())
  78       .into_boxed();
  79
  80     if verified_email_only {
  81       query = query.filter(local_user::email_verified.eq(true))
  82     }
  83
  84     query
  85       .select(count(registration_application::id))
  86       .first::<i64>(conn)
  87       .await
  88   }
  89 }
  90
  91 #[derive(Default)]
  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>,
  97 }
  98
  99 impl RegistrationApplicationQuery {
 100   pub async fn list(
 101     self,
 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);
 106
 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)))
 110       .left_join(
 111         person_alias_1
 112           .on(registration_application::admin_id.eq(person_alias_1.field(person::id).nullable())),
 113       )
 114       .order_by(registration_application::published.desc())
 115       .select((
 116         registration_application::all_columns,
 117         local_user::all_columns,
 118         person::all_columns,
 119         person_alias_1.fields(person::all_columns).nullable(),
 120       ))
 121       .into_boxed();
 122
 123     if self.unread_only.unwrap_or(false) {
 124       query = query.filter(registration_application::admin_id.is_null())
 125     }
 126
 127     if self.verified_email_only.unwrap_or(false) {
 128       query = query.filter(local_user::email_verified.eq(true))
 129     }
 130
 131     let (limit, offset) = limit_and_offset(self.page, self.limit)?;
 132
 133     query = query
 134       .limit(limit)
 135       .offset(offset)
 136       .order_by(registration_application::published.desc());
 137
 138     let res = query.load::<RegistrationApplicationViewTuple>(conn).await?;
 139
 140     Ok(
 141       res
 142         .into_iter()
 143         .map(RegistrationApplicationView::from_tuple)
 144         .collect(),
 145     )
 146   }
 147 }
 148
 149 impl JoinView for RegistrationApplicationView {
 150   type JoinTuple = RegistrationApplicationViewTuple;
 151   fn from_tuple(a: Self::JoinTuple) -> Self {
 152     Self {
 153       registration_application: a.0,
 154       creator_local_user: a.1,
 155       creator: a.2,
 156       admin: a.3,
 157     }
 158   }
 159 }
 160
 161 #[cfg(test)]
 162 mod tests {
 163   #![allow(clippy::unwrap_used)]
 164   #![allow(clippy::indexing_slicing)]
 165
 166   use crate::registration_application_view::{
 167     RegistrationApplicationQuery,
 168     RegistrationApplicationView,
 169   };
 170   use lemmy_db_schema::{
 171     source::{
 172       instance::Instance,
 173       local_user::{LocalUser, LocalUserInsertForm, LocalUserUpdateForm},
 174       person::{Person, PersonInsertForm},
 175       registration_application::{
 176         RegistrationApplication,
 177         RegistrationApplicationInsertForm,
 178         RegistrationApplicationUpdateForm,
 179       },
 180     },
 181     traits::Crud,
 182     utils::build_db_pool_for_tests,
 183   };
 184   use serial_test::serial;
 185
 186   #[tokio::test]
 187   #[serial]
 188   async fn test_crud() {
 189     let pool = &build_db_pool_for_tests().await;
 190     let pool = &mut pool.into();
 191
 192     let inserted_instance = Instance::read_or_create(pool, "my_domain.tld".to_string())
 193       .await
 194       .unwrap();
 195
 196     let timmy_person_form = PersonInsertForm::builder()
 197       .name("timmy_rav".into())
 198       .admin(Some(true))
 199       .public_key("pubkey".to_string())
 200       .instance_id(inserted_instance.id)
 201       .build();
 202
 203     let inserted_timmy_person = Person::create(pool, &timmy_person_form).await.unwrap();
 204
 205     let timmy_local_user_form = LocalUserInsertForm::builder()
 206       .person_id(inserted_timmy_person.id)
 207       .password_encrypted("nada".to_string())
 208       .build();
 209
 210     let _inserted_timmy_local_user = LocalUser::create(pool, &timmy_local_user_form)
 211       .await
 212       .unwrap();
 213
 214     let sara_person_form = PersonInsertForm::builder()
 215       .name("sara_rav".into())
 216       .public_key("pubkey".to_string())
 217       .instance_id(inserted_instance.id)
 218       .build();
 219
 220     let inserted_sara_person = Person::create(pool, &sara_person_form).await.unwrap();
 221
 222     let sara_local_user_form = LocalUserInsertForm::builder()
 223       .person_id(inserted_sara_person.id)
 224       .password_encrypted("nada".to_string())
 225       .build();
 226
 227     let inserted_sara_local_user = LocalUser::create(pool, &sara_local_user_form)
 228       .await
 229       .unwrap();
 230
 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(),
 235     };
 236
 237     let sara_app = RegistrationApplication::create(pool, &sara_app_form)
 238       .await
 239       .unwrap();
 240
 241     let read_sara_app_view = RegistrationApplicationView::read(pool, sara_app.id)
 242       .await
 243       .unwrap();
 244
 245     let jess_person_form = PersonInsertForm::builder()
 246       .name("jess_rav".into())
 247       .public_key("pubkey".to_string())
 248       .instance_id(inserted_instance.id)
 249       .build();
 250
 251     let inserted_jess_person = Person::create(pool, &jess_person_form).await.unwrap();
 252
 253     let jess_local_user_form = LocalUserInsertForm::builder()
 254       .person_id(inserted_jess_person.id)
 255       .password_encrypted("nada".to_string())
 256       .build();
 257
 258     let inserted_jess_local_user = LocalUser::create(pool, &jess_local_user_form)
 259       .await
 260       .unwrap();
 261
 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(),
 266     };
 267
 268     let jess_app = RegistrationApplication::create(pool, &jess_app_form)
 269       .await
 270       .unwrap();
 271
 272     let read_jess_app_view = RegistrationApplicationView::read(pool, jess_app.id)
 273       .await
 274       .unwrap();
 275
 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,
 303       },
 304       creator: Person {
 305         id: inserted_sara_person.id,
 306         name: inserted_sara_person.name.clone(),
 307         display_name: None,
 308         published: inserted_sara_person.published,
 309         avatar: None,
 310         actor_id: inserted_sara_person.actor_id.clone(),
 311         local: true,
 312         banned: false,
 313         ban_expires: None,
 314         deleted: false,
 315         admin: false,
 316         bot_account: false,
 317         bio: None,
 318         banner: None,
 319         updated: None,
 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,
 327       },
 328       admin: None,
 329     };
 330
 331     assert_eq!(read_sara_app_view, expected_sara_app_view);
 332
 333     // Do a batch read of the applications
 334     let apps = RegistrationApplicationQuery {
 335       unread_only: (Some(true)),
 336       ..Default::default()
 337     }
 338     .list(pool)
 339     .await
 340     .unwrap();
 341
 342     assert_eq!(
 343       apps,
 344       [read_jess_app_view.clone(), expected_sara_app_view.clone()]
 345     );
 346
 347     // Make sure the counts are correct
 348     let unread_count = RegistrationApplicationView::get_unread_count(pool, false)
 349       .await
 350       .unwrap();
 351     assert_eq!(unread_count, 2);
 352
 353     // Approve the application
 354     let approve_form = RegistrationApplicationUpdateForm {
 355       admin_id: Some(Some(inserted_timmy_person.id)),
 356       deny_reason: None,
 357     };
 358
 359     RegistrationApplication::update(pool, sara_app.id, &approve_form)
 360       .await
 361       .unwrap();
 362
 363     // Update the local_user row
 364     let approve_local_user_form = LocalUserUpdateForm::builder()
 365       .accepted_application(Some(true))
 366       .build();
 367
 368     LocalUser::update(pool, inserted_sara_local_user.id, &approve_local_user_form)
 369       .await
 370       .unwrap();
 371
 372     let read_sara_app_view_after_approve = RegistrationApplicationView::read(pool, sara_app.id)
 373       .await
 374       .unwrap();
 375
 376     // Make sure the columns changed
 377     expected_sara_app_view
 378       .creator_local_user
 379       .accepted_application = true;
 380     expected_sara_app_view.registration_application.admin_id = Some(inserted_timmy_person.id);
 381
 382     expected_sara_app_view.admin = Some(Person {
 383       id: inserted_timmy_person.id,
 384       name: inserted_timmy_person.name.clone(),
 385       display_name: None,
 386       published: inserted_timmy_person.published,
 387       avatar: None,
 388       actor_id: inserted_timmy_person.actor_id.clone(),
 389       local: true,
 390       banned: false,
 391       ban_expires: None,
 392       deleted: false,
 393       admin: true,
 394       bot_account: false,
 395       bio: None,
 396       banner: None,
 397       updated: None,
 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,
 405     });
 406     assert_eq!(read_sara_app_view_after_approve, expected_sara_app_view);
 407
 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)),
 412       ..Default::default()
 413     }
 414     .list(pool)
 415     .await
 416     .unwrap();
 417     assert_eq!(apps_after_resolve, vec![read_jess_app_view]);
 418
 419     // Make sure the counts are correct
 420     let unread_count_after_approve = RegistrationApplicationView::get_unread_count(pool, false)
 421       .await
 422       .unwrap();
 423     assert_eq!(unread_count_after_approve, 1);
 424
 425     // Make sure the not undenied_only has all the apps
 426     let all_apps = RegistrationApplicationQuery::default()
 427       .list(pool)
 428       .await
 429       .unwrap();
 430     assert_eq!(all_apps.len(), 2);
 431
 432     Person::delete(pool, inserted_timmy_person.id)
 433       .await
 434       .unwrap();
 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();
 438   }
 439 }