crates/db_views/src/local_user_view.rs

   1 use crate::structs::LocalUserView;
   2 use diesel::{result::Error, BoolExpressionMethods, ExpressionMethods, JoinOnDsl, QueryDsl};
   3 use diesel_async::RunQueryDsl;
   4 use lemmy_db_schema::{
   5   aggregates::structs::PersonAggregates,
   6   newtypes::{LocalUserId, PersonId},
   7   schema::{local_user, person, person_aggregates},
   8   source::{local_user::LocalUser, person::Person},
   9   traits::JoinView,
  10   utils::{functions::lower, DbConn, DbPool, ListFn, Queries, ReadFn},
  11 };
  12
  13 type LocalUserViewTuple = (LocalUser, Person, PersonAggregates);
  14
  15 enum ReadBy<'a> {
  16   Id(LocalUserId),
  17   Person(PersonId),
  18   Name(&'a str),
  19   NameOrEmail(&'a str),
  20   Email(&'a str),
  21 }
  22
  23 enum ListMode {
  24   AdminsWithEmails,
  25 }
  26
  27 fn queries<'a>(
  28 ) -> Queries<impl ReadFn<'a, LocalUserView, ReadBy<'a>>, impl ListFn<'a, LocalUserView, ListMode>> {
  29   let selection = (
  30     local_user::all_columns,
  31     person::all_columns,
  32     person_aggregates::all_columns,
  33   );
  34
  35   let read = move |mut conn: DbConn<'a>, search: ReadBy<'a>| async move {
  36     let mut query = local_user::table.into_boxed();
  37     query = match search {
  38       ReadBy::Id(local_user_id) => query.filter(local_user::id.eq(local_user_id)),
  39       ReadBy::Email(from_email) => query.filter(local_user::email.eq(from_email)),
  40       _ => query,
  41     };
  42     let mut query = query.inner_join(person::table);
  43     query = match search {
  44       ReadBy::Person(person_id) => query.filter(person::id.eq(person_id)),
  45       ReadBy::Name(name) => query.filter(lower(person::name).eq(name.to_lowercase())),
  46       ReadBy::NameOrEmail(name_or_email) => query.filter(
  47         lower(person::name)
  48           .eq(lower(name_or_email))
  49           .or(local_user::email.eq(name_or_email)),
  50       ),
  51       _ => query,
  52     };
  53     query
  54       .inner_join(person_aggregates::table.on(person::id.eq(person_aggregates::person_id)))
  55       .select(selection)
  56       .first::<LocalUserViewTuple>(&mut conn)
  57       .await
  58   };
  59
  60   let list = move |mut conn: DbConn<'a>, mode: ListMode| async move {
  61     match mode {
  62       ListMode::AdminsWithEmails => {
  63         local_user::table
  64           .filter(local_user::email.is_not_null())
  65           .filter(person::admin.eq(true))
  66           .inner_join(person::table)
  67           .inner_join(person_aggregates::table.on(person::id.eq(person_aggregates::person_id)))
  68           .select(selection)
  69           .load::<LocalUserViewTuple>(&mut conn)
  70           .await
  71       }
  72     }
  73   };
  74
  75   Queries::new(read, list)
  76 }
  77
  78 impl LocalUserView {
  79   pub async fn read(pool: &mut DbPool<'_>, local_user_id: LocalUserId) -> Result<Self, Error> {
  80     queries().read(pool, ReadBy::Id(local_user_id)).await
  81   }
  82
  83   pub async fn read_person(pool: &mut DbPool<'_>, person_id: PersonId) -> Result<Self, Error> {
  84     queries().read(pool, ReadBy::Person(person_id)).await
  85   }
  86
  87   pub async fn read_from_name(pool: &mut DbPool<'_>, name: &str) -> Result<Self, Error> {
  88     queries().read(pool, ReadBy::Name(name)).await
  89   }
  90
  91   pub async fn find_by_email_or_name(
  92     pool: &mut DbPool<'_>,
  93     name_or_email: &str,
  94   ) -> Result<Self, Error> {
  95     queries()
  96       .read(pool, ReadBy::NameOrEmail(name_or_email))
  97       .await
  98   }
  99
 100   pub async fn find_by_email(pool: &mut DbPool<'_>, from_email: &str) -> Result<Self, Error> {
 101     queries().read(pool, ReadBy::Email(from_email)).await
 102   }
 103
 104   pub async fn list_admins_with_emails(pool: &mut DbPool<'_>) -> Result<Vec<Self>, Error> {
 105     queries().list(pool, ListMode::AdminsWithEmails).await
 106   }
 107 }
 108
 109 impl JoinView for LocalUserView {
 110   type JoinTuple = LocalUserViewTuple;
 111   fn from_tuple(a: Self::JoinTuple) -> Self {
 112     Self {
 113       local_user: a.0,
 114       person: a.1,
 115       counts: a.2,
 116     }
 117   }
 118 }