2 newtypes::{DbUrl, PersonId},
3 schema::person::dsl::*,
4 source::person::{Person, PersonForm},
5 traits::{ApubActor, Crud},
6 utils::{functions::lower, naive_now},
15 TextExpressionMethods,
19 use crate::{schema::person::columns::*, source::person::Person, traits::ToSafe};
42 impl ToSafe for Person {
43 type SafeColumns = Columns;
44 fn safe_columns_tuple() -> Self::SafeColumns {
69 mod safe_type_alias_1 {
70 use crate::{schema::person_alias_1::columns::*, source::person::PersonAlias1, traits::ToSafe};
93 impl ToSafe for PersonAlias1 {
94 type SafeColumns = Columns;
95 fn safe_columns_tuple() -> Self::SafeColumns {
120 mod safe_type_alias_2 {
121 use crate::{schema::person_alias_2::columns::*, source::person::PersonAlias2, traits::ToSafe};
144 impl ToSafe for PersonAlias2 {
145 type SafeColumns = Columns;
146 fn safe_columns_tuple() -> Self::SafeColumns {
171 impl Crud for Person {
172 type Form = PersonForm;
173 type IdType = PersonId;
174 fn read(conn: &PgConnection, person_id: PersonId) -> Result<Self, Error> {
176 .filter(deleted.eq(false))
180 fn delete(conn: &PgConnection, person_id: PersonId) -> Result<usize, Error> {
181 diesel::delete(person.find(person_id)).execute(conn)
183 fn create(conn: &PgConnection, form: &PersonForm) -> Result<Self, Error> {
184 insert_into(person).values(form).get_result::<Self>(conn)
186 fn update(conn: &PgConnection, person_id: PersonId, form: &PersonForm) -> Result<Self, Error> {
187 diesel::update(person.find(person_id))
189 .get_result::<Self>(conn)
198 expires: Option<chrono::NaiveDateTime>,
199 ) -> Result<Self, Error> {
200 diesel::update(person.find(person_id))
201 .set((banned.eq(ban), ban_expires.eq(expires)))
202 .get_result::<Self>(conn)
205 pub fn add_admin(conn: &PgConnection, person_id: PersonId, added: bool) -> Result<Self, Error> {
206 diesel::update(person.find(person_id))
207 .set(admin.eq(added))
208 .get_result::<Self>(conn)
211 pub fn mark_as_updated(conn: &PgConnection, person_id: PersonId) -> Result<Person, Error> {
212 diesel::update(person.find(person_id))
213 .set((last_refreshed_at.eq(naive_now()),))
214 .get_result::<Self>(conn)
217 pub fn delete_account(conn: &PgConnection, person_id: PersonId) -> Result<Person, Error> {
218 use crate::schema::local_user;
220 // Set the local user info to none
221 diesel::update(local_user::table.filter(local_user::person_id.eq(person_id)))
223 local_user::email.eq::<Option<String>>(None),
224 local_user::validator_time.eq(naive_now()),
228 diesel::update(person.find(person_id))
230 display_name.eq::<Option<String>>(None),
231 avatar.eq::<Option<String>>(None),
232 banner.eq::<Option<String>>(None),
233 bio.eq::<Option<String>>(None),
234 matrix_user_id.eq::<Option<String>>(None),
236 updated.eq(naive_now()),
238 .get_result::<Self>(conn)
241 pub fn upsert(conn: &PgConnection, person_form: &PersonForm) -> Result<Person, Error> {
244 .on_conflict(actor_id)
247 .get_result::<Self>(conn)
250 pub fn update_deleted(
254 ) -> Result<Person, Error> {
255 use crate::schema::person::dsl::*;
256 diesel::update(person.find(person_id))
257 .set(deleted.eq(new_deleted))
258 .get_result::<Self>(conn)
261 pub fn leave_admin(conn: &PgConnection, person_id: PersonId) -> Result<Self, Error> {
262 diesel::update(person.find(person_id))
263 .set(admin.eq(false))
264 .get_result::<Self>(conn)
267 pub fn remove_avatar_and_banner(conn: &PgConnection, person_id: PersonId) -> Result<Self, Error> {
268 diesel::update(person.find(person_id))
270 avatar.eq::<Option<String>>(None),
271 banner.eq::<Option<String>>(None),
273 .get_result::<Self>(conn)
277 pub 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)
301 include_deleted: bool,
302 ) -> Result<Person, Error> {
305 .filter(local.eq(true))
306 .filter(lower(name).eq(lower(from_name)));
307 if !include_deleted {
308 q = q.filter(deleted.eq(false))
310 q.first::<Self>(conn)
313 fn read_from_name_and_domain(
316 protocol_domain: &str,
317 ) -> Result<Person, Error> {
318 use crate::schema::person::dsl::*;
320 .filter(lower(name).eq(lower(person_name)))
321 .filter(actor_id.like(format!("{}%", protocol_domain)))
328 use crate::{source::person::*, traits::Crud, utils::establish_unpooled_connection};
332 let conn = establish_unpooled_connection();
334 let new_person = PersonForm {
335 name: "holly".into(),
336 public_key: Some("nada".to_owned()),
337 ..PersonForm::default()
340 let inserted_person = Person::create(&conn, &new_person).unwrap();
342 let expected_person = Person {
343 id: inserted_person.id,
344 name: "holly".into(),
350 published: inserted_person.published,
352 actor_id: inserted_person.actor_id.to_owned(),
358 public_key: "nada".to_owned(),
359 last_refreshed_at: inserted_person.published,
360 inbox_url: inserted_person.inbox_url.to_owned(),
361 shared_inbox_url: None,
362 matrix_user_id: None,
366 let read_person = Person::read(&conn, inserted_person.id).unwrap();
367 let updated_person = Person::update(&conn, inserted_person.id, &new_person).unwrap();
368 let num_deleted = Person::delete(&conn, inserted_person.id).unwrap();
370 assert_eq!(expected_person, read_person);
371 assert_eq!(expected_person, inserted_person);
372 assert_eq!(expected_person, updated_person);
373 assert_eq!(1, num_deleted);