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