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

   1 use crate::{
   2   activities::generate_activity_id,
   3   activity_queue::send_activity_single_dest,
   4   extensions::context::lemmy_context,
   5   ActorType,
   6   ApubObjectType,
   7 };
   8 use activitystreams::{
   9   activity::{
  10     kind::{DeleteType, UndoType},
  11     Delete,
  12     Undo,
  13   },
  14   base::{BaseExt, ExtendsExt},
  15   object::ObjectExt,
  16 };
  17 use lemmy_api_common::blocking;
  18 use lemmy_db_queries::Crud;
  19 use lemmy_db_schema::source::{person::Person, private_message::PrivateMessage};
  20 use lemmy_utils::LemmyError;
  21 use lemmy_websocket::LemmyContext;
  22
  23 #[async_trait::async_trait(?Send)]
  24 impl ApubObjectType for PrivateMessage {
  25   async fn send_create(
  26     &self,
  27     _creator: &Person,
  28     _context: &LemmyContext,
  29   ) -> Result<(), LemmyError> {
  30     unimplemented!()
  31   }
  32
  33   async fn send_update(
  34     &self,
  35     _creator: &Person,
  36     _context: &LemmyContext,
  37   ) -> Result<(), LemmyError> {
  38     unimplemented!()
  39   }
  40
  41   async fn send_delete(&self, creator: &Person, context: &LemmyContext) -> Result<(), LemmyError> {
  42     let recipient_id = self.recipient_id;
  43     let recipient =
  44       blocking(context.pool(), move |conn| Person::read(conn, recipient_id)).await??;
  45
  46     let mut delete = Delete::new(
  47       creator.actor_id.to_owned().into_inner(),
  48       self.ap_id.to_owned().into_inner(),
  49     );
  50     delete
  51       .set_many_contexts(lemmy_context())
  52       .set_id(generate_activity_id(DeleteType::Delete)?)
  53       .set_to(recipient.actor_id());
  54
  55     send_activity_single_dest(delete, creator, recipient.inbox_url.into(), context).await?;
  56     Ok(())
  57   }
  58
  59   async fn send_undo_delete(
  60     &self,
  61     creator: &Person,
  62     context: &LemmyContext,
  63   ) -> Result<(), LemmyError> {
  64     let recipient_id = self.recipient_id;
  65     let recipient =
  66       blocking(context.pool(), move |conn| Person::read(conn, recipient_id)).await??;
  67
  68     let mut delete = Delete::new(
  69       creator.actor_id.to_owned().into_inner(),
  70       self.ap_id.to_owned().into_inner(),
  71     );
  72     delete
  73       .set_many_contexts(lemmy_context())
  74       .set_id(generate_activity_id(DeleteType::Delete)?)
  75       .set_to(recipient.actor_id());
  76
  77     // Undo that fake activity
  78     let mut undo = Undo::new(
  79       creator.actor_id.to_owned().into_inner(),
  80       delete.into_any_base()?,
  81     );
  82     undo
  83       .set_many_contexts(lemmy_context())
  84       .set_id(generate_activity_id(UndoType::Undo)?)
  85       .set_to(recipient.actor_id());
  86
  87     send_activity_single_dest(undo, creator, recipient.inbox_url.into(), context).await?;
  88     Ok(())
  89   }
  90
  91   async fn send_remove(&self, _mod_: &Person, _context: &LemmyContext) -> Result<(), LemmyError> {
  92     unimplemented!()
  93   }
  94
  95   async fn send_undo_remove(
  96     &self,
  97     _mod_: &Person,
  98     _context: &LemmyContext,
  99   ) -> Result<(), LemmyError> {
 100     unimplemented!()
 101   }
 102 }