crates/db_views/src/registration_application_view.rs

   1 use crate::structs::RegistrationApplicationView;
   2 use diesel::{dsl::count, result::Error, *};
   3 use lemmy_db_schema::{
   4   schema::{local_user, person, person_alias_1, registration_application},
   5   source::{
   6     local_user::{LocalUser, LocalUserSettings},
   7     person::{Person, PersonAlias1, PersonSafe, PersonSafeAlias1},
   8     registration_application::RegistrationApplication,
   9   },
  10   traits::{ToSafe, ToSafeSettings, ViewToVec},
  11   utils::limit_and_offset,
  12 };
  13 use typed_builder::TypedBuilder;
  14
  15 type RegistrationApplicationViewTuple = (
  16   RegistrationApplication,
  17   LocalUserSettings,
  18   PersonSafe,
  19   Option<PersonSafeAlias1>,
  20 );
  21
  22 impl RegistrationApplicationView {
  23   pub fn read(conn: &PgConnection, registration_application_id: i32) -> Result<Self, Error> {
  24     let (registration_application, creator_local_user, creator, admin) =
  25       registration_application::table
  26         .find(registration_application_id)
  27         .inner_join(
  28           local_user::table.on(registration_application::local_user_id.eq(local_user::id)),
  29         )
  30         .inner_join(person::table.on(local_user::person_id.eq(person::id)))
  31         .left_join(
  32           person_alias_1::table
  33             .on(registration_application::admin_id.eq(person_alias_1::id.nullable())),
  34         )
  35         .order_by(registration_application::published.desc())
  36         .select((
  37           registration_application::all_columns,
  38           LocalUser::safe_settings_columns_tuple(),
  39           Person::safe_columns_tuple(),
  40           PersonAlias1::safe_columns_tuple().nullable(),
  41         ))
  42         .first::<RegistrationApplicationViewTuple>(conn)?;
  43
  44     Ok(RegistrationApplicationView {
  45       registration_application,
  46       creator_local_user,
  47       creator,
  48       admin,
  49     })
  50   }
  51
  52   /// Returns the current unread registration_application count
  53   pub fn get_unread_count(conn: &PgConnection, verified_email_only: bool) -> Result<i64, Error> {
  54     let mut query = registration_application::table
  55       .inner_join(local_user::table.on(registration_application::local_user_id.eq(local_user::id)))
  56       .inner_join(person::table.on(local_user::person_id.eq(person::id)))
  57       .left_join(
  58         person_alias_1::table
  59           .on(registration_application::admin_id.eq(person_alias_1::id.nullable())),
  60       )
  61       .filter(registration_application::admin_id.is_null())
  62       .into_boxed();
  63
  64     if verified_email_only {
  65       query = query.filter(local_user::email_verified.eq(true))
  66     }
  67
  68     query
  69       .select(count(registration_application::id))
  70       .first::<i64>(conn)
  71   }
  72 }
  73
  74 #[derive(TypedBuilder)]
  75 #[builder(field_defaults(default))]
  76 pub struct RegistrationApplicationQuery<'a> {
  77   #[builder(!default)]
  78   conn: &'a PgConnection,
  79   unread_only: Option<bool>,
  80   verified_email_only: Option<bool>,
  81   page: Option<i64>,
  82   limit: Option<i64>,
  83 }
  84
  85 impl<'a> RegistrationApplicationQuery<'a> {
  86   pub fn list(self) -> Result<Vec<RegistrationApplicationView>, Error> {
  87     let mut query = registration_application::table
  88       .inner_join(local_user::table.on(registration_application::local_user_id.eq(local_user::id)))
  89       .inner_join(person::table.on(local_user::person_id.eq(person::id)))
  90       .left_join(
  91         person_alias_1::table
  92           .on(registration_application::admin_id.eq(person_alias_1::id.nullable())),
  93       )
  94       .order_by(registration_application::published.desc())
  95       .select((
  96         registration_application::all_columns,
  97         LocalUser::safe_settings_columns_tuple(),
  98         Person::safe_columns_tuple(),
  99         PersonAlias1::safe_columns_tuple().nullable(),
 100       ))
 101       .into_boxed();
 102
 103     if self.unread_only.unwrap_or(false) {
 104       query = query.filter(registration_application::admin_id.is_null())
 105     }
 106
 107     if self.verified_email_only.unwrap_or(false) {
 108       query = query.filter(local_user::email_verified.eq(true))
 109     }
 110
 111     let (limit, offset) = limit_and_offset(self.page, self.limit)?;
 112
 113     query = query
 114       .limit(limit)
 115       .offset(offset)
 116       .order_by(registration_application::published.desc());
 117
 118     let res = query.load::<RegistrationApplicationViewTuple>(self.conn)?;
 119
 120     Ok(RegistrationApplicationView::from_tuple_to_vec(res))
 121   }
 122 }
 123
 124 impl ViewToVec for RegistrationApplicationView {
 125   type DbTuple = RegistrationApplicationViewTuple;
 126   fn from_tuple_to_vec(items: Vec<Self::DbTuple>) -> Vec<Self> {
 127     items
 128       .into_iter()
 129       .map(|a| Self {
 130         registration_application: a.0,
 131         creator_local_user: a.1,
 132         creator: a.2,
 133         admin: a.3,
 134       })
 135       .collect::<Vec<Self>>()
 136   }
 137 }
 138
 139 #[cfg(test)]
 140 mod tests {
 141   use crate::registration_application_view::{
 142     RegistrationApplicationQuery,
 143     RegistrationApplicationView,
 144   };
 145   use lemmy_db_schema::{
 146     source::{
 147       local_user::{LocalUser, LocalUserForm, LocalUserSettings},
 148       person::*,
 149       registration_application::{RegistrationApplication, RegistrationApplicationForm},
 150     },
 151     traits::Crud,
 152     utils::establish_unpooled_connection,
 153   };
 154   use serial_test::serial;
 155
 156   #[test]
 157   #[serial]
 158   fn test_crud() {
 159     let conn = establish_unpooled_connection();
 160
 161     let timmy_person_form = PersonForm {
 162       name: "timmy_rav".into(),
 163       admin: Some(true),
 164       public_key: Some("pubkey".to_string()),
 165       ..PersonForm::default()
 166     };
 167
 168     let inserted_timmy_person = Person::create(&conn, &timmy_person_form).unwrap();
 169
 170     let timmy_local_user_form = LocalUserForm {
 171       person_id: Some(inserted_timmy_person.id),
 172       password_encrypted: Some("nada".to_string()),
 173       ..LocalUserForm::default()
 174     };
 175
 176     let _inserted_timmy_local_user = LocalUser::create(&conn, &timmy_local_user_form).unwrap();
 177
 178     let sara_person_form = PersonForm {
 179       name: "sara_rav".into(),
 180       public_key: Some("pubkey".to_string()),
 181       ..PersonForm::default()
 182     };
 183
 184     let inserted_sara_person = Person::create(&conn, &sara_person_form).unwrap();
 185
 186     let sara_local_user_form = LocalUserForm {
 187       person_id: Some(inserted_sara_person.id),
 188       password_encrypted: Some("nada".to_string()),
 189       ..LocalUserForm::default()
 190     };
 191
 192     let inserted_sara_local_user = LocalUser::create(&conn, &sara_local_user_form).unwrap();
 193
 194     // Sara creates an application
 195     let sara_app_form = RegistrationApplicationForm {
 196       local_user_id: Some(inserted_sara_local_user.id),
 197       answer: Some("LET ME IIIIINN".to_string()),
 198       ..RegistrationApplicationForm::default()
 199     };
 200
 201     let sara_app = RegistrationApplication::create(&conn, &sara_app_form).unwrap();
 202
 203     let read_sara_app_view = RegistrationApplicationView::read(&conn, sara_app.id).unwrap();
 204
 205     let jess_person_form = PersonForm {
 206       name: "jess_rav".into(),
 207       public_key: Some("pubkey".to_string()),
 208       ..PersonForm::default()
 209     };
 210
 211     let inserted_jess_person = Person::create(&conn, &jess_person_form).unwrap();
 212
 213     let jess_local_user_form = LocalUserForm {
 214       person_id: Some(inserted_jess_person.id),
 215       password_encrypted: Some("nada".to_string()),
 216       ..LocalUserForm::default()
 217     };
 218
 219     let inserted_jess_local_user = LocalUser::create(&conn, &jess_local_user_form).unwrap();
 220
 221     // Sara creates an application
 222     let jess_app_form = RegistrationApplicationForm {
 223       local_user_id: Some(inserted_jess_local_user.id),
 224       answer: Some("LET ME IIIIINN".to_string()),
 225       ..RegistrationApplicationForm::default()
 226     };
 227
 228     let jess_app = RegistrationApplication::create(&conn, &jess_app_form).unwrap();
 229
 230     let read_jess_app_view = RegistrationApplicationView::read(&conn, jess_app.id).unwrap();
 231
 232     let mut expected_sara_app_view = RegistrationApplicationView {
 233       registration_application: sara_app.to_owned(),
 234       creator_local_user: LocalUserSettings {
 235         id: inserted_sara_local_user.id,
 236         person_id: inserted_sara_local_user.person_id,
 237         email: inserted_sara_local_user.email,
 238         show_nsfw: inserted_sara_local_user.show_nsfw,
 239         theme: inserted_sara_local_user.theme,
 240         default_sort_type: inserted_sara_local_user.default_sort_type,
 241         default_listing_type: inserted_sara_local_user.default_listing_type,
 242         interface_language: inserted_sara_local_user.interface_language,
 243         show_avatars: inserted_sara_local_user.show_avatars,
 244         send_notifications_to_email: inserted_sara_local_user.send_notifications_to_email,
 245         validator_time: inserted_sara_local_user.validator_time,
 246         show_bot_accounts: inserted_sara_local_user.show_bot_accounts,
 247         show_scores: inserted_sara_local_user.show_scores,
 248         show_read_posts: inserted_sara_local_user.show_read_posts,
 249         show_new_post_notifs: inserted_sara_local_user.show_new_post_notifs,
 250         email_verified: inserted_sara_local_user.email_verified,
 251         accepted_application: inserted_sara_local_user.accepted_application,
 252       },
 253       creator: PersonSafe {
 254         id: inserted_sara_person.id,
 255         name: inserted_sara_person.name.to_owned(),
 256         display_name: None,
 257         published: inserted_sara_person.published,
 258         avatar: None,
 259         actor_id: inserted_sara_person.actor_id.to_owned(),
 260         local: true,
 261         banned: false,
 262         ban_expires: None,
 263         deleted: false,
 264         admin: false,
 265         bot_account: false,
 266         bio: None,
 267         banner: None,
 268         updated: None,
 269         inbox_url: inserted_sara_person.inbox_url.to_owned(),
 270         shared_inbox_url: None,
 271         matrix_user_id: None,
 272       },
 273       admin: None,
 274     };
 275
 276     assert_eq!(read_sara_app_view, expected_sara_app_view);
 277
 278     // Do a batch read of the applications
 279     let apps = RegistrationApplicationQuery::builder()
 280       .conn(&conn)
 281       .unread_only(Some(true))
 282       .build()
 283       .list()
 284       .unwrap();
 285
 286     assert_eq!(
 287       apps,
 288       [
 289         read_jess_app_view.to_owned(),
 290         expected_sara_app_view.to_owned()
 291       ]
 292     );
 293
 294     // Make sure the counts are correct
 295     let unread_count = RegistrationApplicationView::get_unread_count(&conn, false).unwrap();
 296     assert_eq!(unread_count, 2);
 297
 298     // Approve the application
 299     let approve_form = RegistrationApplicationForm {
 300       admin_id: Some(inserted_timmy_person.id),
 301       deny_reason: None,
 302       ..RegistrationApplicationForm::default()
 303     };
 304
 305     RegistrationApplication::update(&conn, sara_app.id, &approve_form).unwrap();
 306
 307     // Update the local_user row
 308     let approve_local_user_form = LocalUserForm {
 309       accepted_application: Some(true),
 310       ..LocalUserForm::default()
 311     };
 312
 313     LocalUser::update(&conn, inserted_sara_local_user.id, &approve_local_user_form).unwrap();
 314
 315     let read_sara_app_view_after_approve =
 316       RegistrationApplicationView::read(&conn, sara_app.id).unwrap();
 317
 318     // Make sure the columns changed
 319     expected_sara_app_view
 320       .creator_local_user
 321       .accepted_application = true;
 322     expected_sara_app_view.registration_application.admin_id = Some(inserted_timmy_person.id);
 323
 324     expected_sara_app_view.admin = Some(PersonSafeAlias1 {
 325       id: inserted_timmy_person.id,
 326       name: inserted_timmy_person.name.to_owned(),
 327       display_name: None,
 328       published: inserted_timmy_person.published,
 329       avatar: None,
 330       actor_id: inserted_timmy_person.actor_id.to_owned(),
 331       local: true,
 332       banned: false,
 333       ban_expires: None,
 334       deleted: false,
 335       admin: true,
 336       bot_account: false,
 337       bio: None,
 338       banner: None,
 339       updated: None,
 340       inbox_url: inserted_timmy_person.inbox_url.to_owned(),
 341       shared_inbox_url: None,
 342       matrix_user_id: None,
 343     });
 344     assert_eq!(read_sara_app_view_after_approve, expected_sara_app_view);
 345
 346     // Do a batch read of apps again
 347     // It should show only jessicas which is unresolved
 348     let apps_after_resolve = RegistrationApplicationQuery::builder()
 349       .conn(&conn)
 350       .unread_only(Some(true))
 351       .build()
 352       .list()
 353       .unwrap();
 354     assert_eq!(apps_after_resolve, vec![read_jess_app_view]);
 355
 356     // Make sure the counts are correct
 357     let unread_count_after_approve =
 358       RegistrationApplicationView::get_unread_count(&conn, false).unwrap();
 359     assert_eq!(unread_count_after_approve, 1);
 360
 361     // Make sure the not undenied_only has all the apps
 362     let all_apps = RegistrationApplicationQuery::builder()
 363       .conn(&conn)
 364       .build()
 365       .list()
 366       .unwrap();
 367     assert_eq!(all_apps.len(), 2);
 368
 369     Person::delete(&conn, inserted_timmy_person.id).unwrap();
 370     Person::delete(&conn, inserted_sara_person.id).unwrap();
 371     Person::delete(&conn, inserted_jess_person.id).unwrap();
 372   }
 373 }