2 newtypes::{DbUrl, PersonId},
16 source::person::{Person, PersonInsertForm, PersonUpdateForm},
17 traits::{ApubActor, Crud},
18 utils::{functions::lower, get_conn, naive_now, DbPool},
20 use diesel::{dsl::insert_into, result::Error, ExpressionMethods, QueryDsl, TextExpressionMethods};
21 use diesel_async::RunQueryDsl;
25 schema::person::columns::{
46 source::person::Person,
72 impl ToSafe for Person {
73 type SafeColumns = Columns;
74 fn safe_columns_tuple() -> Self::SafeColumns {
101 impl Crud for Person {
102 type InsertForm = PersonInsertForm;
103 type UpdateForm = PersonUpdateForm;
104 type IdType = PersonId;
105 async fn read(pool: &DbPool, person_id: PersonId) -> Result<Self, Error> {
106 let conn = &mut get_conn(pool).await?;
108 .filter(deleted.eq(false))
113 async fn delete(pool: &DbPool, person_id: PersonId) -> Result<usize, Error> {
114 let conn = &mut get_conn(pool).await?;
115 diesel::delete(person.find(person_id)).execute(conn).await
117 async fn create(pool: &DbPool, form: &PersonInsertForm) -> Result<Self, Error> {
118 let conn = &mut get_conn(pool).await?;
121 .on_conflict(actor_id)
124 .get_result::<Self>(conn)
130 form: &PersonUpdateForm,
131 ) -> Result<Self, Error> {
132 let conn = &mut get_conn(pool).await?;
133 diesel::update(person.find(person_id))
135 .get_result::<Self>(conn)
141 pub async fn delete_account(pool: &DbPool, person_id: PersonId) -> Result<Person, Error> {
142 use crate::schema::local_user;
143 let conn = &mut get_conn(pool).await?;
145 // Set the local user info to none
146 diesel::update(local_user::table.filter(local_user::person_id.eq(person_id)))
148 local_user::email.eq::<Option<String>>(None),
149 local_user::validator_time.eq(naive_now()),
154 diesel::update(person.find(person_id))
156 display_name.eq::<Option<String>>(None),
157 avatar.eq::<Option<String>>(None),
158 banner.eq::<Option<String>>(None),
159 bio.eq::<Option<String>>(None),
160 matrix_user_id.eq::<Option<String>>(None),
162 updated.eq(naive_now()),
164 .get_result::<Self>(conn)
169 pub fn is_banned(banned_: bool, expires: Option<chrono::NaiveDateTime>) -> bool {
170 if let Some(expires) = expires {
171 banned_ && expires.gt(&naive_now())
178 impl ApubActor for Person {
179 async fn read_from_apub_id(pool: &DbPool, object_id: &DbUrl) -> Result<Option<Self>, Error> {
180 let conn = &mut get_conn(pool).await?;
183 .filter(deleted.eq(false))
184 .filter(actor_id.eq(object_id))
185 .first::<Person>(conn)
192 async fn read_from_name(
195 include_deleted: bool,
196 ) -> Result<Person, Error> {
197 let conn = &mut get_conn(pool).await?;
200 .filter(local.eq(true))
201 .filter(lower(name).eq(lower(from_name)));
202 if !include_deleted {
203 q = q.filter(deleted.eq(false))
205 q.first::<Self>(conn).await
208 async fn read_from_name_and_domain(
211 protocol_domain: &str,
212 ) -> Result<Person, Error> {
213 let conn = &mut get_conn(pool).await?;
215 .filter(lower(name).eq(lower(person_name)))
216 .filter(actor_id.like(format!("{}%", protocol_domain)))
227 person::{Person, PersonInsertForm, PersonUpdateForm},
230 utils::build_db_pool_for_tests,
232 use serial_test::serial;
236 async fn test_crud() {
237 let pool = &build_db_pool_for_tests().await;
239 let inserted_instance = Instance::create(pool, "my_domain.tld").await.unwrap();
241 let new_person = PersonInsertForm::builder()
242 .name("holly".into())
243 .public_key("nada".to_owned())
244 .instance_id(inserted_instance.id)
247 let inserted_person = Person::create(pool, &new_person).await.unwrap();
249 let expected_person = Person {
250 id: inserted_person.id,
251 name: "holly".into(),
257 published: inserted_person.published,
259 actor_id: inserted_person.actor_id.clone(),
265 public_key: "nada".to_owned(),
266 last_refreshed_at: inserted_person.published,
267 inbox_url: inserted_person.inbox_url.clone(),
268 shared_inbox_url: None,
269 matrix_user_id: None,
271 instance_id: inserted_instance.id,
274 let read_person = Person::read(pool, inserted_person.id).await.unwrap();
276 let update_person_form = PersonUpdateForm::builder()
277 .actor_id(Some(inserted_person.actor_id.clone()))
279 let updated_person = Person::update(pool, inserted_person.id, &update_person_form)
283 let num_deleted = Person::delete(pool, inserted_person.id).await.unwrap();
284 Instance::delete(pool, inserted_instance.id).await.unwrap();
286 assert_eq!(expected_person, read_person);
287 assert_eq!(expected_person, inserted_person);
288 assert_eq!(expected_person, updated_person);
289 assert_eq!(1, num_deleted);