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: &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: &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: &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(conn: &PgConnection, name_or_email: &str) -> Result<Self, Error> {
  74     let (local_user, person, counts) = local_user::table
  75       .inner_join(person::table)
  76       .inner_join(person_aggregates::table.on(person::id.eq(person_aggregates::person_id)))
  77       .filter(
  78         lower(person::name)
  79           .eq(lower(name_or_email))
  80           .or(local_user::email.eq(name_or_email)),
  81       )
  82       .select((
  83         local_user::all_columns,
  84         person::all_columns,
  85         person_aggregates::all_columns,
  86       ))
  87       .first::<LocalUserViewTuple>(conn)?;
  88     Ok(Self {
  89       local_user,
  90       person,
  91       counts,
  92     })
  93   }
  94
  95   pub fn find_by_email(conn: &PgConnection, from_email: &str) -> Result<Self, Error> {
  96     let (local_user, person, counts) = local_user::table
  97       .inner_join(person::table)
  98       .inner_join(person_aggregates::table.on(person::id.eq(person_aggregates::person_id)))
  99       .filter(local_user::email.eq(from_email))
 100       .select((
 101         local_user::all_columns,
 102         person::all_columns,
 103         person_aggregates::all_columns,
 104       ))
 105       .first::<LocalUserViewTuple>(conn)?;
 106     Ok(Self {
 107       local_user,
 108       person,
 109       counts,
 110     })
 111   }
 112 }
 113
 114 type LocalUserSettingsViewTuple = (LocalUserSettings, PersonSafe, PersonAggregates);
 115
 116 impl LocalUserSettingsView {
 117   pub fn read(conn: &PgConnection, local_user_id: LocalUserId) -> Result<Self, Error> {
 118     let (local_user, person, counts) = local_user::table
 119       .find(local_user_id)
 120       .inner_join(person::table)
 121       .inner_join(person_aggregates::table.on(person::id.eq(person_aggregates::person_id)))
 122       .select((
 123         LocalUser::safe_settings_columns_tuple(),
 124         Person::safe_columns_tuple(),
 125         person_aggregates::all_columns,
 126       ))
 127       .first::<LocalUserSettingsViewTuple>(conn)?;
 128     Ok(Self {
 129       local_user,
 130       person,
 131       counts,
 132     })
 133   }
 134 }