Merge branch 'move_blocklist_to_db' into diesel_async_1

crates/api/src/lib.rs

@@ -7,14 +7,11 @@ use lemmy_api_common::{
   post::*,
   private_message::*,
   site::*,
+  utils::local_site_to_slur_regex,
   websocket::*,
 };
 use lemmy_db_schema::source::local_site::LocalSite;
-use lemmy_utils::{
-  error::LemmyError,
-  utils::{check_slurs, slur_regex},
-  ConnectionId,
-};
+use lemmy_utils::{error::LemmyError, utils::check_slurs, ConnectionId};
 use lemmy_websocket::{serialize_websocket_message, LemmyContext, UserOperation};
 use serde::Deserialize;
 
@@ -233,7 +230,7 @@ pub(crate) fn captcha_as_wav_base64(captcha: &Captcha) -> String {
 
 /// Check size of report and remove whitespace
 pub(crate) fn check_report_reason(reason: &str, local_site: &LocalSite) -> Result<(), LemmyError> {
-  let slur_regex = &slur_regex(local_site.slur_filter_regex.as_deref());
+  let slur_regex = &local_site_to_slur_regex(local_site);
 
   check_slurs(reason, slur_regex)?;
   if reason.is_empty() {

crates/api_common/src/utils.rs

@@ -36,7 +36,7 @@ use lemmy_utils::{
   error::LemmyError,
   rate_limit::RateLimitConfig,
   settings::structs::Settings,
-  utils::{generate_random_string, slur_regex},
+  utils::{build_slur_regex, generate_random_string},
 };
 use regex::Regex;
 use reqwest_middleware::ClientWithMiddleware;
@@ -435,7 +435,14 @@ pub fn local_site_rate_limit_to_rate_limit_config(
 }
 
 pub fn local_site_to_slur_regex(local_site: &LocalSite) -> Option<Regex> {
-  slur_regex(local_site.slur_filter_regex.as_deref())
+  build_slur_regex(local_site.slur_filter_regex.as_deref())
+}
+
+pub fn local_site_opt_to_slur_regex(local_site: &Option<LocalSite>) -> Option<Regex> {
+  local_site
+    .as_ref()
+    .map(local_site_to_slur_regex)
+    .unwrap_or(None)
 }
 
 pub fn send_application_approved_email(

crates/apub/src/activities/block/block_user.rs

@@ -9,6 +9,8 @@ use crate::{
     verify_person_in_community,
   },
   activity_lists::AnnouncableActivities,
+  check_apub_id_valid,
+  fetch_local_site_data,
   local_instance,
   objects::{community::ApubCommunity, instance::remote_instance_inboxes, person::ApubPerson},
   protocol::activities::block::block_user::BlockUser,
@@ -123,6 +125,10 @@ impl ActivityHandler for BlockUser {
     context: &Data<LemmyContext>,
     request_counter: &mut i32,
   ) -> Result<(), LemmyError> {
+    let local_site_data = fetch_local_site_data(context.pool()).await?;
+    check_apub_id_valid(self.id(), &local_site_data, context.settings())
+      .map_err(LemmyError::from_message)?;
+
     verify_is_public(&self.to, &self.cc)?;
     match self
       .target

crates/apub/src/activities/block/undo_block_user.rs

@@ -7,6 +7,8 @@ use crate::{
     verify_is_public,
   },
   activity_lists::AnnouncableActivities,
+  check_apub_id_valid,
+  fetch_local_site_data,
   local_instance,
   objects::{community::ApubCommunity, instance::remote_instance_inboxes, person::ApubPerson},
   protocol::activities::block::{block_user::BlockUser, undo_block_user::UndoBlockUser},
@@ -89,6 +91,10 @@ impl ActivityHandler for UndoBlockUser {
     context: &Data<LemmyContext>,
     request_counter: &mut i32,
   ) -> Result<(), LemmyError> {
+    let local_site_data = fetch_local_site_data(context.pool()).await?;
+    check_apub_id_valid(self.id(), &local_site_data, context.settings())
+      .map_err(LemmyError::from_message)?;
+
     verify_is_public(&self.to, &self.cc)?;
     verify_domains_match(self.actor.inner(), self.object.actor.inner())?;
     self.object.verify(context, request_counter).await?;

crates/apub/src/activities/community/add_mod.rs

@@ -12,6 +12,8 @@ use crate::{
     verify_person_in_community,
   },
   activity_lists::AnnouncableActivities,
+  check_apub_id_valid,
+  fetch_local_site_data,
   generate_moderators_url,
   local_instance,
   objects::{community::ApubCommunity, person::ApubPerson},
@@ -83,6 +85,10 @@ impl ActivityHandler for AddMod {
     context: &Data<LemmyContext>,
     request_counter: &mut i32,
   ) -> Result<(), LemmyError> {
+    let local_site_data = fetch_local_site_data(context.pool()).await?;
+    check_apub_id_valid(self.id(), &local_site_data, context.settings())
+      .map_err(LemmyError::from_message)?;
+
     verify_is_public(&self.to, &self.cc)?;
     let community = self.get_community(context, request_counter).await?;
     verify_person_in_community(&self.actor, &community, context, request_counter).await?;

crates/apub/src/activities/community/announce.rs

@@ -1,6 +1,8 @@
 use crate::{
   activities::{generate_activity_id, send_lemmy_activity, verify_is_public},
   activity_lists::AnnouncableActivities,
+  check_apub_id_valid,
+  fetch_local_site_data,
   insert_activity,
   objects::community::ApubCommunity,
   protocol::{
@@ -84,9 +86,13 @@ impl ActivityHandler for AnnounceActivity {
   #[tracing::instrument(skip_all)]
   async fn verify(
     &self,
-    _context: &Data<LemmyContext>,
+    context: &Data<LemmyContext>,
     _request_counter: &mut i32,
   ) -> Result<(), LemmyError> {
+    let local_site_data = fetch_local_site_data(context.pool()).await?;
+    check_apub_id_valid(self.id(), &local_site_data, context.settings())
+      .map_err(LemmyError::from_message)?;
+
     verify_is_public(&self.to, &self.cc)?;
     Ok(())
   }

crates/apub/src/activities/community/remove_mod.rs

@@ -12,6 +12,8 @@ use crate::{
     verify_person_in_community,
   },
   activity_lists::AnnouncableActivities,
+  check_apub_id_valid,
+  fetch_local_site_data,
   generate_moderators_url,
   local_instance,
   objects::{community::ApubCommunity, person::ApubPerson},
@@ -83,6 +85,10 @@ impl ActivityHandler for RemoveMod {
     context: &Data<LemmyContext>,
     request_counter: &mut i32,
   ) -> Result<(), LemmyError> {
+    let local_site_data = fetch_local_site_data(context.pool()).await?;
+    check_apub_id_valid(self.id(), &local_site_data, context.settings())
+      .map_err(LemmyError::from_message)?;
+
     verify_is_public(&self.to, &self.cc)?;
     let community = self.get_community(context, request_counter).await?;
     verify_person_in_community(&self.actor, &community, context, request_counter).await?;

crates/apub/src/activities/community/report.rs

@@ -1,5 +1,7 @@
 use crate::{
   activities::{generate_activity_id, send_lemmy_activity, verify_person_in_community},
+  check_apub_id_valid,
+  fetch_local_site_data,
   local_instance,
   objects::{community::ApubCommunity, person::ApubPerson},
   protocol::activities::community::report::Report,
@@ -74,6 +76,10 @@ impl ActivityHandler for Report {
     context: &Data<LemmyContext>,
     request_counter: &mut i32,
   ) -> Result<(), LemmyError> {
+    let local_site_data = fetch_local_site_data(context.pool()).await?;
+    check_apub_id_valid(self.id(), &local_site_data, context.settings())
+      .map_err(LemmyError::from_message)?;
+
     let community = self.to[0]
       .dereference(context, local_instance(context).await, request_counter)
       .await?;

crates/apub/src/activities/community/update.rs

@@ -7,6 +7,8 @@ use crate::{
     verify_person_in_community,
   },
   activity_lists::AnnouncableActivities,
+  check_apub_id_valid,
+  fetch_local_site_data,
   local_instance,
   objects::{community::ApubCommunity, person::ApubPerson},
   protocol::activities::community::update::UpdateCommunity,
@@ -68,6 +70,9 @@ impl ActivityHandler for UpdateCommunity {
     context: &Data<LemmyContext>,
     request_counter: &mut i32,
   ) -> Result<(), LemmyError> {
+    let local_site_data = fetch_local_site_data(context.pool()).await?;
+    check_apub_id_valid(self.id(), &local_site_data, context.settings())
+      .map_err(LemmyError::from_message)?;
     verify_is_public(&self.to, &self.cc)?;
     let community = self.get_community(context, request_counter).await?;
     verify_person_in_community(&self.actor, &community, context, request_counter).await?;

crates/apub/src/activities/create_or_update/comment.rs

@@ -8,6 +8,8 @@ use crate::{
     verify_person_in_community,
   },
   activity_lists::AnnouncableActivities,
+  check_apub_id_valid,
+  fetch_local_site_data,
   local_instance,
   mentions::MentionOrValue,
   objects::{comment::ApubComment, community::ApubCommunity, person::ApubPerson},
@@ -111,6 +113,10 @@ impl ActivityHandler for CreateOrUpdateComment {
     context: &Data<LemmyContext>,
     request_counter: &mut i32,
   ) -> Result<(), LemmyError> {
+    let local_site_data = fetch_local_site_data(context.pool()).await?;
+    check_apub_id_valid(self.id(), &local_site_data, context.settings())
+      .map_err(LemmyError::from_message)?;
+
     verify_is_public(&self.to, &self.cc)?;
     let post = self.object.get_parents(context, request_counter).await?.0;
     let community = self.get_community(context, request_counter).await?;

crates/apub/src/activities/create_or_update/post.rs

@@ -8,6 +8,8 @@ use crate::{
     verify_person_in_community,
   },
   activity_lists::AnnouncableActivities,
+  check_apub_id_valid,
+  fetch_local_site_data,
   objects::{community::ApubCommunity, person::ApubPerson, post::ApubPost},
   protocol::activities::{create_or_update::post::CreateOrUpdatePost, CreateOrUpdateType},
   ActorType,
@@ -88,6 +90,9 @@ impl ActivityHandler for CreateOrUpdatePost {
     context: &Data<LemmyContext>,
     request_counter: &mut i32,
   ) -> Result<(), LemmyError> {
+    let local_site_data = fetch_local_site_data(context.pool()).await?;
+    check_apub_id_valid(self.id(), &local_site_data, context.settings())
+      .map_err(LemmyError::from_message)?;
     verify_is_public(&self.to, &self.cc)?;
     let community = self.get_community(context, request_counter).await?;
     verify_person_in_community(&self.actor, &community, context, request_counter).await?;

crates/apub/src/activities/create_or_update/private_message.rs

@@ -1,5 +1,7 @@
 use crate::{
   activities::{generate_activity_id, send_lemmy_activity, verify_person},
+  check_apub_id_valid,
+  fetch_local_site_data,
   objects::{person::ApubPerson, private_message::ApubPrivateMessage},
   protocol::activities::{
     create_or_update::private_message::CreateOrUpdatePrivateMessage,
@@ -65,6 +67,10 @@ impl ActivityHandler for CreateOrUpdatePrivateMessage {
     context: &Data<LemmyContext>,
     request_counter: &mut i32,
   ) -> Result<(), LemmyError> {
+    let local_site_data = fetch_local_site_data(context.pool()).await?;
+    check_apub_id_valid(self.id(), &local_site_data, context.settings())
+      .map_err(LemmyError::from_message)?;
+
     verify_person(&self.actor, context, request_counter).await?;
     verify_domains_match(self.actor.inner(), self.object.id.inner())?;
     verify_domains_match(self.to[0].inner(), self.object.to[0].inner())?;

crates/apub/src/activities/deletion/delete.rs

@@ -4,6 +4,8 @@ use crate::{
     deletion::{receive_delete_action, verify_delete_activity, DeletableObjects},
     generate_activity_id,
   },
+  check_apub_id_valid,
+  fetch_local_site_data,
   local_instance,
   objects::{community::ApubCommunity, person::ApubPerson},
   protocol::{activities::deletion::delete::Delete, IdOrNestedObject},
@@ -54,6 +56,9 @@ impl ActivityHandler for Delete {
     context: &Data<LemmyContext>,
     request_counter: &mut i32,
   ) -> Result<(), LemmyError> {
+    let local_site_data = fetch_local_site_data(context.pool()).await?;
+    check_apub_id_valid(self.id(), &local_site_data, context.settings())
+      .map_err(LemmyError::from_message)?;
     verify_delete_activity(self, self.summary.is_some(), context, request_counter).await?;
     Ok(())
   }

crates/apub/src/activities/deletion/delete_user.rs

@@ -1,5 +1,7 @@
 use crate::{
   activities::{generate_activity_id, send_lemmy_activity, verify_is_public, verify_person},
+  check_apub_id_valid,
+  fetch_local_site_data,
   local_instance,
   objects::{instance::remote_instance_inboxes, person::ApubPerson},
   protocol::activities::deletion::delete_user::DeleteUser,
@@ -36,6 +38,9 @@ impl ActivityHandler for DeleteUser {
     context: &Data<LemmyContext>,
     request_counter: &mut i32,
   ) -> Result<(), LemmyError> {
+    let local_site_data = fetch_local_site_data(context.pool()).await?;
+    check_apub_id_valid(self.id(), &local_site_data, context.settings())
+      .map_err(LemmyError::from_message)?;
     verify_is_public(&self.to, &[])?;
     verify_person(&self.actor, context, request_counter).await?;
     verify_urls_match(self.actor.inner(), self.object.inner())?;

crates/apub/src/activities/deletion/undo_delete.rs

@@ -4,6 +4,8 @@ use crate::{
     deletion::{receive_delete_action, verify_delete_activity, DeletableObjects},
     generate_activity_id,
   },
+  check_apub_id_valid,
+  fetch_local_site_data,
   local_instance,
   objects::{community::ApubCommunity, person::ApubPerson},
   protocol::activities::deletion::{delete::Delete, undo_delete::UndoDelete},
@@ -53,6 +55,9 @@ impl ActivityHandler for UndoDelete {
     context: &Data<LemmyContext>,
     request_counter: &mut i32,
   ) -> Result<(), LemmyError> {
+    let local_site_data = fetch_local_site_data(context.pool()).await?;
+    check_apub_id_valid(self.id(), &local_site_data, context.settings())
+      .map_err(LemmyError::from_message)?;
     self.object.verify(context, request_counter).await?;
     verify_delete_activity(
       &self.object,

crates/apub/src/activities/following/accept.rs

@@ -1,5 +1,7 @@
 use crate::{
   activities::{generate_activity_id, send_lemmy_activity},
+  check_apub_id_valid,
+  fetch_local_site_data,
   local_instance,
   protocol::activities::following::{accept::AcceptFollowCommunity, follow::FollowCommunity},
   ActorType,
@@ -67,6 +69,10 @@ impl ActivityHandler for AcceptFollowCommunity {
     context: &Data<LemmyContext>,
     request_counter: &mut i32,
   ) -> Result<(), LemmyError> {
+    let local_site_data = fetch_local_site_data(context.pool()).await?;
+    check_apub_id_valid(self.id(), &local_site_data, context.settings())
+      .map_err(LemmyError::from_message)?;
+
     verify_urls_match(self.actor.inner(), self.object.object.inner())?;
     self.object.verify(context, request_counter).await?;
     Ok(())

crates/apub/src/activities/following/follow.rs

@@ -5,6 +5,8 @@ use crate::{
     verify_person,
     verify_person_in_community,
   },
+  check_apub_id_valid,
+  fetch_local_site_data,
   local_instance,
   objects::{community::ApubCommunity, person::ApubPerson},
   protocol::activities::following::{accept::AcceptFollowCommunity, follow::FollowCommunity},
@@ -82,6 +84,9 @@ impl ActivityHandler for FollowCommunity {
     context: &Data<LemmyContext>,
     request_counter: &mut i32,
   ) -> Result<(), LemmyError> {
+    let local_site_data = fetch_local_site_data(context.pool()).await?;
+    check_apub_id_valid(self.id(), &local_site_data, context.settings())
+      .map_err(LemmyError::from_message)?;
     verify_person(&self.actor, context, request_counter).await?;
     let community = self
       .object

crates/apub/src/activities/following/undo_follow.rs

@@ -1,5 +1,7 @@
 use crate::{
   activities::{generate_activity_id, send_lemmy_activity, verify_person},
+  check_apub_id_valid,
+  fetch_local_site_data,
   local_instance,
   objects::{community::ApubCommunity, person::ApubPerson},
   protocol::activities::following::{follow::FollowCommunity, undo_follow::UndoFollowCommunity},
@@ -62,6 +64,9 @@ impl ActivityHandler for UndoFollowCommunity {
     context: &Data<LemmyContext>,
     request_counter: &mut i32,
   ) -> Result<(), LemmyError> {
+    let local_site_data = fetch_local_site_data(context.pool()).await?;
+    check_apub_id_valid(self.id(), &local_site_data, context.settings())
+      .map_err(LemmyError::from_message)?;
     verify_urls_match(self.actor.inner(), self.object.actor.inner())?;
     verify_person(&self.actor, context, request_counter).await?;
     self.object.verify(context, request_counter).await?;

crates/apub/src/activities/voting/undo_vote.rs

@@ -6,6 +6,8 @@ use crate::{
     voting::{undo_vote_comment, undo_vote_post},
   },
   activity_lists::AnnouncableActivities,
+  check_apub_id_valid,
+  fetch_local_site_data,
   local_instance,
   objects::{community::ApubCommunity, person::ApubPerson},
   protocol::activities::voting::{
@@ -77,6 +79,9 @@ impl ActivityHandler for UndoVote {
     context: &Data<LemmyContext>,
     request_counter: &mut i32,
   ) -> Result<(), LemmyError> {
+    let local_site_data = fetch_local_site_data(context.pool()).await?;
+    check_apub_id_valid(self.id(), &local_site_data, context.settings())
+      .map_err(LemmyError::from_message)?;
     let community = self.get_community(context, request_counter).await?;
     verify_person_in_community(&self.actor, &community, context, request_counter).await?;
     verify_urls_match(self.actor.inner(), self.object.actor.inner())?;

crates/apub/src/activities/voting/vote.rs

@@ -6,6 +6,8 @@ use crate::{
     voting::{vote_comment, vote_post},
   },
   activity_lists::AnnouncableActivities,
+  check_apub_id_valid,
+  fetch_local_site_data,
   local_instance,
   objects::{community::ApubCommunity, person::ApubPerson},
   protocol::activities::voting::vote::{Vote, VoteType},
@@ -76,6 +78,9 @@ impl ActivityHandler for Vote {
     context: &Data<LemmyContext>,
     request_counter: &mut i32,
   ) -> Result<(), LemmyError> {
+    let local_site_data = fetch_local_site_data(context.pool()).await?;
+    check_apub_id_valid(self.id(), &local_site_data, context.settings())
+      .map_err(LemmyError::from_message)?;
     let community = self.get_community(context, request_counter).await?;
     verify_person_in_community(&self.actor, &community, context, request_counter).await?;
     let enable_downvotes = LocalSite::read(context.pool())

crates/apub/src/lib.rs

@@ -241,10 +241,6 @@ pub fn generate_shared_inbox_url(actor_id: &DbUrl) -> Result<DbUrl, LemmyError>
   Ok(Url::parse(&url)?.into())
 }
 
-pub fn generate_domain_url(actor_id: &Url) -> Result<String, LemmyError> {
-  Ok(actor_id.host_str().context(location_info!())?.to_string())
-}
-
 pub fn generate_outbox_url(actor_id: &DbUrl) -> Result<DbUrl, ParseError> {
   Ok(Url::parse(&format!("{}/outbox", actor_id))?.into())
 }

crates/apub/src/objects/comment.rs

@@ -19,6 +19,7 @@ use activitypub_federation::{
 };
 use activitystreams_kinds::{object::NoteType, public};
 use chrono::NaiveDateTime;
+use lemmy_api_common::utils::local_site_opt_to_slur_regex;
 use lemmy_db_schema::{
   source::{
     comment::{Comment, CommentInsertForm, CommentUpdateForm},
@@ -31,7 +32,7 @@ use lemmy_db_schema::{
 };
 use lemmy_utils::{
   error::LemmyError,
-  utils::{convert_datetime, markdown_to_html, remove_slurs, slur_regex},
+  utils::{convert_datetime, markdown_to_html, remove_slurs},
 };
 use lemmy_websocket::LemmyContext;
 use std::ops::Deref;
@@ -177,14 +178,8 @@ impl ApubObject for ApubComment {
 
     let content = read_from_string_or_source(&note.content, &note.media_type, &note.source);
 
-    let slur_regex = &slur_regex(
-      LocalSite::read(context.pool())
-        .await
-        .as_ref()
-        .map(|l| l.slur_filter_regex.as_deref())
-        .unwrap_or(None),
-    );
-
+    let local_site = LocalSite::read(context.pool()).await.ok();
+    let slur_regex = &local_site_opt_to_slur_regex(&local_site);
     let content_slurs_removed = remove_slurs(&content, slur_regex);
     let language_id = LanguageTag::to_language_id_single(note.language, context.pool()).await?;
 

crates/apub/src/objects/community.rs

@@ -2,7 +2,6 @@ use crate::{
   check_apub_id_valid_with_strictness,
   collections::{community_moderators::ApubCommunityModerators, CommunityContext},
   fetch_local_site_data,
-  generate_domain_url,
   generate_moderators_url,
   generate_outbox_url,
   local_instance,
@@ -136,8 +135,8 @@ impl ApubObject for ApubCommunity {
     context: &LemmyContext,
     request_counter: &mut i32,
   ) -> Result<ApubCommunity, LemmyError> {
-    let domain = generate_domain_url(group.id.inner())?;
-    let instance = Instance::create(context.pool(), &domain).await?;
+    let apub_id = group.id.inner().to_owned();
+    let instance = Instance::create_from_actor_id(context.pool(), &apub_id).await?;
 
     let form = Group::into_insert_form(group.clone(), instance.id);
     let languages = LanguageTag::to_language_id_multiple(group.language, context.pool()).await?;

crates/apub/src/objects/instance.rs

@@ -1,7 +1,6 @@
 use crate::{
   check_apub_id_valid_with_strictness,
   fetch_local_site_data,
-  generate_domain_url,
   local_instance,
   objects::read_from_string_or_source_opt,
   protocol::{
@@ -21,6 +20,7 @@ use activitypub_federation::{
   utils::verify_domains_match,
 };
 use chrono::NaiveDateTime;
+use lemmy_api_common::utils::local_site_opt_to_slur_regex;
 use lemmy_db_schema::{
   source::{
     actor_language::SiteLanguage,
@@ -32,7 +32,7 @@ use lemmy_db_schema::{
 };
 use lemmy_utils::{
   error::LemmyError,
-  utils::{check_slurs, check_slurs_opt, convert_datetime, markdown_to_html, slur_regex},
+  utils::{check_slurs, check_slurs_opt, convert_datetime, markdown_to_html},
 };
 use lemmy_websocket::LemmyContext;
 use std::ops::Deref;
@@ -120,13 +120,7 @@ impl ApubObject for ApubSite {
     check_apub_id_valid_with_strictness(apub.id.inner(), true, &local_site_data, data.settings())?;
     verify_domains_match(expected_domain, apub.id.inner())?;
 
-    let slur_regex = &slur_regex(
-      local_site_data
-        .local_site
-        .as_ref()
-        .map(|l| l.slur_filter_regex.as_deref())
-        .unwrap_or(None),
-    );
+    let slur_regex = &local_site_opt_to_slur_regex(&local_site_data.local_site);
 
     check_slurs(&apub.name, slur_regex)?;
     check_slurs_opt(&apub.summary, slur_regex)?;
@@ -139,8 +133,8 @@ impl ApubObject for ApubSite {
     data: &Self::DataType,
     _request_counter: &mut i32,
   ) -> Result<Self, LemmyError> {
-    let domain = generate_domain_url(apub.id.inner())?;
-    let instance = DbInstance::create(data.pool(), &domain).await?;
+    let apub_id = apub.id.inner().to_owned();
+    let instance = DbInstance::create_from_actor_id(data.pool(), &apub_id).await?;
 
     let site_form = SiteInsertForm {
       name: apub.name.clone(),

crates/apub/src/objects/person.rs

@@ -1,7 +1,6 @@
 use crate::{
   check_apub_id_valid_with_strictness,
   fetch_local_site_data,
-  generate_domain_url,
   generate_outbox_url,
   objects::{instance::fetch_instance_actor_for_object, read_from_string_or_source_opt},
   protocol::{
@@ -20,6 +19,7 @@ use activitypub_federation::{
   utils::verify_domains_match,
 };
 use chrono::NaiveDateTime;
+use lemmy_api_common::utils::local_site_opt_to_slur_regex;
 use lemmy_db_schema::{
   source::{
     instance::Instance,
@@ -30,7 +30,7 @@ use lemmy_db_schema::{
 };
 use lemmy_utils::{
   error::LemmyError,
-  utils::{check_slurs, check_slurs_opt, convert_datetime, markdown_to_html, slur_regex},
+  utils::{check_slurs, check_slurs_opt, convert_datetime, markdown_to_html},
 };
 use lemmy_websocket::LemmyContext;
 use std::ops::Deref;
@@ -120,13 +120,7 @@ impl ApubObject for ApubPerson {
     _request_counter: &mut i32,
   ) -> Result<(), LemmyError> {
     let local_site_data = fetch_local_site_data(context.pool()).await?;
-    let slur_regex = &slur_regex(
-      local_site_data
-        .local_site
-        .as_ref()
-        .map(|l| l.slur_filter_regex.as_deref())
-        .unwrap_or(None),
-    );
+    let slur_regex = &local_site_opt_to_slur_regex(&local_site_data.local_site);
 
     check_slurs(&person.preferred_username, slur_regex)?;
     check_slurs_opt(&person.name, slur_regex)?;
@@ -150,9 +144,8 @@ impl ApubObject for ApubPerson {
     context: &LemmyContext,
     request_counter: &mut i32,
   ) -> Result<ApubPerson, LemmyError> {
-    // TODO Maybe a better way to do this? Same for community and site from_apub
-    let domain = generate_domain_url(person.id.inner())?;
-    let instance = Instance::create(context.pool(), &domain).await?;
+    let apub_id = person.id.inner().to_owned();
+    let instance = Instance::create_from_actor_id(context.pool(), &apub_id).await?;
 
     let person_form = PersonInsertForm {
       name: person.preferred_username,

crates/apub/src/objects/post.rs

@@ -21,7 +21,7 @@ use activitypub_federation::{
 };
 use activitystreams_kinds::public;
 use chrono::NaiveDateTime;
-use lemmy_api_common::request::fetch_site_data;
+use lemmy_api_common::{request::fetch_site_data, utils::local_site_opt_to_slur_regex};
 use lemmy_db_schema::{
   self,
   source::{
@@ -35,7 +35,7 @@ use lemmy_db_schema::{
 };
 use lemmy_utils::{
   error::LemmyError,
-  utils::{check_slurs, convert_datetime, markdown_to_html, remove_slurs, slur_regex},
+  utils::{check_slurs, convert_datetime, markdown_to_html, remove_slurs},
 };
 use lemmy_websocket::LemmyContext;
 use std::ops::Deref;
@@ -146,13 +146,7 @@ impl ApubObject for ApubPost {
     )?;
     verify_person_in_community(&page.creator()?, &community, context, request_counter).await?;
 
-    let slur_regex = &slur_regex(
-      local_site_data
-        .local_site
-        .as_ref()
-        .map(|l| l.slur_filter_regex.as_deref())
-        .unwrap_or(None),
-    );
+    let slur_regex = &local_site_opt_to_slur_regex(&local_site_data.local_site);
     check_slurs(&page.name, slur_regex)?;
 
     verify_domains_match(page.creator()?.inner(), page.id.inner())?;
@@ -194,13 +188,8 @@ impl ApubObject for ApubPost {
       let (embed_title, embed_description, embed_video_url) = metadata_res
         .map(|u| (u.title, u.description, u.embed_video_url))
         .unwrap_or_default();
-      let slur_regex = &slur_regex(
-        LocalSite::read(context.pool())
-          .await
-          .as_ref()
-          .map(|l| l.slur_filter_regex.as_deref())
-          .unwrap_or(None),
-      );
+      let local_site = LocalSite::read(context.pool()).await.ok();
+      let slur_regex = &local_site_opt_to_slur_regex(&local_site);
 
       let body_slurs_removed =
         read_from_string_or_source_opt(&page.content, &page.media_type, &page.source)

crates/apub/src/protocol/objects/group.rs

@@ -19,6 +19,7 @@ use activitypub_federation::{
 };
 use activitystreams_kinds::actor::GroupType;
 use chrono::{DateTime, FixedOffset};
+use lemmy_api_common::utils::local_site_opt_to_slur_regex;
 use lemmy_db_schema::{
   newtypes::InstanceId,
   source::community::{CommunityInsertForm, CommunityUpdateForm},
@@ -26,7 +27,7 @@ use lemmy_db_schema::{
 };
 use lemmy_utils::{
   error::LemmyError,
-  utils::{check_slurs, check_slurs_opt, slur_regex},
+  utils::{check_slurs, check_slurs_opt},
 };
 use lemmy_websocket::LemmyContext;
 use serde::{Deserialize, Serialize};
@@ -84,13 +85,7 @@ impl Group {
     )?;
     verify_domains_match(expected_domain, self.id.inner())?;
 
-    let slur_regex = &slur_regex(
-      local_site_data
-        .local_site
-        .as_ref()
-        .map(|l| l.slur_filter_regex.as_deref())
-        .unwrap_or(None),
-    );
+    let slur_regex = &local_site_opt_to_slur_regex(&local_site_data.local_site);
 
     check_slurs(&self.preferred_username, slur_regex)?;
     check_slurs_opt(&self.name, slur_regex)?;

crates/db_schema/src/impls/instance.rs

@@ -6,6 +6,8 @@ use crate::{
 };
 use diesel::{dsl::*, result::Error, ExpressionMethods, QueryDsl};
 use diesel_async::{AsyncPgConnection, RunQueryDsl};
+use lemmy_utils::utils::generate_domain_url;
+use url::Url;
 
 impl Instance {
   async fn create_from_form_conn(
@@ -25,6 +27,10 @@ impl Instance {
     let conn = &mut get_conn(pool).await?;
     Self::create_conn(conn, domain).await
   }
+  pub async fn create_from_actor_id(pool: &DbPool, actor_id: &Url) -> Result<Self, Error> {
+    let domain = &generate_domain_url(actor_id).expect("actor id missing a domain");
+    Self::create(pool, domain).await
+  }
   pub async fn create_conn(conn: &mut AsyncPgConnection, domain: &str) -> Result<Self, Error> {
     let form = InstanceForm {
       domain: domain.to_string(),

crates/utils/src/utils.rs

@@ -1,5 +1,6 @@
-use crate::{error::LemmyError, IpAddr};
+use crate::{error::LemmyError, location_info, IpAddr};
 use actix_web::dev::ConnectionInfo;
+use anyhow::Context;
 use chrono::{DateTime, FixedOffset, NaiveDateTime};
 use itertools::Itertools;
 use once_cell::sync::Lazy;
@@ -60,7 +61,7 @@ pub(crate) fn slur_check<'a>(
   }
 }
 
-pub fn slur_regex(regex_str: Option<&str>) -> Option<Regex> {
+pub fn build_slur_regex(regex_str: Option<&str>) -> Option<Regex> {
   regex_str.map(|slurs| {
     RegexBuilder::new(slurs)
       .case_insensitive(true)
@@ -201,6 +202,10 @@ pub fn clean_url_params(url: &Url) -> Url {
   url_out
 }
 
+pub fn generate_domain_url(actor_id: &Url) -> Result<String, LemmyError> {
+  Ok(actor_id.host_str().context(location_info!())?.to_string())
+}
+
 #[cfg(test)]
 mod tests {
   use crate::utils::{clean_url_params, is_valid_post_title};