crates/db_schema/src/impls/person.rs

   1 use crate::{
   2   functions::lower,
   3   naive_now,
   4   newtypes::{DbUrl, PersonId},
   5   schema::person::dsl::*,
   6   source::person::{Person, PersonForm, PersonSafe},
   7   traits::{ApubActor, Crud},
   8 };
   9 use diesel::{
  10   dsl::*,
  11   result::Error,
  12   ExpressionMethods,
  13   PgConnection,
  14   QueryDsl,
  15   RunQueryDsl,
  16   TextExpressionMethods,
  17 };
  18
  19 mod safe_type {
  20   use crate::{schema::person::columns::*, source::person::Person, traits::ToSafe};
  21
  22   type Columns = (
  23     id,
  24     name,
  25     display_name,
  26     avatar,
  27     banned,
  28     published,
  29     updated,
  30     actor_id,
  31     bio,
  32     local,
  33     banner,
  34     deleted,
  35     inbox_url,
  36     shared_inbox_url,
  37     matrix_user_id,
  38     admin,
  39     bot_account,
  40     ban_expires,
  41   );
  42
  43   impl ToSafe for Person {
  44     type SafeColumns = Columns;
  45     fn safe_columns_tuple() -> Self::SafeColumns {
  46       (
  47         id,
  48         name,
  49         display_name,
  50         avatar,
  51         banned,
  52         published,
  53         updated,
  54         actor_id,
  55         bio,
  56         local,
  57         banner,
  58         deleted,
  59         inbox_url,
  60         shared_inbox_url,
  61         matrix_user_id,
  62         admin,
  63         bot_account,
  64         ban_expires,
  65       )
  66     }
  67   }
  68 }
  69
  70 mod safe_type_alias_1 {
  71   use crate::{schema::person_alias_1::columns::*, source::person::PersonAlias1, traits::ToSafe};
  72
  73   type Columns = (
  74     id,
  75     name,
  76     display_name,
  77     avatar,
  78     banned,
  79     published,
  80     updated,
  81     actor_id,
  82     bio,
  83     local,
  84     banner,
  85     deleted,
  86     inbox_url,
  87     shared_inbox_url,
  88     matrix_user_id,
  89     admin,
  90     bot_account,
  91     ban_expires,
  92   );
  93
  94   impl ToSafe for PersonAlias1 {
  95     type SafeColumns = Columns;
  96     fn safe_columns_tuple() -> Self::SafeColumns {
  97       (
  98         id,
  99         name,
 100         display_name,
 101         avatar,
 102         banned,
 103         published,
 104         updated,
 105         actor_id,
 106         bio,
 107         local,
 108         banner,
 109         deleted,
 110         inbox_url,
 111         shared_inbox_url,
 112         matrix_user_id,
 113         admin,
 114         bot_account,
 115         ban_expires,
 116       )
 117     }
 118   }
 119 }
 120
 121 mod safe_type_alias_2 {
 122   use crate::{schema::person_alias_2::columns::*, source::person::PersonAlias2, traits::ToSafe};
 123
 124   type Columns = (
 125     id,
 126     name,
 127     display_name,
 128     avatar,
 129     banned,
 130     published,
 131     updated,
 132     actor_id,
 133     bio,
 134     local,
 135     banner,
 136     deleted,
 137     inbox_url,
 138     shared_inbox_url,
 139     matrix_user_id,
 140     admin,
 141     bot_account,
 142     ban_expires,
 143   );
 144
 145   impl ToSafe for PersonAlias2 {
 146     type SafeColumns = Columns;
 147     fn safe_columns_tuple() -> Self::SafeColumns {
 148       (
 149         id,
 150         name,
 151         display_name,
 152         avatar,
 153         banned,
 154         published,
 155         updated,
 156         actor_id,
 157         bio,
 158         local,
 159         banner,
 160         deleted,
 161         inbox_url,
 162         shared_inbox_url,
 163         matrix_user_id,
 164         admin,
 165         bot_account,
 166         ban_expires,
 167       )
 168     }
 169   }
 170 }
 171
 172 impl Crud for Person {
 173   type Form = PersonForm;
 174   type IdType = PersonId;
 175   fn read(conn: &PgConnection, person_id: PersonId) -> Result<Self, Error> {
 176     person
 177       .filter(deleted.eq(false))
 178       .find(person_id)
 179       .first::<Self>(conn)
 180   }
 181   fn delete(conn: &PgConnection, person_id: PersonId) -> Result<usize, Error> {
 182     diesel::delete(person.find(person_id)).execute(conn)
 183   }
 184   fn create(conn: &PgConnection, form: &PersonForm) -> Result<Self, Error> {
 185     insert_into(person).values(form).get_result::<Self>(conn)
 186   }
 187   fn update(conn: &PgConnection, person_id: PersonId, form: &PersonForm) -> Result<Self, Error> {
 188     diesel::update(person.find(person_id))
 189       .set(form)
 190       .get_result::<Self>(conn)
 191   }
 192 }
 193
 194 impl Person {
 195   pub fn ban_person(
 196     conn: &PgConnection,
 197     person_id: PersonId,
 198     ban: bool,
 199     expires: Option<chrono::NaiveDateTime>,
 200   ) -> Result<Self, Error> {
 201     diesel::update(person.find(person_id))
 202       .set((banned.eq(ban), ban_expires.eq(expires)))
 203       .get_result::<Self>(conn)
 204   }
 205
 206   pub fn add_admin(conn: &PgConnection, person_id: PersonId, added: bool) -> Result<Self, Error> {
 207     diesel::update(person.find(person_id))
 208       .set(admin.eq(added))
 209       .get_result::<Self>(conn)
 210   }
 211
 212   pub fn mark_as_updated(conn: &PgConnection, person_id: PersonId) -> Result<Person, Error> {
 213     diesel::update(person.find(person_id))
 214       .set((last_refreshed_at.eq(naive_now()),))
 215       .get_result::<Self>(conn)
 216   }
 217
 218   pub fn delete_account(conn: &PgConnection, person_id: PersonId) -> Result<Person, Error> {
 219     use crate::schema::local_user;
 220
 221     // Set the local user info to none
 222     diesel::update(local_user::table.filter(local_user::person_id.eq(person_id)))
 223       .set((
 224         local_user::email.eq::<Option<String>>(None),
 225         local_user::validator_time.eq(naive_now()),
 226       ))
 227       .execute(conn)?;
 228
 229     diesel::update(person.find(person_id))
 230       .set((
 231         display_name.eq::<Option<String>>(None),
 232         bio.eq::<Option<String>>(None),
 233         matrix_user_id.eq::<Option<String>>(None),
 234         deleted.eq(true),
 235         updated.eq(naive_now()),
 236       ))
 237       .get_result::<Self>(conn)
 238   }
 239
 240   pub fn upsert(conn: &PgConnection, person_form: &PersonForm) -> Result<Person, Error> {
 241     insert_into(person)
 242       .values(person_form)
 243       .on_conflict(actor_id)
 244       .do_update()
 245       .set(person_form)
 246       .get_result::<Self>(conn)
 247   }
 248
 249   pub fn update_deleted(
 250     conn: &PgConnection,
 251     person_id: PersonId,
 252     new_deleted: bool,
 253   ) -> Result<Person, Error> {
 254     use crate::schema::person::dsl::*;
 255     diesel::update(person.find(person_id))
 256       .set(deleted.eq(new_deleted))
 257       .get_result::<Self>(conn)
 258   }
 259
 260   pub fn is_banned(&self) -> bool {
 261     is_banned(self.banned, self.ban_expires)
 262   }
 263
 264   pub fn leave_admin(conn: &PgConnection, person_id: PersonId) -> Result<Self, Error> {
 265     diesel::update(person.find(person_id))
 266       .set(admin.eq(false))
 267       .get_result::<Self>(conn)
 268   }
 269 }
 270
 271 impl PersonSafe {
 272   pub fn is_banned(&self) -> bool {
 273     is_banned(self.banned, self.ban_expires)
 274   }
 275 }
 276
 277 fn is_banned(banned_: bool, expires: Option<chrono::NaiveDateTime>) -> bool {
 278   if let Some(expires) = expires {
 279     banned_ && expires.gt(&naive_now())
 280   } else {
 281     banned_
 282   }
 283 }
 284
 285 impl ApubActor for Person {
 286   fn read_from_apub_id(conn: &PgConnection, object_id: &DbUrl) -> Result<Option<Self>, Error> {
 287     use crate::schema::person::dsl::*;
 288     Ok(
 289       person
 290         .filter(deleted.eq(false))
 291         .filter(actor_id.eq(object_id))
 292         .first::<Person>(conn)
 293         .ok()
 294         .map(Into::into),
 295     )
 296   }
 297
 298   fn read_from_name(conn: &PgConnection, from_name: &str) -> Result<Person, Error> {
 299     person
 300       .filter(deleted.eq(false))
 301       .filter(local.eq(true))
 302       .filter(lower(name).eq(lower(from_name)))
 303       .first::<Person>(conn)
 304   }
 305
 306   fn read_from_name_and_domain(
 307     conn: &PgConnection,
 308     person_name: &str,
 309     protocol_domain: &str,
 310   ) -> Result<Person, Error> {
 311     use crate::schema::person::dsl::*;
 312     person
 313       .filter(lower(name).eq(lower(person_name)))
 314       .filter(actor_id.like(format!("{}%", protocol_domain)))
 315       .first::<Self>(conn)
 316   }
 317 }
 318
 319 #[cfg(test)]
 320 mod tests {
 321   use crate::{establish_unpooled_connection, source::person::*, traits::Crud};
 322
 323   #[test]
 324   fn test_crud() {
 325     let conn = establish_unpooled_connection();
 326
 327     let new_person = PersonForm {
 328       name: "holly".into(),
 329       public_key: "nada".to_owned(),
 330       ..PersonForm::default()
 331     };
 332
 333     let inserted_person = Person::create(&conn, &new_person).unwrap();
 334
 335     let expected_person = Person {
 336       id: inserted_person.id,
 337       name: "holly".into(),
 338       display_name: None,
 339       avatar: None,
 340       banner: None,
 341       banned: false,
 342       deleted: false,
 343       published: inserted_person.published,
 344       updated: None,
 345       actor_id: inserted_person.actor_id.to_owned(),
 346       bio: None,
 347       local: true,
 348       bot_account: false,
 349       admin: false,
 350       private_key: None,
 351       public_key: "nada".to_owned(),
 352       last_refreshed_at: inserted_person.published,
 353       inbox_url: inserted_person.inbox_url.to_owned(),
 354       shared_inbox_url: None,
 355       matrix_user_id: None,
 356       ban_expires: None,
 357     };
 358
 359     let read_person = Person::read(&conn, inserted_person.id).unwrap();
 360     let updated_person = Person::update(&conn, inserted_person.id, &new_person).unwrap();
 361     let num_deleted = Person::delete(&conn, inserted_person.id).unwrap();
 362
 363     assert_eq!(expected_person, read_person);
 364     assert_eq!(expected_person, inserted_person);
 365     assert_eq!(expected_person, updated_person);
 366     assert_eq!(1, num_deleted);
 367   }
 368 }