Moving settings to Database. (#2492)

[lemmy.git] / crates / apub / src / objects / person.rs

diff --git a/crates/apub/src/objects/person.rs b/crates/apub/src/objects/person.rs
index b1a892a321244ee9788ea732b98f5977e00eef62..e496da075229511fb128467400246c06db1134a5 100644 (file)
--- a/crates/apub/src/objects/person.rs
+++ b/crates/apub/src/objects/person.rs
@@ -1,5 +1,6 @@
 use crate::{
   check_apub_id_valid_with_strictness,
+  fetch_local_site_data,
   generate_outbox_url,
   objects::{instance::fetch_instance_actor_for_object, read_from_string_or_source_opt},
   protocol::{
@@ -18,10 +19,13 @@ use activitypub_federation::{
   utils::verify_domains_match,
 };
 use chrono::NaiveDateTime;
-use lemmy_api_common::utils::blocking;
+use lemmy_api_common::utils::{blocking, local_site_opt_to_slur_regex};
 use lemmy_db_schema::{
-  source::person::{Person as DbPerson, PersonForm},
-  traits::ApubActor,
+  source::{
+    instance::Instance,
+    person::{Person as DbPerson, PersonInsertForm, PersonUpdateForm},
+  },
+  traits::{ApubActor, Crud},
   utils::naive_now,
 };
 use lemmy_utils::{
@@ -76,7 +80,8 @@ impl ApubObject for ApubPerson {
   #[tracing::instrument(skip_all)]
   async fn delete(self, context: &LemmyContext) -> Result<(), LemmyError> {
     blocking(context.pool(), move |conn| {
-      DbPerson::update_deleted(conn, self.id, true)
+      let form = PersonUpdateForm::builder().deleted(Some(true)).build();
+      DbPerson::update(conn, self.id, &form)
     })
     .await??;
     Ok(())
@@ -119,12 +124,20 @@ impl ApubObject for ApubPerson {
     context: &LemmyContext,
     _request_counter: &mut i32,
   ) -> Result<(), LemmyError> {
-    verify_domains_match(person.id.inner(), expected_domain)?;
-    check_apub_id_valid_with_strictness(person.id.inner(), false, context.settings())?;
+    let local_site_data = blocking(context.pool(), fetch_local_site_data).await??;
+    let slur_regex = &local_site_opt_to_slur_regex(&local_site_data.local_site);
 
-    let slur_regex = &context.settings().slur_regex();
     check_slurs(&person.preferred_username, slur_regex)?;
     check_slurs_opt(&person.name, slur_regex)?;
+
+    verify_domains_match(person.id.inner(), expected_domain)?;
+    check_apub_id_valid_with_strictness(
+      person.id.inner(),
+      false,
+      &local_site_data,
+      context.settings(),
+    )?;
+
     let bio = read_from_string_or_source_opt(&person.summary, &None, &person.source);
     check_slurs_opt(&bio, slur_regex)?;
     Ok(())
@@ -136,34 +149,37 @@ impl ApubObject for ApubPerson {
     context: &LemmyContext,
     request_counter: &mut i32,
   ) -> Result<ApubPerson, LemmyError> {
-    let person_form = PersonForm {
+    let apub_id = person.id.inner().to_owned();
+    let instance = blocking(context.pool(), move |conn| {
+      Instance::create_from_actor_id(conn, &apub_id)
+    })
+    .await??;
+
+    let person_form = PersonInsertForm {
       name: person.preferred_username,
-      display_name: Some(person.name),
+      display_name: person.name,
       banned: None,
       ban_expires: None,
       deleted: None,
-      avatar: Some(person.icon.map(|i| i.url.into())),
-      banner: Some(person.image.map(|i| i.url.into())),
+      avatar: person.icon.map(|i| i.url.into()),
+      banner: person.image.map(|i| i.url.into()),
       published: person.published.map(|u| u.naive_local()),
       updated: person.updated.map(|u| u.naive_local()),
       actor_id: Some(person.id.into()),
-      bio: Some(read_from_string_or_source_opt(
-        &person.summary,
-        &None,
-        &person.source,
-      )),
+      bio: read_from_string_or_source_opt(&person.summary, &None, &person.source),
       local: Some(false),
       admin: Some(false),
       bot_account: Some(person.kind == UserTypes::Service),
       private_key: None,
-      public_key: Some(person.public_key.public_key_pem),
+      public_key: person.public_key.public_key_pem,
       last_refreshed_at: Some(naive_now()),
       inbox_url: Some(person.inbox.into()),
-      shared_inbox_url: Some(person.endpoints.map(|e| e.shared_inbox.into())),
-      matrix_user_id: Some(person.matrix_user_id),
+      shared_inbox_url: person.endpoints.map(|e| e.shared_inbox.into()),
+      matrix_user_id: person.matrix_user_id,
+      instance_id: instance.id,
     };
     let person = blocking(context.pool(), move |conn| {
-      DbPerson::upsert(conn, &person_form)
+      DbPerson::create(conn, &person_form)
     })
     .await??;
 
@@ -230,22 +246,19 @@ pub(crate) mod tests {
   #[serial]
   async fn test_parse_lemmy_person() {
     let context = init_context();
-    let conn = &mut context.pool().get().unwrap();
     let (person, site) = parse_lemmy_person(&context).await;
 
     assert_eq!(person.display_name, Some("Jean-Luc Picard".to_string()));
     assert!(!person.local);
     assert_eq!(person.bio.as_ref().unwrap().len(), 39);
 
-    DbPerson::delete(conn, person.id).unwrap();
-    Site::delete(conn, site.id).unwrap();
+    cleanup((person, site), &context);
   }
 
   #[actix_rt::test]
   #[serial]
   async fn test_parse_pleroma_person() {
     let context = init_context();
-    let conn = &mut context.pool().get().unwrap();
 
     // create and parse a fake pleroma instance actor, to avoid network request during test
     let mut json: Instance = file_to_json_object("assets/lemmy/objects/instance.json").unwrap();
@@ -272,7 +285,12 @@ pub(crate) mod tests {
     assert_eq!(request_counter, 0);
     assert_eq!(person.bio.as_ref().unwrap().len(), 873);
 
-    DbPerson::delete(conn, person.id).unwrap();
-    Site::delete(conn, site.id).unwrap();
+    cleanup((person, site), &context);
+  }
+
+  fn cleanup(data: (ApubPerson, ApubSite), context: &LemmyContext) {
+    let conn = &mut context.pool().get().unwrap();
+    DbPerson::delete(conn, data.0.id).unwrap();
+    Site::delete(conn, data.1.id).unwrap();
   }
 }