use crate::structs::RegistrationApplicationView;
use diesel::{
dsl::count,
+ pg::Pg,
result::Error,
ExpressionMethods,
JoinOnDsl,
};
use diesel_async::RunQueryDsl;
use lemmy_db_schema::{
+ aliases,
schema::{local_user, person, registration_application},
source::{
local_user::LocalUser,
registration_application::RegistrationApplication,
},
traits::JoinView,
- utils::{get_conn, limit_and_offset, DbPool},
+ utils::{get_conn, limit_and_offset, DbConn, DbPool, ListFn, Queries, ReadFn},
};
-use typed_builder::TypedBuilder;
type RegistrationApplicationViewTuple =
(RegistrationApplication, LocalUser, Person, Option<Person>);
+fn queries<'a>() -> Queries<
+ impl ReadFn<'a, RegistrationApplicationView, i32>,
+ impl ListFn<'a, RegistrationApplicationView, RegistrationApplicationQuery>,
+> {
+ let all_joins = |query: registration_application::BoxedQuery<'a, Pg>| {
+ query
+ .inner_join(local_user::table.on(registration_application::local_user_id.eq(local_user::id)))
+ .inner_join(person::table.on(local_user::person_id.eq(person::id)))
+ .left_join(
+ aliases::person1
+ .on(registration_application::admin_id.eq(aliases::person1.field(person::id).nullable())),
+ )
+ .order_by(registration_application::published.desc())
+ .select((
+ registration_application::all_columns,
+ local_user::all_columns,
+ person::all_columns,
+ aliases::person1.fields(person::all_columns).nullable(),
+ ))
+ };
+
+ let read = move |mut conn: DbConn<'a>, registration_application_id: i32| async move {
+ all_joins(
+ registration_application::table
+ .find(registration_application_id)
+ .into_boxed(),
+ )
+ .first::<RegistrationApplicationViewTuple>(&mut conn)
+ .await
+ };
+
+ let list = move |mut conn: DbConn<'a>, options: RegistrationApplicationQuery| async move {
+ let mut query = all_joins(registration_application::table.into_boxed());
+
+ if options.unread_only {
+ query = query.filter(registration_application::admin_id.is_null())
+ }
+
+ if options.verified_email_only {
+ query = query.filter(local_user::email_verified.eq(true))
+ }
+
+ let (limit, offset) = limit_and_offset(options.page, options.limit)?;
+
+ query = query
+ .limit(limit)
+ .offset(offset)
+ .order_by(registration_application::published.desc());
+
+ query
+ .load::<RegistrationApplicationViewTuple>(&mut conn)
+ .await
+ };
+
+ Queries::new(read, list)
+}
+
impl RegistrationApplicationView {
pub async fn read(
pool: &mut DbPool<'_>,
registration_application_id: i32,
) -> Result<Self, Error> {
- let conn = &mut get_conn(pool).await?;
- let person_alias_1 = diesel::alias!(person as person1);
-
- let (registration_application, creator_local_user, creator, admin) =
- registration_application::table
- .find(registration_application_id)
- .inner_join(
- local_user::table.on(registration_application::local_user_id.eq(local_user::id)),
- )
- .inner_join(person::table.on(local_user::person_id.eq(person::id)))
- .left_join(
- person_alias_1
- .on(registration_application::admin_id.eq(person_alias_1.field(person::id).nullable())),
- )
- .order_by(registration_application::published.desc())
- .select((
- registration_application::all_columns,
- local_user::all_columns,
- person::all_columns,
- person_alias_1.fields(person::all_columns).nullable(),
- ))
- .first::<RegistrationApplicationViewTuple>(conn)
- .await?;
-
- Ok(RegistrationApplicationView {
- registration_application,
- creator_local_user,
- creator,
- admin,
- })
+ queries().read(pool, registration_application_id).await
}
/// Returns the current unread registration_application count
}
}
-#[derive(TypedBuilder)]
-#[builder(field_defaults(default))]
-pub struct RegistrationApplicationQuery<'a, 'b: 'a> {
- #[builder(!default)]
- pool: &'a mut DbPool<'b>,
- unread_only: Option<bool>,
- verified_email_only: Option<bool>,
- page: Option<i64>,
- limit: Option<i64>,
+#[derive(Default)]
+pub struct RegistrationApplicationQuery {
+ pub unread_only: bool,
+ pub verified_email_only: bool,
+ pub page: Option<i64>,
+ pub limit: Option<i64>,
}
-impl<'a, 'b: 'a> RegistrationApplicationQuery<'a, 'b> {
- pub async fn list(self) -> Result<Vec<RegistrationApplicationView>, Error> {
- let conn = &mut get_conn(self.pool).await?;
- let person_alias_1 = diesel::alias!(person as person1);
-
- let mut query = registration_application::table
- .inner_join(local_user::table.on(registration_application::local_user_id.eq(local_user::id)))
- .inner_join(person::table.on(local_user::person_id.eq(person::id)))
- .left_join(
- person_alias_1
- .on(registration_application::admin_id.eq(person_alias_1.field(person::id).nullable())),
- )
- .order_by(registration_application::published.desc())
- .select((
- registration_application::all_columns,
- local_user::all_columns,
- person::all_columns,
- person_alias_1.fields(person::all_columns).nullable(),
- ))
- .into_boxed();
-
- if self.unread_only.unwrap_or(false) {
- query = query.filter(registration_application::admin_id.is_null())
- }
-
- if self.verified_email_only.unwrap_or(false) {
- query = query.filter(local_user::email_verified.eq(true))
- }
-
- let (limit, offset) = limit_and_offset(self.page, self.limit)?;
-
- query = query
- .limit(limit)
- .offset(offset)
- .order_by(registration_application::published.desc());
-
- let res = query.load::<RegistrationApplicationViewTuple>(conn).await?;
-
- Ok(
- res
- .into_iter()
- .map(RegistrationApplicationView::from_tuple)
- .collect(),
- )
+impl RegistrationApplicationQuery {
+ pub async fn list(
+ self,
+ pool: &mut DbPool<'_>,
+ ) -> Result<Vec<RegistrationApplicationView>, Error> {
+ queries().list(pool, self).await
}
}
#[cfg(test)]
mod tests {
+ #![allow(clippy::unwrap_used)]
+ #![allow(clippy::indexing_slicing)]
+
use crate::registration_application_view::{
RegistrationApplicationQuery,
RegistrationApplicationView,
person_id: inserted_sara_local_user.person_id,
email: inserted_sara_local_user.email,
show_nsfw: inserted_sara_local_user.show_nsfw,
+ auto_expand: inserted_sara_local_user.auto_expand,
+ blur_nsfw: inserted_sara_local_user.blur_nsfw,
theme: inserted_sara_local_user.theme,
default_sort_type: inserted_sara_local_user.default_sort_type,
default_listing_type: inserted_sara_local_user.default_listing_type,
assert_eq!(read_sara_app_view, expected_sara_app_view);
// Do a batch read of the applications
- let apps = RegistrationApplicationQuery::builder()
- .pool(pool)
- .unread_only(Some(true))
- .build()
- .list()
- .await
- .unwrap();
+ let apps = RegistrationApplicationQuery {
+ unread_only: (true),
+ ..Default::default()
+ }
+ .list(pool)
+ .await
+ .unwrap();
assert_eq!(
apps,
.unwrap();
// Update the local_user row
- let approve_local_user_form = LocalUserUpdateForm::builder()
- .accepted_application(Some(true))
- .build();
+ let approve_local_user_form = LocalUserUpdateForm {
+ accepted_application: Some(true),
+ ..Default::default()
+ };
LocalUser::update(pool, inserted_sara_local_user.id, &approve_local_user_form)
.await
// Do a batch read of apps again
// It should show only jessicas which is unresolved
- let apps_after_resolve = RegistrationApplicationQuery::builder()
- .pool(pool)
- .unread_only(Some(true))
- .build()
- .list()
- .await
- .unwrap();
+ let apps_after_resolve = RegistrationApplicationQuery {
+ unread_only: (true),
+ ..Default::default()
+ }
+ .list(pool)
+ .await
+ .unwrap();
assert_eq!(apps_after_resolve, vec![read_jess_app_view]);
// Make sure the counts are correct
assert_eq!(unread_count_after_approve, 1);
// Make sure the not undenied_only has all the apps
- let all_apps = RegistrationApplicationQuery::builder()
- .pool(pool)
- .build()
- .list()
+ let all_apps = RegistrationApplicationQuery::default()
+ .list(pool)
.await
.unwrap();
assert_eq!(all_apps.len(), 2);
projects / lemmy.git / blobdiff