crates/db_views/src/local_user_view.rs

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