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

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