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

   1 use crate::{
   2   activities::generate_activity_id,
   3   activity_queue::send_to_community,
   4   extensions::context::lemmy_context,
   5   ActorType,
   6   ApubObjectType,
   7 };
   8 use activitystreams::{
   9   activity::{
  10     kind::{DeleteType, RemoveType, UndoType},
  11     Delete,
  12     Remove,
  13     Undo,
  14   },
  15   prelude::*,
  16   public,
  17 };
  18 use lemmy_api_common::blocking;
  19 use lemmy_db_queries::Crud;
  20 use lemmy_db_schema::source::{community::Community, person::Person, post::Post};
  21 use lemmy_utils::LemmyError;
  22 use lemmy_websocket::LemmyContext;
  23
  24 #[async_trait::async_trait(?Send)]
  25 impl ApubObjectType for Post {
  26   async fn send_delete(&self, creator: &Person, context: &LemmyContext) -> Result<(), LemmyError> {
  27     let community_id = self.community_id;
  28     let community = blocking(context.pool(), move |conn| {
  29       Community::read(conn, community_id)
  30     })
  31     .await??;
  32
  33     let mut delete = Delete::new(
  34       creator.actor_id.to_owned().into_inner(),
  35       self.ap_id.to_owned().into_inner(),
  36     );
  37     delete
  38       .set_many_contexts(lemmy_context())
  39       .set_id(generate_activity_id(DeleteType::Delete)?)
  40       .set_to(public())
  41       .set_many_ccs(vec![community.actor_id()]);
  42
  43     send_to_community(delete, creator, &community, None, context).await?;
  44     Ok(())
  45   }
  46
  47   async fn send_undo_delete(
  48     &self,
  49     creator: &Person,
  50     context: &LemmyContext,
  51   ) -> Result<(), LemmyError> {
  52     let community_id = self.community_id;
  53     let community = blocking(context.pool(), move |conn| {
  54       Community::read(conn, community_id)
  55     })
  56     .await??;
  57
  58     let mut delete = Delete::new(
  59       creator.actor_id.to_owned().into_inner(),
  60       self.ap_id.to_owned().into_inner(),
  61     );
  62     delete
  63       .set_many_contexts(lemmy_context())
  64       .set_id(generate_activity_id(DeleteType::Delete)?)
  65       .set_to(public())
  66       .set_many_ccs(vec![community.actor_id()]);
  67
  68     // Undo that fake activity
  69     let mut undo = Undo::new(
  70       creator.actor_id.to_owned().into_inner(),
  71       delete.into_any_base()?,
  72     );
  73     undo
  74       .set_many_contexts(lemmy_context())
  75       .set_id(generate_activity_id(UndoType::Undo)?)
  76       .set_to(public())
  77       .set_many_ccs(vec![community.actor_id()]);
  78
  79     send_to_community(undo, creator, &community, None, context).await?;
  80     Ok(())
  81   }
  82
  83   async fn send_remove(&self, mod_: &Person, context: &LemmyContext) -> Result<(), LemmyError> {
  84     let community_id = self.community_id;
  85     let community = blocking(context.pool(), move |conn| {
  86       Community::read(conn, community_id)
  87     })
  88     .await??;
  89
  90     let mut remove = Remove::new(
  91       mod_.actor_id.to_owned().into_inner(),
  92       self.ap_id.to_owned().into_inner(),
  93     );
  94     remove
  95       .set_many_contexts(lemmy_context())
  96       .set_id(generate_activity_id(RemoveType::Remove)?)
  97       .set_to(public())
  98       .set_many_ccs(vec![community.actor_id()]);
  99
 100     send_to_community(remove, mod_, &community, None, context).await?;
 101     Ok(())
 102   }
 103
 104   async fn send_undo_remove(
 105     &self,
 106     mod_: &Person,
 107     context: &LemmyContext,
 108   ) -> Result<(), LemmyError> {
 109     let community_id = self.community_id;
 110     let community = blocking(context.pool(), move |conn| {
 111       Community::read(conn, community_id)
 112     })
 113     .await??;
 114
 115     let mut remove = Remove::new(
 116       mod_.actor_id.to_owned().into_inner(),
 117       self.ap_id.to_owned().into_inner(),
 118     );
 119     remove
 120       .set_many_contexts(lemmy_context())
 121       .set_id(generate_activity_id(RemoveType::Remove)?)
 122       .set_to(public())
 123       .set_many_ccs(vec![community.actor_id()]);
 124
 125     // Undo that fake activity
 126     let mut undo = Undo::new(
 127       mod_.actor_id.to_owned().into_inner(),
 128       remove.into_any_base()?,
 129     );
 130     undo
 131       .set_many_contexts(lemmy_context())
 132       .set_id(generate_activity_id(UndoType::Undo)?)
 133       .set_to(public())
 134       .set_many_ccs(vec![community.actor_id()]);
 135
 136     send_to_community(undo, mod_, &community, None, context).await?;
 137     Ok(())
 138   }
 139 }