crates/db_views/src/local_user_view.rs

   1 use crate::structs::{LocalUserSettingsView, LocalUserView};
   2 use diesel::{result::Error, *};
   3 use lemmy_db_schema::{
   4   aggregates::structs::PersonAggregates,
   5   newtypes::{LocalUserId, PersonId},
   6   schema::{local_user, person, person_aggregates},
   7   source::{
   8     local_user::{LocalUser, LocalUserSettings},
   9     person::{Person, PersonSafe},
  10   },
  11   traits::{ToSafe, ToSafeSettings},
  12   utils::functions::lower,
  13 };
  14
  15 type LocalUserViewTuple = (LocalUser, Person, PersonAggregates);
  16
  17 impl LocalUserView {
  18   pub fn read(conn: &mut PgConnection, local_user_id: LocalUserId) -> Result<Self, Error> {
  19     let (local_user, person, counts) = local_user::table
  20       .find(local_user_id)
  21       .inner_join(person::table)
  22       .inner_join(person_aggregates::table.on(person::id.eq(person_aggregates::person_id)))
  23       .select((
  24         local_user::all_columns,
  25         person::all_columns,
  26         person_aggregates::all_columns,
  27       ))
  28       .first::<LocalUserViewTuple>(conn)?;
  29     Ok(Self {
  30       local_user,
  31       person,
  32       counts,
  33     })
  34   }
  35
  36   pub fn read_person(conn: &mut PgConnection, person_id: PersonId) -> Result<Self, Error> {
  37     let (local_user, person, counts) = local_user::table
  38       .filter(person::id.eq(person_id))
  39       .inner_join(person::table)
  40       .inner_join(person_aggregates::table.on(person::id.eq(person_aggregates::person_id)))
  41       .select((
  42         local_user::all_columns,
  43         person::all_columns,
  44         person_aggregates::all_columns,
  45       ))
  46       .first::<LocalUserViewTuple>(conn)?;
  47     Ok(Self {
  48       local_user,
  49       person,
  50       counts,
  51     })
  52   }
  53
  54   // TODO check where this is used
  55   pub fn read_from_name(conn: &mut PgConnection, name: &str) -> Result<Self, Error> {
  56     let (local_user, person, counts) = local_user::table
  57       .filter(person::name.eq(name))
  58       .inner_join(person::table)
  59       .inner_join(person_aggregates::table.on(person::id.eq(person_aggregates::person_id)))
  60       .select((
  61         local_user::all_columns,
  62         person::all_columns,
  63         person_aggregates::all_columns,
  64       ))
  65       .first::<LocalUserViewTuple>(conn)?;
  66     Ok(Self {
  67       local_user,
  68       person,
  69       counts,
  70     })
  71   }
  72
  73   pub fn find_by_email_or_name(
  74     conn: &mut PgConnection,
  75     name_or_email: &str,
  76   ) -> Result<Self, Error> {
  77     let (local_user, person, counts) = local_user::table
  78       .inner_join(person::table)
  79       .inner_join(person_aggregates::table.on(person::id.eq(person_aggregates::person_id)))
  80       .filter(
  81         lower(person::name)
  82           .eq(lower(name_or_email))
  83           .or(local_user::email.eq(name_or_email)),
  84       )
  85       .select((
  86         local_user::all_columns,
  87         person::all_columns,
  88         person_aggregates::all_columns,
  89       ))
  90       .first::<LocalUserViewTuple>(conn)?;
  91     Ok(Self {
  92       local_user,
  93       person,
  94       counts,
  95     })
  96   }
  97
  98   pub fn find_by_email(conn: &mut PgConnection, from_email: &str) -> Result<Self, Error> {
  99     let (local_user, person, counts) = local_user::table
 100       .inner_join(person::table)
 101       .inner_join(person_aggregates::table.on(person::id.eq(person_aggregates::person_id)))
 102       .filter(local_user::email.eq(from_email))
 103       .select((
 104         local_user::all_columns,
 105         person::all_columns,
 106         person_aggregates::all_columns,
 107       ))
 108       .first::<LocalUserViewTuple>(conn)?;
 109     Ok(Self {
 110       local_user,
 111       person,
 112       counts,
 113     })
 114   }
 115 }
 116
 117 type LocalUserSettingsViewTuple = (LocalUserSettings, PersonSafe, PersonAggregates);
 118
 119 impl LocalUserSettingsView {
 120   pub fn read(conn: &mut PgConnection, local_user_id: LocalUserId) -> Result<Self, Error> {
 121     let (local_user, person, counts) = local_user::table
 122       .find(local_user_id)
 123       .inner_join(person::table)
 124       .inner_join(person_aggregates::table.on(person::id.eq(person_aggregates::person_id)))
 125       .select((
 126         LocalUser::safe_settings_columns_tuple(),
 127         Person::safe_columns_tuple(),
 128         person_aggregates::all_columns,
 129       ))
 130       .first::<LocalUserSettingsViewTuple>(conn)?;
 131     Ok(Self {
 132       local_user,
 133       person,
 134       counts,
 135     })
 136   }
 137 }