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

   1 use crate::{
   2   activities::{generate_activity_id, send_lemmy_activity, verify_activity, verify_person},
   3   objects::{person::ApubPerson, private_message::ApubPrivateMessage},
   4   protocol::activities::private_message::delete::DeletePrivateMessage,
   5 };
   6 use activitystreams_kinds::activity::DeleteType;
   7 use lemmy_api_common::blocking;
   8 use lemmy_apub_lib::{
   9   data::Data,
  10   object_id::ObjectId,
  11   traits::{ActivityHandler, ActorType},
  12   verify::verify_domains_match,
  13 };
  14 use lemmy_db_schema::{
  15   source::{person::Person, private_message::PrivateMessage},
  16   traits::Crud,
  17 };
  18 use lemmy_utils::LemmyError;
  19 use lemmy_websocket::{send::send_pm_ws_message, LemmyContext, UserOperationCrud};
  20
  21 impl DeletePrivateMessage {
  22   pub(in crate::activities::private_message) fn new(
  23     actor: &ApubPerson,
  24     pm: &PrivateMessage,
  25     context: &LemmyContext,
  26   ) -> Result<DeletePrivateMessage, LemmyError> {
  27     Ok(DeletePrivateMessage {
  28       actor: ObjectId::new(actor.actor_id()),
  29       to: [ObjectId::new(actor.actor_id())],
  30       object: ObjectId::new(pm.ap_id.clone()),
  31       kind: DeleteType::Delete,
  32       id: generate_activity_id(
  33         DeleteType::Delete,
  34         &context.settings().get_protocol_and_hostname(),
  35       )?,
  36       unparsed: Default::default(),
  37     })
  38   }
  39   pub async fn send(
  40     actor: &ApubPerson,
  41     pm: &ApubPrivateMessage,
  42     context: &LemmyContext,
  43   ) -> Result<(), LemmyError> {
  44     let delete = DeletePrivateMessage::new(actor, pm, context)?;
  45     let delete_id = delete.id.clone();
  46
  47     let recipient_id = pm.recipient_id;
  48     let recipient: ApubPerson =
  49       blocking(context.pool(), move |conn| Person::read(conn, recipient_id))
  50         .await??
  51         .into();
  52     let inbox = vec![recipient.shared_inbox_or_inbox_url()];
  53     send_lemmy_activity(context, &delete, &delete_id, actor, inbox, true).await
  54   }
  55 }
  56
  57 #[async_trait::async_trait(?Send)]
  58 impl ActivityHandler for DeletePrivateMessage {
  59   type DataType = LemmyContext;
  60   async fn verify(
  61     &self,
  62     context: &Data<LemmyContext>,
  63     request_counter: &mut i32,
  64   ) -> Result<(), LemmyError> {
  65     verify_activity(&self.id, self.actor.inner(), &context.settings())?;
  66     verify_person(&self.actor, context, request_counter).await?;
  67     verify_domains_match(self.actor.inner(), self.object.inner())?;
  68     Ok(())
  69   }
  70
  71   async fn receive(
  72     self,
  73     context: &Data<LemmyContext>,
  74     _request_counter: &mut i32,
  75   ) -> Result<(), LemmyError> {
  76     let private_message = self.object.dereference_local(context).await?;
  77     let deleted_private_message = blocking(context.pool(), move |conn| {
  78       PrivateMessage::update_deleted(conn, private_message.id, true)
  79     })
  80     .await??;
  81
  82     send_pm_ws_message(
  83       deleted_private_message.id,
  84       UserOperationCrud::DeletePrivateMessage,
  85       None,
  86       context,
  87     )
  88     .await?;
  89
  90     Ok(())
  91   }
  92 }