crates/db_queries/src/source/person.rs

   1 use crate::{ApubObject, Crud};
   2 use diesel::{dsl::*, result::Error, *};
   3 use lemmy_db_schema::{
   4   naive_now,
   5   schema::person::dsl::*,
   6   source::person::{Person, PersonForm},
   7   DbUrl,
   8   PersonId,
   9 };
  10
  11 mod safe_type {
  12   use crate::ToSafe;
  13   use lemmy_db_schema::{schema::person::columns::*, source::person::Person};
  14
  15   type Columns = (
  16     id,
  17     name,
  18     preferred_username,
  19     avatar,
  20     banned,
  21     published,
  22     updated,
  23     actor_id,
  24     bio,
  25     local,
  26     banner,
  27     deleted,
  28     inbox_url,
  29     shared_inbox_url,
  30     matrix_user_id,
  31   );
  32
  33   impl ToSafe for Person {
  34     type SafeColumns = Columns;
  35     fn safe_columns_tuple() -> Self::SafeColumns {
  36       (
  37         id,
  38         name,
  39         preferred_username,
  40         avatar,
  41         banned,
  42         published,
  43         updated,
  44         actor_id,
  45         bio,
  46         local,
  47         banner,
  48         deleted,
  49         inbox_url,
  50         shared_inbox_url,
  51         matrix_user_id,
  52       )
  53     }
  54   }
  55 }
  56
  57 mod safe_type_alias_1 {
  58   use crate::ToSafe;
  59   use lemmy_db_schema::{schema::person_alias_1::columns::*, source::person::PersonAlias1};
  60
  61   type Columns = (
  62     id,
  63     name,
  64     preferred_username,
  65     avatar,
  66     banned,
  67     published,
  68     updated,
  69     actor_id,
  70     bio,
  71     local,
  72     banner,
  73     deleted,
  74     inbox_url,
  75     shared_inbox_url,
  76     matrix_user_id,
  77   );
  78
  79   impl ToSafe for PersonAlias1 {
  80     type SafeColumns = Columns;
  81     fn safe_columns_tuple() -> Self::SafeColumns {
  82       (
  83         id,
  84         name,
  85         preferred_username,
  86         avatar,
  87         banned,
  88         published,
  89         updated,
  90         actor_id,
  91         bio,
  92         local,
  93         banner,
  94         deleted,
  95         inbox_url,
  96         shared_inbox_url,
  97         matrix_user_id,
  98       )
  99     }
 100   }
 101 }
 102
 103 mod safe_type_alias_2 {
 104   use crate::ToSafe;
 105   use lemmy_db_schema::{schema::person_alias_2::columns::*, source::person::PersonAlias2};
 106
 107   type Columns = (
 108     id,
 109     name,
 110     preferred_username,
 111     avatar,
 112     banned,
 113     published,
 114     updated,
 115     actor_id,
 116     bio,
 117     local,
 118     banner,
 119     deleted,
 120     inbox_url,
 121     shared_inbox_url,
 122     matrix_user_id,
 123   );
 124
 125   impl ToSafe for PersonAlias2 {
 126     type SafeColumns = Columns;
 127     fn safe_columns_tuple() -> Self::SafeColumns {
 128       (
 129         id,
 130         name,
 131         preferred_username,
 132         avatar,
 133         banned,
 134         published,
 135         updated,
 136         actor_id,
 137         bio,
 138         local,
 139         banner,
 140         deleted,
 141         inbox_url,
 142         shared_inbox_url,
 143         matrix_user_id,
 144       )
 145     }
 146   }
 147 }
 148
 149 impl Crud<PersonForm, PersonId> for Person {
 150   fn read(conn: &PgConnection, person_id: PersonId) -> Result<Self, Error> {
 151     person
 152       .filter(deleted.eq(false))
 153       .find(person_id)
 154       .first::<Self>(conn)
 155   }
 156   fn delete(conn: &PgConnection, person_id: PersonId) -> Result<usize, Error> {
 157     diesel::delete(person.find(person_id)).execute(conn)
 158   }
 159   fn create(conn: &PgConnection, form: &PersonForm) -> Result<Self, Error> {
 160     insert_into(person).values(form).get_result::<Self>(conn)
 161   }
 162   fn update(conn: &PgConnection, person_id: PersonId, form: &PersonForm) -> Result<Self, Error> {
 163     diesel::update(person.find(person_id))
 164       .set(form)
 165       .get_result::<Self>(conn)
 166   }
 167 }
 168
 169 impl ApubObject<PersonForm> for Person {
 170   fn read_from_apub_id(conn: &PgConnection, object_id: &DbUrl) -> Result<Self, Error> {
 171     use lemmy_db_schema::schema::person::dsl::*;
 172     person
 173       .filter(deleted.eq(false))
 174       .filter(actor_id.eq(object_id))
 175       .first::<Self>(conn)
 176   }
 177
 178   fn upsert(conn: &PgConnection, person_form: &PersonForm) -> Result<Person, Error> {
 179     insert_into(person)
 180       .values(person_form)
 181       .on_conflict(actor_id)
 182       .do_update()
 183       .set(person_form)
 184       .get_result::<Self>(conn)
 185   }
 186 }
 187
 188 pub trait Person_ {
 189   fn ban_person(conn: &PgConnection, person_id: PersonId, ban: bool) -> Result<Person, Error>;
 190   fn find_by_name(conn: &PgConnection, name: &str) -> Result<Person, Error>;
 191   fn mark_as_updated(conn: &PgConnection, person_id: PersonId) -> Result<Person, Error>;
 192   fn delete_account(conn: &PgConnection, person_id: PersonId) -> Result<Person, Error>;
 193 }
 194
 195 impl Person_ for Person {
 196   fn ban_person(conn: &PgConnection, person_id: PersonId, ban: bool) -> Result<Self, Error> {
 197     diesel::update(person.find(person_id))
 198       .set(banned.eq(ban))
 199       .get_result::<Self>(conn)
 200   }
 201
 202   fn find_by_name(conn: &PgConnection, from_name: &str) -> Result<Person, Error> {
 203     person
 204       .filter(deleted.eq(false))
 205       .filter(local.eq(true))
 206       .filter(name.ilike(from_name))
 207       .first::<Person>(conn)
 208   }
 209
 210   fn mark_as_updated(conn: &PgConnection, person_id: PersonId) -> Result<Person, Error> {
 211     diesel::update(person.find(person_id))
 212       .set((last_refreshed_at.eq(naive_now()),))
 213       .get_result::<Self>(conn)
 214   }
 215
 216   fn delete_account(conn: &PgConnection, person_id: PersonId) -> Result<Person, Error> {
 217     use lemmy_db_schema::schema::local_user;
 218
 219     // Set the local user info to none
 220     diesel::update(local_user::table.filter(local_user::person_id.eq(person_id)))
 221       .set((local_user::email.eq::<Option<String>>(None),))
 222       .execute(conn)?;
 223
 224     diesel::update(person.find(person_id))
 225       .set((
 226         preferred_username.eq::<Option<String>>(None),
 227         bio.eq::<Option<String>>(None),
 228         matrix_user_id.eq::<Option<String>>(None),
 229         deleted.eq(true),
 230         updated.eq(naive_now()),
 231       ))
 232       .get_result::<Self>(conn)
 233   }
 234 }
 235
 236 #[cfg(test)]
 237 mod tests {
 238   use crate::{establish_unpooled_connection, source::person::*};
 239
 240   #[test]
 241   fn test_crud() {
 242     let conn = establish_unpooled_connection();
 243
 244     let new_person = PersonForm {
 245       name: "holly".into(),
 246       preferred_username: None,
 247       avatar: None,
 248       banner: None,
 249       banned: None,
 250       deleted: None,
 251       published: None,
 252       updated: None,
 253       actor_id: None,
 254       bio: None,
 255       local: None,
 256       private_key: None,
 257       public_key: None,
 258       last_refreshed_at: None,
 259       inbox_url: None,
 260       shared_inbox_url: None,
 261       matrix_user_id: None,
 262     };
 263
 264     let inserted_person = Person::create(&conn, &new_person).unwrap();
 265
 266     let expected_person = Person {
 267       id: inserted_person.id,
 268       name: "holly".into(),
 269       preferred_username: None,
 270       avatar: None,
 271       banner: None,
 272       banned: false,
 273       deleted: false,
 274       published: inserted_person.published,
 275       updated: None,
 276       actor_id: inserted_person.actor_id.to_owned(),
 277       bio: None,
 278       local: true,
 279       private_key: None,
 280       public_key: None,
 281       last_refreshed_at: inserted_person.published,
 282       inbox_url: inserted_person.inbox_url.to_owned(),
 283       shared_inbox_url: None,
 284       matrix_user_id: None,
 285     };
 286
 287     let read_person = Person::read(&conn, inserted_person.id).unwrap();
 288     let updated_person = Person::update(&conn, inserted_person.id, &new_person).unwrap();
 289     let num_deleted = Person::delete(&conn, inserted_person.id).unwrap();
 290
 291     assert_eq!(expected_person, read_person);
 292     assert_eq!(expected_person, inserted_person);
 293     assert_eq!(expected_person, updated_person);
 294     assert_eq!(1, num_deleted);
 295   }
 296 }