crates/db_views/src/local_user_view.rs

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