1 use diesel::{dsl::count, result::Error, *};
4 schema::{local_user, person, person_alias_1, registration_application},
6 local_user::{LocalUser, LocalUserSettings},
7 person::{Person, PersonAlias1, PersonSafe, PersonSafeAlias1},
8 registration_application::RegistrationApplication,
10 traits::{MaybeOptional, ToSafe, ToSafeSettings, ViewToVec},
12 use serde::{Deserialize, Serialize};
14 #[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
15 pub struct RegistrationApplicationView {
16 pub registration_application: RegistrationApplication,
17 pub creator_local_user: LocalUserSettings,
18 pub creator: PersonSafe,
19 pub admin: Option<PersonSafeAlias1>,
22 type RegistrationApplicationViewTuple = (
23 RegistrationApplication,
26 Option<PersonSafeAlias1>,
29 impl RegistrationApplicationView {
30 pub fn read(conn: &PgConnection, registration_application_id: i32) -> Result<Self, Error> {
31 let (registration_application, creator_local_user, creator, admin) =
32 registration_application::table
33 .find(registration_application_id)
35 local_user::table.on(registration_application::local_user_id.eq(local_user::id)),
37 .inner_join(person::table.on(local_user::person_id.eq(person::id)))
40 .on(registration_application::admin_id.eq(person_alias_1::id.nullable())),
42 .order_by(registration_application::published.desc())
44 registration_application::all_columns,
45 LocalUser::safe_settings_columns_tuple(),
46 Person::safe_columns_tuple(),
47 PersonAlias1::safe_columns_tuple().nullable(),
49 .first::<RegistrationApplicationViewTuple>(conn)?;
51 Ok(RegistrationApplicationView {
52 registration_application,
59 /// Returns the current unread registration_application count
60 pub fn get_unread_count(conn: &PgConnection, verified_email_only: bool) -> Result<i64, Error> {
61 let mut query = registration_application::table
62 .inner_join(local_user::table.on(registration_application::local_user_id.eq(local_user::id)))
63 .inner_join(person::table.on(local_user::person_id.eq(person::id)))
66 .on(registration_application::admin_id.eq(person_alias_1::id.nullable())),
68 .filter(registration_application::admin_id.is_null())
71 if verified_email_only {
72 query = query.filter(local_user::email_verified.eq(true))
76 .select(count(registration_application::id))
81 pub struct RegistrationApplicationQueryBuilder<'a> {
82 conn: &'a PgConnection,
83 unread_only: Option<bool>,
84 verified_email_only: Option<bool>,
89 impl<'a> RegistrationApplicationQueryBuilder<'a> {
90 pub fn create(conn: &'a PgConnection) -> Self {
91 RegistrationApplicationQueryBuilder {
94 verified_email_only: None,
100 pub fn unread_only<T: MaybeOptional<bool>>(mut self, unread_only: T) -> Self {
101 self.unread_only = unread_only.get_optional();
105 pub fn verified_email_only<T: MaybeOptional<bool>>(mut self, verified_email_only: T) -> Self {
106 self.verified_email_only = verified_email_only.get_optional();
110 pub fn page<T: MaybeOptional<i64>>(mut self, page: T) -> Self {
111 self.page = page.get_optional();
115 pub fn limit<T: MaybeOptional<i64>>(mut self, limit: T) -> Self {
116 self.limit = limit.get_optional();
120 pub fn list(self) -> Result<Vec<RegistrationApplicationView>, Error> {
121 let mut query = registration_application::table
122 .inner_join(local_user::table.on(registration_application::local_user_id.eq(local_user::id)))
123 .inner_join(person::table.on(local_user::person_id.eq(person::id)))
125 person_alias_1::table
126 .on(registration_application::admin_id.eq(person_alias_1::id.nullable())),
128 .order_by(registration_application::published.desc())
130 registration_application::all_columns,
131 LocalUser::safe_settings_columns_tuple(),
132 Person::safe_columns_tuple(),
133 PersonAlias1::safe_columns_tuple().nullable(),
137 if self.unread_only.unwrap_or(false) {
138 query = query.filter(registration_application::admin_id.is_null())
141 if self.verified_email_only.unwrap_or(false) {
142 query = query.filter(local_user::email_verified.eq(true))
145 let (limit, offset) = limit_and_offset(self.page, self.limit);
150 .order_by(registration_application::published.desc());
152 let res = query.load::<RegistrationApplicationViewTuple>(self.conn)?;
154 Ok(RegistrationApplicationView::from_tuple_to_vec(res))
158 impl ViewToVec for RegistrationApplicationView {
159 type DbTuple = RegistrationApplicationViewTuple;
160 fn from_tuple_to_vec(items: Vec<Self::DbTuple>) -> Vec<Self> {
164 registration_application: a.0.to_owned(),
165 creator_local_user: a.1.to_owned(),
166 creator: a.2.to_owned(),
167 admin: a.3.to_owned(),
169 .collect::<Vec<Self>>()
175 use crate::registration_application_view::{
176 RegistrationApplicationQueryBuilder,
177 RegistrationApplicationView,
179 use lemmy_db_schema::{
180 establish_unpooled_connection,
182 local_user::{LocalUser, LocalUserForm, LocalUserSettings},
184 registration_application::{RegistrationApplication, RegistrationApplicationForm},
188 use serial_test::serial;
193 let conn = establish_unpooled_connection();
195 let timmy_person_form = PersonForm {
196 name: "timmy_rav".into(),
198 ..PersonForm::default()
201 let inserted_timmy_person = Person::create(&conn, &timmy_person_form).unwrap();
203 let timmy_local_user_form = LocalUserForm {
204 person_id: Some(inserted_timmy_person.id),
205 password_encrypted: Some("nada".to_string()),
206 ..LocalUserForm::default()
209 let _inserted_timmy_local_user = LocalUser::create(&conn, &timmy_local_user_form).unwrap();
211 let sara_person_form = PersonForm {
212 name: "sara_rav".into(),
213 ..PersonForm::default()
216 let inserted_sara_person = Person::create(&conn, &sara_person_form).unwrap();
218 let sara_local_user_form = LocalUserForm {
219 person_id: Some(inserted_sara_person.id),
220 password_encrypted: Some("nada".to_string()),
221 ..LocalUserForm::default()
224 let inserted_sara_local_user = LocalUser::create(&conn, &sara_local_user_form).unwrap();
226 // Sara creates an application
227 let sara_app_form = RegistrationApplicationForm {
228 local_user_id: Some(inserted_sara_local_user.id),
229 answer: Some("LET ME IIIIINN".to_string()),
230 ..RegistrationApplicationForm::default()
233 let sara_app = RegistrationApplication::create(&conn, &sara_app_form).unwrap();
235 let read_sara_app_view = RegistrationApplicationView::read(&conn, sara_app.id).unwrap();
237 let jess_person_form = PersonForm {
238 name: "jess_rav".into(),
239 ..PersonForm::default()
242 let inserted_jess_person = Person::create(&conn, &jess_person_form).unwrap();
244 let jess_local_user_form = LocalUserForm {
245 person_id: Some(inserted_jess_person.id),
246 password_encrypted: Some("nada".to_string()),
247 ..LocalUserForm::default()
250 let inserted_jess_local_user = LocalUser::create(&conn, &jess_local_user_form).unwrap();
252 // Sara creates an application
253 let jess_app_form = RegistrationApplicationForm {
254 local_user_id: Some(inserted_jess_local_user.id),
255 answer: Some("LET ME IIIIINN".to_string()),
256 ..RegistrationApplicationForm::default()
259 let jess_app = RegistrationApplication::create(&conn, &jess_app_form).unwrap();
261 let read_jess_app_view = RegistrationApplicationView::read(&conn, jess_app.id).unwrap();
263 let mut expected_sara_app_view = RegistrationApplicationView {
264 registration_application: sara_app.to_owned(),
265 creator_local_user: LocalUserSettings {
266 id: inserted_sara_local_user.id,
267 person_id: inserted_sara_local_user.person_id,
268 email: inserted_sara_local_user.email,
269 show_nsfw: inserted_sara_local_user.show_nsfw,
270 theme: inserted_sara_local_user.theme,
271 default_sort_type: inserted_sara_local_user.default_sort_type,
272 default_listing_type: inserted_sara_local_user.default_listing_type,
273 lang: inserted_sara_local_user.lang,
274 show_avatars: inserted_sara_local_user.show_avatars,
275 send_notifications_to_email: inserted_sara_local_user.send_notifications_to_email,
276 validator_time: inserted_sara_local_user.validator_time,
277 show_bot_accounts: inserted_sara_local_user.show_bot_accounts,
278 show_scores: inserted_sara_local_user.show_scores,
279 show_read_posts: inserted_sara_local_user.show_read_posts,
280 show_new_post_notifs: inserted_sara_local_user.show_new_post_notifs,
281 email_verified: inserted_sara_local_user.email_verified,
282 accepted_application: inserted_sara_local_user.accepted_application,
284 creator: PersonSafe {
285 id: inserted_sara_person.id,
286 name: inserted_sara_person.name.to_owned(),
288 published: inserted_sara_person.published,
290 actor_id: inserted_sara_person.actor_id.to_owned(),
300 inbox_url: inserted_sara_person.inbox_url.to_owned(),
301 shared_inbox_url: None,
302 matrix_user_id: None,
307 assert_eq!(read_sara_app_view, expected_sara_app_view);
309 // Do a batch read of the applications
310 let apps = RegistrationApplicationQueryBuilder::create(&conn)
318 read_jess_app_view.to_owned(),
319 expected_sara_app_view.to_owned()
323 // Make sure the counts are correct
324 let unread_count = RegistrationApplicationView::get_unread_count(&conn, false).unwrap();
325 assert_eq!(unread_count, 2);
327 // Approve the application
328 let approve_form = RegistrationApplicationForm {
329 admin_id: Some(inserted_timmy_person.id),
331 ..RegistrationApplicationForm::default()
334 RegistrationApplication::update(&conn, sara_app.id, &approve_form).unwrap();
336 // Update the local_user row
337 let approve_local_user_form = LocalUserForm {
338 accepted_application: Some(true),
339 ..LocalUserForm::default()
342 LocalUser::update(&conn, inserted_sara_local_user.id, &approve_local_user_form).unwrap();
344 let read_sara_app_view_after_approve =
345 RegistrationApplicationView::read(&conn, sara_app.id).unwrap();
347 // Make sure the columns changed
348 expected_sara_app_view
350 .accepted_application = true;
351 expected_sara_app_view.registration_application.admin_id = Some(inserted_timmy_person.id);
353 expected_sara_app_view.admin = Some(PersonSafeAlias1 {
354 id: inserted_timmy_person.id,
355 name: inserted_timmy_person.name.to_owned(),
357 published: inserted_timmy_person.published,
359 actor_id: inserted_timmy_person.actor_id.to_owned(),
369 inbox_url: inserted_timmy_person.inbox_url.to_owned(),
370 shared_inbox_url: None,
371 matrix_user_id: None,
373 assert_eq!(read_sara_app_view_after_approve, expected_sara_app_view);
375 // Do a batch read of apps again
376 // It should show only jessicas which is unresolved
377 let apps_after_resolve = RegistrationApplicationQueryBuilder::create(&conn)
381 assert_eq!(apps_after_resolve, vec![read_jess_app_view]);
383 // Make sure the counts are correct
384 let unread_count_after_approve =
385 RegistrationApplicationView::get_unread_count(&conn, false).unwrap();
386 assert_eq!(unread_count_after_approve, 1);
388 // Make sure the not undenied_only has all the apps
389 let all_apps = RegistrationApplicationQueryBuilder::create(&conn)
392 assert_eq!(all_apps.len(), 2);
394 Person::delete(&conn, inserted_timmy_person.id).unwrap();
395 Person::delete(&conn, inserted_sara_person.id).unwrap();
396 Person::delete(&conn, inserted_jess_person.id).unwrap();