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       ..PersonForm::default()
 191     };
 192
 193     let inserted_timmy_person = Person::create(&conn, &timmy_person_form).unwrap();
 194
 195     let timmy_local_user_form = LocalUserForm {
 196       person_id: Some(inserted_timmy_person.id),
 197       password_encrypted: Some("nada".to_string()),
 198       ..LocalUserForm::default()
 199     };
 200
 201     let _inserted_timmy_local_user = LocalUser::create(&conn, &timmy_local_user_form).unwrap();
 202
 203     let sara_person_form = PersonForm {
 204       name: "sara_rav".into(),
 205       ..PersonForm::default()
 206     };
 207
 208     let inserted_sara_person = Person::create(&conn, &sara_person_form).unwrap();
 209
 210     let sara_local_user_form = LocalUserForm {
 211       person_id: Some(inserted_sara_person.id),
 212       password_encrypted: Some("nada".to_string()),
 213       ..LocalUserForm::default()
 214     };
 215
 216     let inserted_sara_local_user = LocalUser::create(&conn, &sara_local_user_form).unwrap();
 217
 218     // Sara creates an application
 219     let sara_app_form = RegistrationApplicationForm {
 220       local_user_id: Some(inserted_sara_local_user.id),
 221       answer: Some("LET ME IIIIINN".to_string()),
 222       ..RegistrationApplicationForm::default()
 223     };
 224
 225     let sara_app = RegistrationApplication::create(&conn, &sara_app_form).unwrap();
 226
 227     let read_sara_app_view = RegistrationApplicationView::read(&conn, sara_app.id).unwrap();
 228
 229     let jess_person_form = PersonForm {
 230       name: "jess_rav".into(),
 231       ..PersonForm::default()
 232     };
 233
 234     let inserted_jess_person = Person::create(&conn, &jess_person_form).unwrap();
 235
 236     let jess_local_user_form = LocalUserForm {
 237       person_id: Some(inserted_jess_person.id),
 238       password_encrypted: Some("nada".to_string()),
 239       ..LocalUserForm::default()
 240     };
 241
 242     let inserted_jess_local_user = LocalUser::create(&conn, &jess_local_user_form).unwrap();
 243
 244     // Sara creates an application
 245     let jess_app_form = RegistrationApplicationForm {
 246       local_user_id: Some(inserted_jess_local_user.id),
 247       answer: Some("LET ME IIIIINN".to_string()),
 248       ..RegistrationApplicationForm::default()
 249     };
 250
 251     let jess_app = RegistrationApplication::create(&conn, &jess_app_form).unwrap();
 252
 253     let read_jess_app_view = RegistrationApplicationView::read(&conn, jess_app.id).unwrap();
 254
 255     let mut expected_sara_app_view = RegistrationApplicationView {
 256       registration_application: sara_app.to_owned(),
 257       creator_local_user: LocalUserSettings {
 258         id: inserted_sara_local_user.id,
 259         person_id: inserted_sara_local_user.person_id,
 260         email: inserted_sara_local_user.email,
 261         show_nsfw: inserted_sara_local_user.show_nsfw,
 262         theme: inserted_sara_local_user.theme,
 263         default_sort_type: inserted_sara_local_user.default_sort_type,
 264         default_listing_type: inserted_sara_local_user.default_listing_type,
 265         lang: inserted_sara_local_user.lang,
 266         show_avatars: inserted_sara_local_user.show_avatars,
 267         send_notifications_to_email: inserted_sara_local_user.send_notifications_to_email,
 268         validator_time: inserted_sara_local_user.validator_time,
 269         show_bot_accounts: inserted_sara_local_user.show_bot_accounts,
 270         show_scores: inserted_sara_local_user.show_scores,
 271         show_read_posts: inserted_sara_local_user.show_read_posts,
 272         show_new_post_notifs: inserted_sara_local_user.show_new_post_notifs,
 273         email_verified: inserted_sara_local_user.email_verified,
 274         accepted_application: inserted_sara_local_user.accepted_application,
 275       },
 276       creator: PersonSafe {
 277         id: inserted_sara_person.id,
 278         name: inserted_sara_person.name.to_owned(),
 279         display_name: None,
 280         published: inserted_sara_person.published,
 281         avatar: None,
 282         actor_id: inserted_sara_person.actor_id.to_owned(),
 283         local: true,
 284         banned: false,
 285         ban_expires: None,
 286         deleted: false,
 287         admin: false,
 288         bot_account: false,
 289         bio: None,
 290         banner: None,
 291         updated: None,
 292         inbox_url: inserted_sara_person.inbox_url.to_owned(),
 293         shared_inbox_url: None,
 294         matrix_user_id: None,
 295       },
 296       admin: None,
 297     };
 298
 299     assert_eq!(read_sara_app_view, expected_sara_app_view);
 300
 301     // Do a batch read of the applications
 302     let apps = RegistrationApplicationQueryBuilder::create(&conn)
 303       .unread_only(true)
 304       .list()
 305       .unwrap();
 306
 307     assert_eq!(
 308       apps,
 309       [
 310         read_jess_app_view.to_owned(),
 311         expected_sara_app_view.to_owned()
 312       ]
 313     );
 314
 315     // Make sure the counts are correct
 316     let unread_count = RegistrationApplicationView::get_unread_count(&conn, false).unwrap();
 317     assert_eq!(unread_count, 2);
 318
 319     // Approve the application
 320     let approve_form = RegistrationApplicationForm {
 321       admin_id: Some(inserted_timmy_person.id),
 322       deny_reason: None,
 323       ..RegistrationApplicationForm::default()
 324     };
 325
 326     RegistrationApplication::update(&conn, sara_app.id, &approve_form).unwrap();
 327
 328     // Update the local_user row
 329     let approve_local_user_form = LocalUserForm {
 330       accepted_application: Some(true),
 331       ..LocalUserForm::default()
 332     };
 333
 334     LocalUser::update(&conn, inserted_sara_local_user.id, &approve_local_user_form).unwrap();
 335
 336     let read_sara_app_view_after_approve =
 337       RegistrationApplicationView::read(&conn, sara_app.id).unwrap();
 338
 339     // Make sure the columns changed
 340     expected_sara_app_view
 341       .creator_local_user
 342       .accepted_application = true;
 343     expected_sara_app_view.registration_application.admin_id = Some(inserted_timmy_person.id);
 344
 345     expected_sara_app_view.admin = Some(PersonSafeAlias1 {
 346       id: inserted_timmy_person.id,
 347       name: inserted_timmy_person.name.to_owned(),
 348       display_name: None,
 349       published: inserted_timmy_person.published,
 350       avatar: None,
 351       actor_id: inserted_timmy_person.actor_id.to_owned(),
 352       local: true,
 353       banned: false,
 354       ban_expires: None,
 355       deleted: false,
 356       admin: true,
 357       bot_account: false,
 358       bio: None,
 359       banner: None,
 360       updated: None,
 361       inbox_url: inserted_timmy_person.inbox_url.to_owned(),
 362       shared_inbox_url: None,
 363       matrix_user_id: None,
 364     });
 365     assert_eq!(read_sara_app_view_after_approve, expected_sara_app_view);
 366
 367     // Do a batch read of apps again
 368     // It should show only jessicas which is unresolved
 369     let apps_after_resolve = RegistrationApplicationQueryBuilder::create(&conn)
 370       .unread_only(true)
 371       .list()
 372       .unwrap();
 373     assert_eq!(apps_after_resolve, vec![read_jess_app_view]);
 374
 375     // Make sure the counts are correct
 376     let unread_count_after_approve =
 377       RegistrationApplicationView::get_unread_count(&conn, false).unwrap();
 378     assert_eq!(unread_count_after_approve, 1);
 379
 380     // Make sure the not undenied_only has all the apps
 381     let all_apps = RegistrationApplicationQueryBuilder::create(&conn)
 382       .list()
 383       .unwrap();
 384     assert_eq!(all_apps.len(), 2);
 385
 386     Person::delete(&conn, inserted_timmy_person.id).unwrap();
 387     Person::delete(&conn, inserted_sara_person.id).unwrap();
 388     Person::delete(&conn, inserted_jess_person.id).unwrap();
 389   }
 390 }