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

   1 use crate::{
   2   activities::{
   3     generate_activity_id,
   4     send_lemmy_activity,
   5     verify_activity,
   6     verify_person_in_community,
   7   },
   8   objects::{community::ApubCommunity, person::ApubPerson},
   9   protocol::activities::community::report::Report,
  10   PostOrComment,
  11 };
  12 use activitystreams_kinds::activity::FlagType;
  13 use lemmy_api_common::{blocking, comment::CommentReportResponse, post::PostReportResponse};
  14 use lemmy_apub_lib::{
  15   data::Data,
  16   object_id::ObjectId,
  17   traits::{ActivityHandler, ActorType},
  18 };
  19 use lemmy_db_schema::{
  20   source::{
  21     comment_report::{CommentReport, CommentReportForm},
  22     post_report::{PostReport, PostReportForm},
  23   },
  24   traits::Reportable,
  25 };
  26 use lemmy_db_views::{comment_report_view::CommentReportView, post_report_view::PostReportView};
  27 use lemmy_utils::LemmyError;
  28 use lemmy_websocket::{messages::SendModRoomMessage, LemmyContext, UserOperation};
  29
  30 impl Report {
  31   pub async fn send(
  32     object_id: ObjectId<PostOrComment>,
  33     actor: &ApubPerson,
  34     community_id: ObjectId<ApubCommunity>,
  35     reason: String,
  36     context: &LemmyContext,
  37   ) -> Result<(), LemmyError> {
  38     let community = community_id.dereference_local(context).await?;
  39     let kind = FlagType::Flag;
  40     let id = generate_activity_id(
  41       kind.clone(),
  42       &context.settings().get_protocol_and_hostname(),
  43     )?;
  44     let report = Report {
  45       actor: ObjectId::new(actor.actor_id()),
  46       to: [ObjectId::new(community.actor_id())],
  47       object: object_id,
  48       summary: reason,
  49       kind,
  50       id: id.clone(),
  51       unparsed: Default::default(),
  52     };
  53     send_lemmy_activity(
  54       context,
  55       &report,
  56       &id,
  57       actor,
  58       vec![community.shared_inbox_or_inbox_url()],
  59       false,
  60     )
  61     .await
  62   }
  63 }
  64
  65 #[async_trait::async_trait(?Send)]
  66 impl ActivityHandler for Report {
  67   type DataType = LemmyContext;
  68   async fn verify(
  69     &self,
  70     context: &Data<LemmyContext>,
  71     request_counter: &mut i32,
  72   ) -> Result<(), LemmyError> {
  73     verify_activity(&self.id, self.actor.inner(), &context.settings())?;
  74     let community = self.to[0].dereference(context, request_counter).await?;
  75     verify_person_in_community(&self.actor, &community, context, request_counter).await?;
  76     Ok(())
  77   }
  78
  79   async fn receive(
  80     self,
  81     context: &Data<LemmyContext>,
  82     request_counter: &mut i32,
  83   ) -> Result<(), LemmyError> {
  84     let actor = self.actor.dereference(context, request_counter).await?;
  85     match self.object.dereference(context, request_counter).await? {
  86       PostOrComment::Post(post) => {
  87         let report_form = PostReportForm {
  88           creator_id: actor.id,
  89           post_id: post.id,
  90           original_post_name: post.name.clone(),
  91           original_post_url: post.url.clone(),
  92           reason: self.summary,
  93           original_post_body: post.body.clone(),
  94         };
  95
  96         let report = blocking(context.pool(), move |conn| {
  97           PostReport::report(conn, &report_form)
  98         })
  99         .await??;
 100
 101         let post_report_view = blocking(context.pool(), move |conn| {
 102           PostReportView::read(conn, report.id, actor.id)
 103         })
 104         .await??;
 105
 106         context.chat_server().do_send(SendModRoomMessage {
 107           op: UserOperation::CreateCommentReport,
 108           response: PostReportResponse { post_report_view },
 109           community_id: post.community_id,
 110           websocket_id: None,
 111         });
 112       }
 113       PostOrComment::Comment(comment) => {
 114         let report_form = CommentReportForm {
 115           creator_id: actor.id,
 116           comment_id: comment.id,
 117           original_comment_text: comment.content.clone(),
 118           reason: self.summary,
 119         };
 120
 121         let report = blocking(context.pool(), move |conn| {
 122           CommentReport::report(conn, &report_form)
 123         })
 124         .await??;
 125
 126         let comment_report_view = blocking(context.pool(), move |conn| {
 127           CommentReportView::read(conn, report.id, actor.id)
 128         })
 129         .await??;
 130         let community_id = comment_report_view.community.id;
 131
 132         context.chat_server().do_send(SendModRoomMessage {
 133           op: UserOperation::CreateCommentReport,
 134           response: CommentReportResponse {
 135             comment_report_view,
 136           },
 137           community_id,
 138           websocket_id: None,
 139         });
 140       }
 141     };
 142     Ok(())
 143   }
 144 }