Split activity table into sent and received parts (fixes #3103) (#3583)

[lemmy.git] / crates / apub / src / activities / community / report.rs

diff --git a/crates/apub/src/activities/community/report.rs b/crates/apub/src/activities/community/report.rs
index de3fb3566d1ca0357ad8b8bdef9fad9da158e703..67b84644e6b473078d7833823cdcb4780828178c 100644 (file)
--- a/crates/apub/src/activities/community/report.rs
+++ b/crates/apub/src/activities/community/report.rs
@@ -1,20 +1,23 @@
 use crate::{
   activities::{generate_activity_id, send_lemmy_activity, verify_person_in_community},
-  check_apub_id_valid,
-  fetch_local_site_data,
-  local_instance,
+  insert_received_activity,
   objects::{community::ApubCommunity, person::ApubPerson},
-  protocol::activities::community::report::Report,
-  ActorType,
+  protocol::{activities::community::report::Report, InCommunity},
   PostOrComment,
+  SendActivity,
 };
 use activitypub_federation::{
-  core::object_id::ObjectId,
-  data::Data,
+  config::Data,
+  fetch::object_id::ObjectId,
+  kinds::activity::FlagType,
   traits::{ActivityHandler, Actor},
 };
-use activitystreams_kinds::activity::FlagType;
-use lemmy_api_common::{comment::CommentReportResponse, post::PostReportResponse, utils::blocking};
+use lemmy_api_common::{
+  comment::{CommentReportResponse, CreateCommentReport},
+  context::LemmyContext,
+  post::{CreatePostReport, PostReportResponse},
+  utils::local_user_view_from_jwt,
+};
 use lemmy_db_schema::{
   source::{
     comment_report::{CommentReport, CommentReportForm},
@@ -22,19 +25,59 @@ use lemmy_db_schema::{
   },
   traits::Reportable,
 };
-use lemmy_db_views::structs::{CommentReportView, PostReportView};
 use lemmy_utils::error::LemmyError;
-use lemmy_websocket::{messages::SendModRoomMessage, LemmyContext, UserOperation};
 use url::Url;
 
+#[async_trait::async_trait]
+impl SendActivity for CreatePostReport {
+  type Response = PostReportResponse;
+
+  async fn send_activity(
+    request: &Self,
+    response: &Self::Response,
+    context: &Data<LemmyContext>,
+  ) -> Result<(), LemmyError> {
+    let local_user_view = local_user_view_from_jwt(&request.auth, context).await?;
+    Report::send(
+      ObjectId::from(response.post_report_view.post.ap_id.clone()),
+      &local_user_view.person.into(),
+      ObjectId::from(response.post_report_view.community.actor_id.clone()),
+      request.reason.to_string(),
+      context,
+    )
+    .await
+  }
+}
+
+#[async_trait::async_trait]
+impl SendActivity for CreateCommentReport {
+  type Response = CommentReportResponse;
+
+  async fn send_activity(
+    request: &Self,
+    response: &Self::Response,
+    context: &Data<LemmyContext>,
+  ) -> Result<(), LemmyError> {
+    let local_user_view = local_user_view_from_jwt(&request.auth, context).await?;
+    Report::send(
+      ObjectId::from(response.comment_report_view.comment.ap_id.clone()),
+      &local_user_view.person.into(),
+      ObjectId::from(response.comment_report_view.community.actor_id.clone()),
+      request.reason.to_string(),
+      context,
+    )
+    .await
+  }
+}
+
 impl Report {
   #[tracing::instrument(skip_all)]
-  pub async fn send(
+  async fn send(
     object_id: ObjectId<PostOrComment>,
     actor: &ApubPerson,
     community_id: ObjectId<ApubCommunity>,
     reason: String,
-    context: &LemmyContext,
+    context: &Data<LemmyContext>,
   ) -> Result<(), LemmyError> {
     let community = community_id.dereference_local(context).await?;
     let kind = FlagType::Flag;
@@ -43,13 +86,13 @@ impl Report {
       &context.settings().get_protocol_and_hostname(),
     )?;
     let report = Report {
-      actor: ObjectId::new(actor.actor_id()),
-      to: [ObjectId::new(community.actor_id())],
+      actor: actor.id().into(),
+      to: [community.id().into()],
       object: object_id,
       summary: reason,
       kind,
       id: id.clone(),
-      unparsed: Default::default(),
+      audience: Some(community.id().into()),
     };
 
     let inbox = vec![community.shared_inbox_or_inbox()];
@@ -57,7 +100,7 @@ impl Report {
   }
 }
 
-#[async_trait::async_trait(?Send)]
+#[async_trait::async_trait]
 impl ActivityHandler for Report {
   type DataType = LemmyContext;
   type Error = LemmyError;
@@ -71,37 +114,17 @@ impl ActivityHandler for Report {
   }
 
   #[tracing::instrument(skip_all)]
-  async fn verify(
-    &self,
-    context: &Data<LemmyContext>,
-    request_counter: &mut i32,
-  ) -> Result<(), LemmyError> {
-    let local_site_data = blocking(context.pool(), fetch_local_site_data).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), request_counter)
-      .await?;
-    verify_person_in_community(&self.actor, &community, context, request_counter).await?;
+  async fn verify(&self, context: &Data<Self::DataType>) -> Result<(), LemmyError> {
+    insert_received_activity(&self.id, context).await?;
+    let community = self.community(context).await?;
+    verify_person_in_community(&self.actor, &community, context).await?;
     Ok(())
   }
 
   #[tracing::instrument(skip_all)]
-  async fn receive(
-    self,
-    context: &Data<LemmyContext>,
-    request_counter: &mut i32,
-  ) -> Result<(), LemmyError> {
-    let actor = self
-      .actor
-      .dereference(context, local_instance(context), request_counter)
-      .await?;
-    match self
-      .object
-      .dereference(context, local_instance(context), request_counter)
-      .await?
-    {
+  async fn receive(self, context: &Data<Self::DataType>) -> Result<(), LemmyError> {
+    let actor = self.actor.dereference(context).await?;
+    match self.object.dereference(context).await? {
       PostOrComment::Post(post) => {
         let report_form = PostReportForm {
           creator_id: actor.id,
@@ -111,23 +134,7 @@ impl ActivityHandler for Report {
           reason: self.summary,
           original_post_body: post.body.clone(),
         };
-
-        let report = blocking(context.pool(), move |conn| {
-          PostReport::report(conn, &report_form)
-        })
-        .await??;
-
-        let post_report_view = blocking(context.pool(), move |conn| {
-          PostReportView::read(conn, report.id, actor.id)
-        })
-        .await??;
-
-        context.chat_server().do_send(SendModRoomMessage {
-          op: UserOperation::CreateCommentReport,
-          response: PostReportResponse { post_report_view },
-          community_id: post.community_id,
-          websocket_id: None,
-        });
+        PostReport::report(&mut context.pool(), &report_form).await?;
       }
       PostOrComment::Comment(comment) => {
         let report_form = CommentReportForm {
@@ -136,26 +143,7 @@ impl ActivityHandler for Report {
           original_comment_text: comment.content.clone(),
           reason: self.summary,
         };
-
-        let report = blocking(context.pool(), move |conn| {
-          CommentReport::report(conn, &report_form)
-        })
-        .await??;
-
-        let comment_report_view = blocking(context.pool(), move |conn| {
-          CommentReportView::read(conn, report.id, actor.id)
-        })
-        .await??;
-        let community_id = comment_report_view.community.id;
-
-        context.chat_server().do_send(SendModRoomMessage {
-          op: UserOperation::CreateCommentReport,
-          response: CommentReportResponse {
-            comment_report_view,
-          },
-          community_id,
-          websocket_id: None,
-        });
+        CommentReport::report(&mut context.pool(), &report_form).await?;
       }
     };
     Ok(())