1 use crate::structs::RegistrationApplicationView;
7 NullableExpressionMethods,
10 use diesel_async::RunQueryDsl;
11 use lemmy_db_schema::{
12 schema::{local_user, person, registration_application},
14 local_user::LocalUser,
16 registration_application::RegistrationApplication,
19 utils::{get_conn, limit_and_offset, DbPool},
21 use typed_builder::TypedBuilder;
23 type RegistrationApplicationViewTuple =
24 (RegistrationApplication, LocalUser, Person, Option<Person>);
26 impl RegistrationApplicationView {
27 pub async fn read(pool: &DbPool, registration_application_id: i32) -> Result<Self, Error> {
28 let conn = &mut get_conn(pool).await?;
29 let person_alias_1 = diesel::alias!(person as person1);
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.field(person::id).nullable())),
42 .order_by(registration_application::published.desc())
44 registration_application::all_columns,
45 local_user::all_columns,
47 person_alias_1.fields(person::all_columns).nullable(),
49 .first::<RegistrationApplicationViewTuple>(conn)
52 Ok(RegistrationApplicationView {
53 registration_application,
60 /// Returns the current unread registration_application count
61 pub async fn get_unread_count(pool: &DbPool, verified_email_only: bool) -> Result<i64, Error> {
62 let conn = &mut get_conn(pool).await?;
63 let person_alias_1 = diesel::alias!(person as person1);
65 let mut query = registration_application::table
66 .inner_join(local_user::table.on(registration_application::local_user_id.eq(local_user::id)))
67 .inner_join(person::table.on(local_user::person_id.eq(person::id)))
70 .on(registration_application::admin_id.eq(person_alias_1.field(person::id).nullable())),
72 .filter(registration_application::admin_id.is_null())
75 if verified_email_only {
76 query = query.filter(local_user::email_verified.eq(true))
80 .select(count(registration_application::id))
86 #[derive(TypedBuilder)]
87 #[builder(field_defaults(default))]
88 pub struct RegistrationApplicationQuery<'a> {
91 unread_only: Option<bool>,
92 verified_email_only: Option<bool>,
97 impl<'a> RegistrationApplicationQuery<'a> {
98 pub async fn list(self) -> Result<Vec<RegistrationApplicationView>, Error> {
99 let conn = &mut get_conn(self.pool).await?;
100 let person_alias_1 = diesel::alias!(person as person1);
102 let mut query = registration_application::table
103 .inner_join(local_user::table.on(registration_application::local_user_id.eq(local_user::id)))
104 .inner_join(person::table.on(local_user::person_id.eq(person::id)))
107 .on(registration_application::admin_id.eq(person_alias_1.field(person::id).nullable())),
109 .order_by(registration_application::published.desc())
111 registration_application::all_columns,
112 local_user::all_columns,
114 person_alias_1.fields(person::all_columns).nullable(),
118 if self.unread_only.unwrap_or(false) {
119 query = query.filter(registration_application::admin_id.is_null())
122 if self.verified_email_only.unwrap_or(false) {
123 query = query.filter(local_user::email_verified.eq(true))
126 let (limit, offset) = limit_and_offset(self.page, self.limit)?;
131 .order_by(registration_application::published.desc());
133 let res = query.load::<RegistrationApplicationViewTuple>(conn).await?;
138 .map(RegistrationApplicationView::from_tuple)
144 impl JoinView for RegistrationApplicationView {
145 type JoinTuple = RegistrationApplicationViewTuple;
146 fn from_tuple(a: Self::JoinTuple) -> Self {
148 registration_application: a.0,
149 creator_local_user: a.1,
158 use crate::registration_application_view::{
159 RegistrationApplicationQuery,
160 RegistrationApplicationView,
162 use lemmy_db_schema::{
165 local_user::{LocalUser, LocalUserInsertForm, LocalUserUpdateForm},
166 person::{Person, PersonInsertForm},
167 registration_application::{
168 RegistrationApplication,
169 RegistrationApplicationInsertForm,
170 RegistrationApplicationUpdateForm,
174 utils::build_db_pool_for_tests,
176 use serial_test::serial;
180 async fn test_crud() {
181 let pool = &build_db_pool_for_tests().await;
183 let inserted_instance = Instance::read_or_create(pool, "my_domain.tld".to_string())
187 let timmy_person_form = PersonInsertForm::builder()
188 .name("timmy_rav".into())
190 .public_key("pubkey".to_string())
191 .instance_id(inserted_instance.id)
194 let inserted_timmy_person = Person::create(pool, &timmy_person_form).await.unwrap();
196 let timmy_local_user_form = LocalUserInsertForm::builder()
197 .person_id(inserted_timmy_person.id)
198 .password_encrypted("nada".to_string())
201 let _inserted_timmy_local_user = LocalUser::create(pool, &timmy_local_user_form)
205 let sara_person_form = PersonInsertForm::builder()
206 .name("sara_rav".into())
207 .public_key("pubkey".to_string())
208 .instance_id(inserted_instance.id)
211 let inserted_sara_person = Person::create(pool, &sara_person_form).await.unwrap();
213 let sara_local_user_form = LocalUserInsertForm::builder()
214 .person_id(inserted_sara_person.id)
215 .password_encrypted("nada".to_string())
218 let inserted_sara_local_user = LocalUser::create(pool, &sara_local_user_form)
222 // Sara creates an application
223 let sara_app_form = RegistrationApplicationInsertForm {
224 local_user_id: inserted_sara_local_user.id,
225 answer: "LET ME IIIIINN".to_string(),
228 let sara_app = RegistrationApplication::create(pool, &sara_app_form)
232 let read_sara_app_view = RegistrationApplicationView::read(pool, sara_app.id)
236 let jess_person_form = PersonInsertForm::builder()
237 .name("jess_rav".into())
238 .public_key("pubkey".to_string())
239 .instance_id(inserted_instance.id)
242 let inserted_jess_person = Person::create(pool, &jess_person_form).await.unwrap();
244 let jess_local_user_form = LocalUserInsertForm::builder()
245 .person_id(inserted_jess_person.id)
246 .password_encrypted("nada".to_string())
249 let inserted_jess_local_user = LocalUser::create(pool, &jess_local_user_form)
253 // Sara creates an application
254 let jess_app_form = RegistrationApplicationInsertForm {
255 local_user_id: inserted_jess_local_user.id,
256 answer: "LET ME IIIIINN".to_string(),
259 let jess_app = RegistrationApplication::create(pool, &jess_app_form)
263 let read_jess_app_view = RegistrationApplicationView::read(pool, jess_app.id)
267 let mut expected_sara_app_view = RegistrationApplicationView {
268 registration_application: sara_app.clone(),
269 creator_local_user: LocalUser {
270 id: inserted_sara_local_user.id,
271 person_id: inserted_sara_local_user.person_id,
272 email: inserted_sara_local_user.email,
273 show_nsfw: inserted_sara_local_user.show_nsfw,
274 theme: inserted_sara_local_user.theme,
275 default_sort_type: inserted_sara_local_user.default_sort_type,
276 default_listing_type: inserted_sara_local_user.default_listing_type,
277 interface_language: inserted_sara_local_user.interface_language,
278 show_avatars: inserted_sara_local_user.show_avatars,
279 send_notifications_to_email: inserted_sara_local_user.send_notifications_to_email,
280 validator_time: inserted_sara_local_user.validator_time,
281 show_bot_accounts: inserted_sara_local_user.show_bot_accounts,
282 show_scores: inserted_sara_local_user.show_scores,
283 show_read_posts: inserted_sara_local_user.show_read_posts,
284 show_new_post_notifs: inserted_sara_local_user.show_new_post_notifs,
285 email_verified: inserted_sara_local_user.email_verified,
286 accepted_application: inserted_sara_local_user.accepted_application,
287 password_encrypted: inserted_sara_local_user.password_encrypted,
290 id: inserted_sara_person.id,
291 name: inserted_sara_person.name.clone(),
293 published: inserted_sara_person.published,
295 actor_id: inserted_sara_person.actor_id.clone(),
305 inbox_url: inserted_sara_person.inbox_url.clone(),
306 shared_inbox_url: None,
307 matrix_user_id: None,
308 instance_id: inserted_instance.id,
309 private_key: inserted_sara_person.private_key,
310 public_key: inserted_sara_person.public_key,
311 last_refreshed_at: inserted_sara_person.last_refreshed_at,
316 assert_eq!(read_sara_app_view, expected_sara_app_view);
318 // Do a batch read of the applications
319 let apps = RegistrationApplicationQuery::builder()
321 .unread_only(Some(true))
329 [read_jess_app_view.clone(), expected_sara_app_view.clone()]
332 // Make sure the counts are correct
333 let unread_count = RegistrationApplicationView::get_unread_count(pool, false)
336 assert_eq!(unread_count, 2);
338 // Approve the application
339 let approve_form = RegistrationApplicationUpdateForm {
340 admin_id: Some(Some(inserted_timmy_person.id)),
344 RegistrationApplication::update(pool, sara_app.id, &approve_form)
348 // Update the local_user row
349 let approve_local_user_form = LocalUserUpdateForm::builder()
350 .accepted_application(Some(true))
353 LocalUser::update(pool, inserted_sara_local_user.id, &approve_local_user_form)
357 let read_sara_app_view_after_approve = RegistrationApplicationView::read(pool, sara_app.id)
361 // Make sure the columns changed
362 expected_sara_app_view
364 .accepted_application = true;
365 expected_sara_app_view.registration_application.admin_id = Some(inserted_timmy_person.id);
367 expected_sara_app_view.admin = Some(Person {
368 id: inserted_timmy_person.id,
369 name: inserted_timmy_person.name.clone(),
371 published: inserted_timmy_person.published,
373 actor_id: inserted_timmy_person.actor_id.clone(),
383 inbox_url: inserted_timmy_person.inbox_url.clone(),
384 shared_inbox_url: None,
385 matrix_user_id: None,
386 instance_id: inserted_instance.id,
387 private_key: inserted_timmy_person.private_key,
388 public_key: inserted_timmy_person.public_key,
389 last_refreshed_at: inserted_timmy_person.last_refreshed_at,
391 assert_eq!(read_sara_app_view_after_approve, expected_sara_app_view);
393 // Do a batch read of apps again
394 // It should show only jessicas which is unresolved
395 let apps_after_resolve = RegistrationApplicationQuery::builder()
397 .unread_only(Some(true))
402 assert_eq!(apps_after_resolve, vec![read_jess_app_view]);
404 // Make sure the counts are correct
405 let unread_count_after_approve = RegistrationApplicationView::get_unread_count(pool, false)
408 assert_eq!(unread_count_after_approve, 1);
410 // Make sure the not undenied_only has all the apps
411 let all_apps = RegistrationApplicationQuery::builder()
417 assert_eq!(all_apps.len(), 2);
419 Person::delete(pool, inserted_timmy_person.id)
422 Person::delete(pool, inserted_sara_person.id).await.unwrap();
423 Person::delete(pool, inserted_jess_person.id).await.unwrap();
424 Instance::delete(pool, inserted_instance.id).await.unwrap();