4 newtypes::{DbUrl, PersonId},
5 schema::person::dsl::*,
6 source::person::{Person, PersonForm, PersonSafe},
7 traits::{ApubActor, Crud},
16 TextExpressionMethods,
20 use crate::{schema::person::columns::*, source::person::Person, traits::ToSafe};
43 impl ToSafe for Person {
44 type SafeColumns = Columns;
45 fn safe_columns_tuple() -> Self::SafeColumns {
70 mod safe_type_alias_1 {
71 use crate::{schema::person_alias_1::columns::*, source::person::PersonAlias1, traits::ToSafe};
94 impl ToSafe for PersonAlias1 {
95 type SafeColumns = Columns;
96 fn safe_columns_tuple() -> Self::SafeColumns {
121 mod safe_type_alias_2 {
122 use crate::{schema::person_alias_2::columns::*, source::person::PersonAlias2, traits::ToSafe};
145 impl ToSafe for PersonAlias2 {
146 type SafeColumns = Columns;
147 fn safe_columns_tuple() -> Self::SafeColumns {
172 impl Crud for Person {
173 type Form = PersonForm;
174 type IdType = PersonId;
175 fn read(conn: &PgConnection, person_id: PersonId) -> Result<Self, Error> {
177 .filter(deleted.eq(false))
181 fn delete(conn: &PgConnection, person_id: PersonId) -> Result<usize, Error> {
182 diesel::delete(person.find(person_id)).execute(conn)
184 fn create(conn: &PgConnection, form: &PersonForm) -> Result<Self, Error> {
185 insert_into(person).values(form).get_result::<Self>(conn)
187 fn update(conn: &PgConnection, person_id: PersonId, form: &PersonForm) -> Result<Self, Error> {
188 diesel::update(person.find(person_id))
190 .get_result::<Self>(conn)
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)
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)
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)
218 pub fn delete_account(conn: &PgConnection, person_id: PersonId) -> Result<Person, Error> {
219 use crate::schema::local_user;
221 // Set the local user info to none
222 diesel::update(local_user::table.filter(local_user::person_id.eq(person_id)))
224 local_user::email.eq::<Option<String>>(None),
225 local_user::validator_time.eq(naive_now()),
229 diesel::update(person.find(person_id))
231 display_name.eq::<Option<String>>(None),
232 bio.eq::<Option<String>>(None),
233 matrix_user_id.eq::<Option<String>>(None),
235 updated.eq(naive_now()),
237 .get_result::<Self>(conn)
240 pub fn upsert(conn: &PgConnection, person_form: &PersonForm) -> Result<Person, Error> {
243 .on_conflict(actor_id)
246 .get_result::<Self>(conn)
249 pub fn update_deleted(
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)
260 pub fn is_banned(&self) -> bool {
261 is_banned(self.banned, self.ban_expires)
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)
272 pub fn is_banned(&self) -> bool {
273 is_banned(self.banned, self.ban_expires)
277 fn is_banned(banned_: bool, expires: Option<chrono::NaiveDateTime>) -> bool {
278 if let Some(expires) = expires {
279 banned_ && expires.gt(&naive_now())
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::*;
290 .filter(deleted.eq(false))
291 .filter(actor_id.eq(object_id))
292 .first::<Person>(conn)
298 fn read_from_name(conn: &PgConnection, from_name: &str) -> Result<Person, Error> {
300 .filter(deleted.eq(false))
301 .filter(local.eq(true))
302 .filter(lower(name).eq(lower(from_name)))
303 .first::<Person>(conn)
306 fn read_from_name_and_domain(
309 protocol_domain: &str,
310 ) -> Result<Person, Error> {
311 use crate::schema::person::dsl::*;
313 .filter(lower(name).eq(lower(person_name)))
314 .filter(actor_id.like(format!("{}%", protocol_domain)))
321 use crate::{establish_unpooled_connection, source::person::*, traits::Crud};
325 let conn = establish_unpooled_connection();
327 let new_person = PersonForm {
328 name: "holly".into(),
329 public_key: "nada".to_owned(),
330 ..PersonForm::default()
333 let inserted_person = Person::create(&conn, &new_person).unwrap();
335 let expected_person = Person {
336 id: inserted_person.id,
337 name: "holly".into(),
343 published: inserted_person.published,
345 actor_id: inserted_person.actor_id.to_owned(),
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,
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();
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);