lemmy_apub/src/activities/send/private_message.rs

   1 use crate::{
   2   activities::send::generate_activity_id,
   3   activity_queue::send_activity_single_dest,
   4   extensions::context::lemmy_context,
   5   objects::ToApub,
   6   ActorType,
   7   ApubObjectType,
   8 };
   9 use activitystreams::{
  10   activity::{
  11     kind::{CreateType, DeleteType, UndoType, UpdateType},
  12     Create,
  13     Delete,
  14     Undo,
  15     Update,
  16   },
  17   prelude::*,
  18 };
  19 use lemmy_db_queries::Crud;
  20 use lemmy_db_schema::source::{private_message::PrivateMessage, user::User_};
  21 use lemmy_structs::blocking;
  22 use lemmy_utils::LemmyError;
  23 use lemmy_websocket::LemmyContext;
  24 use url::Url;
  25
  26 #[async_trait::async_trait(?Send)]
  27 impl ApubObjectType for PrivateMessage {
  28   /// Send out information about a newly created private message
  29   async fn send_create(&self, creator: &User_, context: &LemmyContext) -> Result<(), LemmyError> {
  30     let note = self.to_apub(context.pool()).await?;
  31
  32     let recipient_id = self.recipient_id;
  33     let recipient = blocking(context.pool(), move |conn| User_::read(conn, recipient_id)).await??;
  34
  35     let mut create = Create::new(creator.actor_id.to_owned(), note.into_any_base()?);
  36
  37     create
  38       .set_many_contexts(lemmy_context()?)
  39       .set_id(generate_activity_id(CreateType::Create)?)
  40       .set_to(recipient.actor_id()?);
  41
  42     send_activity_single_dest(create, creator, recipient.get_inbox_url()?, context).await?;
  43     Ok(())
  44   }
  45
  46   /// Send out information about an edited private message, to the followers of the community.
  47   async fn send_update(&self, creator: &User_, context: &LemmyContext) -> Result<(), LemmyError> {
  48     let note = self.to_apub(context.pool()).await?;
  49
  50     let recipient_id = self.recipient_id;
  51     let recipient = blocking(context.pool(), move |conn| User_::read(conn, recipient_id)).await??;
  52
  53     let mut update = Update::new(creator.actor_id.to_owned(), note.into_any_base()?);
  54     update
  55       .set_many_contexts(lemmy_context()?)
  56       .set_id(generate_activity_id(UpdateType::Update)?)
  57       .set_to(recipient.actor_id()?);
  58
  59     send_activity_single_dest(update, creator, recipient.get_inbox_url()?, context).await?;
  60     Ok(())
  61   }
  62
  63   async fn send_delete(&self, creator: &User_, context: &LemmyContext) -> Result<(), LemmyError> {
  64     let recipient_id = self.recipient_id;
  65     let recipient = blocking(context.pool(), move |conn| User_::read(conn, recipient_id)).await??;
  66
  67     let mut delete = Delete::new(creator.actor_id.to_owned(), Url::parse(&self.ap_id)?);
  68     delete
  69       .set_many_contexts(lemmy_context()?)
  70       .set_id(generate_activity_id(DeleteType::Delete)?)
  71       .set_to(recipient.actor_id()?);
  72
  73     send_activity_single_dest(delete, creator, recipient.get_inbox_url()?, context).await?;
  74     Ok(())
  75   }
  76
  77   async fn send_undo_delete(
  78     &self,
  79     creator: &User_,
  80     context: &LemmyContext,
  81   ) -> Result<(), LemmyError> {
  82     let recipient_id = self.recipient_id;
  83     let recipient = blocking(context.pool(), move |conn| User_::read(conn, recipient_id)).await??;
  84
  85     let mut delete = Delete::new(creator.actor_id.to_owned(), Url::parse(&self.ap_id)?);
  86     delete
  87       .set_many_contexts(lemmy_context()?)
  88       .set_id(generate_activity_id(DeleteType::Delete)?)
  89       .set_to(recipient.actor_id()?);
  90
  91     // Undo that fake activity
  92     let mut undo = Undo::new(creator.actor_id.to_owned(), delete.into_any_base()?);
  93     undo
  94       .set_many_contexts(lemmy_context()?)
  95       .set_id(generate_activity_id(UndoType::Undo)?)
  96       .set_to(recipient.actor_id()?);
  97
  98     send_activity_single_dest(undo, creator, recipient.get_inbox_url()?, context).await?;
  99     Ok(())
 100   }
 101
 102   async fn send_remove(&self, _mod_: &User_, _context: &LemmyContext) -> Result<(), LemmyError> {
 103     unimplemented!()
 104   }
 105
 106   async fn send_undo_remove(
 107     &self,
 108     _mod_: &User_,
 109     _context: &LemmyContext,
 110   ) -> Result<(), LemmyError> {
 111     unimplemented!()
 112   }
 113 }