1 use crate::structs::RegistrationApplicationView;
2 use diesel::{dsl::count, result::Error, *};
4 schema::{local_user, person, registration_application},
6 local_user::{LocalUser, LocalUserSettings},
7 person::{Person, PersonSafe},
8 registration_application::RegistrationApplication,
10 traits::{ToSafe, ToSafeSettings, ViewToVec},
11 utils::limit_and_offset,
13 use typed_builder::TypedBuilder;
15 type RegistrationApplicationViewTuple = (
16 RegistrationApplication,
22 impl RegistrationApplicationView {
23 pub fn read(conn: &mut PgConnection, registration_application_id: i32) -> Result<Self, Error> {
24 let person_alias_1 = diesel::alias!(person as person1);
26 let (registration_application, creator_local_user, creator, admin) =
27 registration_application::table
28 .find(registration_application_id)
30 local_user::table.on(registration_application::local_user_id.eq(local_user::id)),
32 .inner_join(person::table.on(local_user::person_id.eq(person::id)))
35 .on(registration_application::admin_id.eq(person_alias_1.field(person::id).nullable())),
37 .order_by(registration_application::published.desc())
39 registration_application::all_columns,
40 LocalUser::safe_settings_columns_tuple(),
41 Person::safe_columns_tuple(),
43 .fields(Person::safe_columns_tuple())
46 .first::<RegistrationApplicationViewTuple>(conn)?;
48 Ok(RegistrationApplicationView {
49 registration_application,
56 /// Returns the current unread registration_application count
57 pub fn get_unread_count(
58 conn: &mut PgConnection,
59 verified_email_only: bool,
60 ) -> Result<i64, Error> {
61 let person_alias_1 = diesel::alias!(person as person1);
63 let mut query = registration_application::table
64 .inner_join(local_user::table.on(registration_application::local_user_id.eq(local_user::id)))
65 .inner_join(person::table.on(local_user::person_id.eq(person::id)))
68 .on(registration_application::admin_id.eq(person_alias_1.field(person::id).nullable())),
70 .filter(registration_application::admin_id.is_null())
73 if verified_email_only {
74 query = query.filter(local_user::email_verified.eq(true))
78 .select(count(registration_application::id))
83 #[derive(TypedBuilder)]
84 #[builder(field_defaults(default))]
85 pub struct RegistrationApplicationQuery<'a> {
87 conn: &'a mut PgConnection,
88 unread_only: Option<bool>,
89 verified_email_only: Option<bool>,
94 impl<'a> RegistrationApplicationQuery<'a> {
95 pub fn list(self) -> Result<Vec<RegistrationApplicationView>, Error> {
96 let person_alias_1 = diesel::alias!(person as person1);
98 let mut query = registration_application::table
99 .inner_join(local_user::table.on(registration_application::local_user_id.eq(local_user::id)))
100 .inner_join(person::table.on(local_user::person_id.eq(person::id)))
103 .on(registration_application::admin_id.eq(person_alias_1.field(person::id).nullable())),
105 .order_by(registration_application::published.desc())
107 registration_application::all_columns,
108 LocalUser::safe_settings_columns_tuple(),
109 Person::safe_columns_tuple(),
111 .fields(Person::safe_columns_tuple())
116 if self.unread_only.unwrap_or(false) {
117 query = query.filter(registration_application::admin_id.is_null())
120 if self.verified_email_only.unwrap_or(false) {
121 query = query.filter(local_user::email_verified.eq(true))
124 let (limit, offset) = limit_and_offset(self.page, self.limit)?;
129 .order_by(registration_application::published.desc());
131 let res = query.load::<RegistrationApplicationViewTuple>(self.conn)?;
133 Ok(RegistrationApplicationView::from_tuple_to_vec(res))
137 impl ViewToVec for RegistrationApplicationView {
138 type DbTuple = RegistrationApplicationViewTuple;
139 fn from_tuple_to_vec(items: Vec<Self::DbTuple>) -> Vec<Self> {
143 registration_application: a.0,
144 creator_local_user: a.1,
148 .collect::<Vec<Self>>()
154 use crate::registration_application_view::{
155 RegistrationApplicationQuery,
156 RegistrationApplicationView,
158 use lemmy_db_schema::{
160 local_user::{LocalUser, LocalUserForm, LocalUserSettings},
162 registration_application::{RegistrationApplication, RegistrationApplicationForm},
165 utils::establish_unpooled_connection,
167 use serial_test::serial;
172 let conn = &mut establish_unpooled_connection();
174 let timmy_person_form = PersonForm {
175 name: "timmy_rav".into(),
177 public_key: Some("pubkey".to_string()),
178 ..PersonForm::default()
181 let inserted_timmy_person = Person::create(conn, &timmy_person_form).unwrap();
183 let timmy_local_user_form = LocalUserForm {
184 person_id: Some(inserted_timmy_person.id),
185 password_encrypted: Some("nada".to_string()),
186 ..LocalUserForm::default()
189 let _inserted_timmy_local_user = LocalUser::create(conn, &timmy_local_user_form).unwrap();
191 let sara_person_form = PersonForm {
192 name: "sara_rav".into(),
193 public_key: Some("pubkey".to_string()),
194 ..PersonForm::default()
197 let inserted_sara_person = Person::create(conn, &sara_person_form).unwrap();
199 let sara_local_user_form = LocalUserForm {
200 person_id: Some(inserted_sara_person.id),
201 password_encrypted: Some("nada".to_string()),
202 ..LocalUserForm::default()
205 let inserted_sara_local_user = LocalUser::create(conn, &sara_local_user_form).unwrap();
207 // Sara creates an application
208 let sara_app_form = RegistrationApplicationForm {
209 local_user_id: Some(inserted_sara_local_user.id),
210 answer: Some("LET ME IIIIINN".to_string()),
211 ..RegistrationApplicationForm::default()
214 let sara_app = RegistrationApplication::create(conn, &sara_app_form).unwrap();
216 let read_sara_app_view = RegistrationApplicationView::read(conn, sara_app.id).unwrap();
218 let jess_person_form = PersonForm {
219 name: "jess_rav".into(),
220 public_key: Some("pubkey".to_string()),
221 ..PersonForm::default()
224 let inserted_jess_person = Person::create(conn, &jess_person_form).unwrap();
226 let jess_local_user_form = LocalUserForm {
227 person_id: Some(inserted_jess_person.id),
228 password_encrypted: Some("nada".to_string()),
229 ..LocalUserForm::default()
232 let inserted_jess_local_user = LocalUser::create(conn, &jess_local_user_form).unwrap();
234 // Sara creates an application
235 let jess_app_form = RegistrationApplicationForm {
236 local_user_id: Some(inserted_jess_local_user.id),
237 answer: Some("LET ME IIIIINN".to_string()),
238 ..RegistrationApplicationForm::default()
241 let jess_app = RegistrationApplication::create(conn, &jess_app_form).unwrap();
243 let read_jess_app_view = RegistrationApplicationView::read(conn, jess_app.id).unwrap();
245 let mut expected_sara_app_view = RegistrationApplicationView {
246 registration_application: sara_app.to_owned(),
247 creator_local_user: LocalUserSettings {
248 id: inserted_sara_local_user.id,
249 person_id: inserted_sara_local_user.person_id,
250 email: inserted_sara_local_user.email,
251 show_nsfw: inserted_sara_local_user.show_nsfw,
252 theme: inserted_sara_local_user.theme,
253 default_sort_type: inserted_sara_local_user.default_sort_type,
254 default_listing_type: inserted_sara_local_user.default_listing_type,
255 interface_language: inserted_sara_local_user.interface_language,
256 show_avatars: inserted_sara_local_user.show_avatars,
257 send_notifications_to_email: inserted_sara_local_user.send_notifications_to_email,
258 validator_time: inserted_sara_local_user.validator_time,
259 show_bot_accounts: inserted_sara_local_user.show_bot_accounts,
260 show_scores: inserted_sara_local_user.show_scores,
261 show_read_posts: inserted_sara_local_user.show_read_posts,
262 show_new_post_notifs: inserted_sara_local_user.show_new_post_notifs,
263 email_verified: inserted_sara_local_user.email_verified,
264 accepted_application: inserted_sara_local_user.accepted_application,
266 creator: PersonSafe {
267 id: inserted_sara_person.id,
268 name: inserted_sara_person.name.to_owned(),
270 published: inserted_sara_person.published,
272 actor_id: inserted_sara_person.actor_id.to_owned(),
282 inbox_url: inserted_sara_person.inbox_url.to_owned(),
283 shared_inbox_url: None,
284 matrix_user_id: None,
289 assert_eq!(read_sara_app_view, expected_sara_app_view);
291 // Do a batch read of the applications
292 let apps = RegistrationApplicationQuery::builder()
294 .unread_only(Some(true))
302 read_jess_app_view.to_owned(),
303 expected_sara_app_view.to_owned()
307 // Make sure the counts are correct
308 let unread_count = RegistrationApplicationView::get_unread_count(conn, false).unwrap();
309 assert_eq!(unread_count, 2);
311 // Approve the application
312 let approve_form = RegistrationApplicationForm {
313 admin_id: Some(inserted_timmy_person.id),
315 ..RegistrationApplicationForm::default()
318 RegistrationApplication::update(conn, sara_app.id, &approve_form).unwrap();
320 // Update the local_user row
321 let approve_local_user_form = LocalUserForm {
322 accepted_application: Some(true),
323 ..LocalUserForm::default()
326 LocalUser::update(conn, inserted_sara_local_user.id, &approve_local_user_form).unwrap();
328 let read_sara_app_view_after_approve =
329 RegistrationApplicationView::read(conn, sara_app.id).unwrap();
331 // Make sure the columns changed
332 expected_sara_app_view
334 .accepted_application = true;
335 expected_sara_app_view.registration_application.admin_id = Some(inserted_timmy_person.id);
337 expected_sara_app_view.admin = Some(PersonSafe {
338 id: inserted_timmy_person.id,
339 name: inserted_timmy_person.name.to_owned(),
341 published: inserted_timmy_person.published,
343 actor_id: inserted_timmy_person.actor_id.to_owned(),
353 inbox_url: inserted_timmy_person.inbox_url.to_owned(),
354 shared_inbox_url: None,
355 matrix_user_id: None,
357 assert_eq!(read_sara_app_view_after_approve, expected_sara_app_view);
359 // Do a batch read of apps again
360 // It should show only jessicas which is unresolved
361 let apps_after_resolve = RegistrationApplicationQuery::builder()
363 .unread_only(Some(true))
367 assert_eq!(apps_after_resolve, vec![read_jess_app_view]);
369 // Make sure the counts are correct
370 let unread_count_after_approve =
371 RegistrationApplicationView::get_unread_count(conn, false).unwrap();
372 assert_eq!(unread_count_after_approve, 1);
374 // Make sure the not undenied_only has all the apps
375 let all_apps = RegistrationApplicationQuery::builder()
380 assert_eq!(all_apps.len(), 2);
382 Person::delete(conn, inserted_timmy_person.id).unwrap();
383 Person::delete(conn, inserted_sara_person.id).unwrap();
384 Person::delete(conn, inserted_jess_person.id).unwrap();