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   ApubLikeableType,
   7   ApubObjectType,
   8 };
   9 use activitystreams::{
  10   activity::{
  11     kind::{DeleteType, DislikeType, LikeType, RemoveType, UndoType},
  12     Delete,
  13     Dislike,
  14     Like,
  15     Remove,
  16     Undo,
  17   },
  18   prelude::*,
  19   public,
  20 };
  21 use lemmy_api_common::blocking;
  22 use lemmy_db_queries::Crud;
  23 use lemmy_db_schema::source::{community::Community, person::Person, post::Post};
  24 use lemmy_utils::LemmyError;
  25 use lemmy_websocket::LemmyContext;
  26
  27 #[async_trait::async_trait(?Send)]
  28 impl ApubObjectType for Post {
  29   async fn send_create(
  30     &self,
  31     _creator: &Person,
  32     _context: &LemmyContext,
  33   ) -> Result<(), LemmyError> {
  34     unimplemented!()
  35   }
  36
  37   async fn send_update(
  38     &self,
  39     _creator: &Person,
  40     _context: &LemmyContext,
  41   ) -> Result<(), LemmyError> {
  42     unimplemented!()
  43   }
  44
  45   async fn send_delete(&self, creator: &Person, context: &LemmyContext) -> Result<(), LemmyError> {
  46     let community_id = self.community_id;
  47     let community = blocking(context.pool(), move |conn| {
  48       Community::read(conn, community_id)
  49     })
  50     .await??;
  51
  52     let mut delete = Delete::new(
  53       creator.actor_id.to_owned().into_inner(),
  54       self.ap_id.to_owned().into_inner(),
  55     );
  56     delete
  57       .set_many_contexts(lemmy_context())
  58       .set_id(generate_activity_id(DeleteType::Delete)?)
  59       .set_to(public())
  60       .set_many_ccs(vec![community.actor_id()]);
  61
  62     send_to_community(delete, creator, &community, None, context).await?;
  63     Ok(())
  64   }
  65
  66   async fn send_undo_delete(
  67     &self,
  68     creator: &Person,
  69     context: &LemmyContext,
  70   ) -> Result<(), LemmyError> {
  71     let community_id = self.community_id;
  72     let community = blocking(context.pool(), move |conn| {
  73       Community::read(conn, community_id)
  74     })
  75     .await??;
  76
  77     let mut delete = Delete::new(
  78       creator.actor_id.to_owned().into_inner(),
  79       self.ap_id.to_owned().into_inner(),
  80     );
  81     delete
  82       .set_many_contexts(lemmy_context())
  83       .set_id(generate_activity_id(DeleteType::Delete)?)
  84       .set_to(public())
  85       .set_many_ccs(vec![community.actor_id()]);
  86
  87     // Undo that fake activity
  88     let mut undo = Undo::new(
  89       creator.actor_id.to_owned().into_inner(),
  90       delete.into_any_base()?,
  91     );
  92     undo
  93       .set_many_contexts(lemmy_context())
  94       .set_id(generate_activity_id(UndoType::Undo)?)
  95       .set_to(public())
  96       .set_many_ccs(vec![community.actor_id()]);
  97
  98     send_to_community(undo, creator, &community, None, context).await?;
  99     Ok(())
 100   }
 101
 102   async fn send_remove(&self, mod_: &Person, context: &LemmyContext) -> Result<(), LemmyError> {
 103     let community_id = self.community_id;
 104     let community = blocking(context.pool(), move |conn| {
 105       Community::read(conn, community_id)
 106     })
 107     .await??;
 108
 109     let mut remove = Remove::new(
 110       mod_.actor_id.to_owned().into_inner(),
 111       self.ap_id.to_owned().into_inner(),
 112     );
 113     remove
 114       .set_many_contexts(lemmy_context())
 115       .set_id(generate_activity_id(RemoveType::Remove)?)
 116       .set_to(public())
 117       .set_many_ccs(vec![community.actor_id()]);
 118
 119     send_to_community(remove, mod_, &community, None, context).await?;
 120     Ok(())
 121   }
 122
 123   async fn send_undo_remove(
 124     &self,
 125     mod_: &Person,
 126     context: &LemmyContext,
 127   ) -> Result<(), LemmyError> {
 128     let community_id = self.community_id;
 129     let community = blocking(context.pool(), move |conn| {
 130       Community::read(conn, community_id)
 131     })
 132     .await??;
 133
 134     let mut remove = Remove::new(
 135       mod_.actor_id.to_owned().into_inner(),
 136       self.ap_id.to_owned().into_inner(),
 137     );
 138     remove
 139       .set_many_contexts(lemmy_context())
 140       .set_id(generate_activity_id(RemoveType::Remove)?)
 141       .set_to(public())
 142       .set_many_ccs(vec![community.actor_id()]);
 143
 144     // Undo that fake activity
 145     let mut undo = Undo::new(
 146       mod_.actor_id.to_owned().into_inner(),
 147       remove.into_any_base()?,
 148     );
 149     undo
 150       .set_many_contexts(lemmy_context())
 151       .set_id(generate_activity_id(UndoType::Undo)?)
 152       .set_to(public())
 153       .set_many_ccs(vec![community.actor_id()]);
 154
 155     send_to_community(undo, mod_, &community, None, context).await?;
 156     Ok(())
 157   }
 158 }
 159
 160 #[async_trait::async_trait(?Send)]
 161 impl ApubLikeableType for Post {
 162   async fn send_like(&self, creator: &Person, context: &LemmyContext) -> Result<(), LemmyError> {
 163     let community_id = self.community_id;
 164     let community = blocking(context.pool(), move |conn| {
 165       Community::read(conn, community_id)
 166     })
 167     .await??;
 168
 169     let mut like = Like::new(
 170       creator.actor_id.to_owned().into_inner(),
 171       self.ap_id.to_owned().into_inner(),
 172     );
 173     like
 174       .set_many_contexts(lemmy_context())
 175       .set_id(generate_activity_id(LikeType::Like)?)
 176       .set_to(public())
 177       .set_many_ccs(vec![community.actor_id()]);
 178
 179     send_to_community(like, creator, &community, None, context).await?;
 180     Ok(())
 181   }
 182
 183   async fn send_dislike(&self, creator: &Person, context: &LemmyContext) -> Result<(), LemmyError> {
 184     let community_id = self.community_id;
 185     let community = blocking(context.pool(), move |conn| {
 186       Community::read(conn, community_id)
 187     })
 188     .await??;
 189
 190     let mut dislike = Dislike::new(
 191       creator.actor_id.to_owned().into_inner(),
 192       self.ap_id.to_owned().into_inner(),
 193     );
 194     dislike
 195       .set_many_contexts(lemmy_context())
 196       .set_id(generate_activity_id(DislikeType::Dislike)?)
 197       .set_to(public())
 198       .set_many_ccs(vec![community.actor_id()]);
 199
 200     send_to_community(dislike, creator, &community, None, context).await?;
 201     Ok(())
 202   }
 203
 204   async fn send_undo_like(
 205     &self,
 206     creator: &Person,
 207     context: &LemmyContext,
 208   ) -> Result<(), LemmyError> {
 209     let community_id = self.community_id;
 210     let community = blocking(context.pool(), move |conn| {
 211       Community::read(conn, community_id)
 212     })
 213     .await??;
 214
 215     let mut like = Like::new(
 216       creator.actor_id.to_owned().into_inner(),
 217       self.ap_id.to_owned().into_inner(),
 218     );
 219     like
 220       .set_many_contexts(lemmy_context())
 221       .set_id(generate_activity_id(LikeType::Like)?)
 222       .set_to(public())
 223       .set_many_ccs(vec![community.actor_id()]);
 224
 225     // Undo that fake activity
 226     let mut undo = Undo::new(
 227       creator.actor_id.to_owned().into_inner(),
 228       like.into_any_base()?,
 229     );
 230     undo
 231       .set_many_contexts(lemmy_context())
 232       .set_id(generate_activity_id(UndoType::Undo)?)
 233       .set_to(public())
 234       .set_many_ccs(vec![community.actor_id()]);
 235
 236     send_to_community(undo, creator, &community, None, context).await?;
 237     Ok(())
 238   }
 239 }