crates/apub/src/activities/send/comment.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::{comment::Comment, 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 Comment {
  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 post_id = self.post_id;
  47     let post = blocking(context.pool(), move |conn| Post::read(conn, post_id)).await??;
  48
  49     let community_id = post.community_id;
  50     let community = blocking(context.pool(), move |conn| {
  51       Community::read(conn, community_id)
  52     })
  53     .await??;
  54
  55     let mut delete = Delete::new(
  56       creator.actor_id.to_owned().into_inner(),
  57       self.ap_id.to_owned().into_inner(),
  58     );
  59     delete
  60       .set_many_contexts(lemmy_context())
  61       .set_id(generate_activity_id(DeleteType::Delete)?)
  62       .set_to(public())
  63       .set_many_ccs(vec![community.actor_id()]);
  64
  65     send_to_community(delete, creator, &community, None, context).await?;
  66     Ok(())
  67   }
  68
  69   async fn send_undo_delete(
  70     &self,
  71     creator: &Person,
  72     context: &LemmyContext,
  73   ) -> Result<(), LemmyError> {
  74     let post_id = self.post_id;
  75     let post = blocking(context.pool(), move |conn| Post::read(conn, post_id)).await??;
  76
  77     let community_id = post.community_id;
  78     let community = blocking(context.pool(), move |conn| {
  79       Community::read(conn, community_id)
  80     })
  81     .await??;
  82
  83     // Generate a fake delete activity, with the correct object
  84     let mut delete = Delete::new(
  85       creator.actor_id.to_owned().into_inner(),
  86       self.ap_id.to_owned().into_inner(),
  87     );
  88     delete
  89       .set_many_contexts(lemmy_context())
  90       .set_id(generate_activity_id(DeleteType::Delete)?)
  91       .set_to(public())
  92       .set_many_ccs(vec![community.actor_id()]);
  93
  94     // Undo that fake activity
  95     let mut undo = Undo::new(
  96       creator.actor_id.to_owned().into_inner(),
  97       delete.into_any_base()?,
  98     );
  99     undo
 100       .set_many_contexts(lemmy_context())
 101       .set_id(generate_activity_id(UndoType::Undo)?)
 102       .set_to(public())
 103       .set_many_ccs(vec![community.actor_id()]);
 104
 105     send_to_community(undo, creator, &community, None, context).await?;
 106     Ok(())
 107   }
 108
 109   async fn send_remove(&self, mod_: &Person, context: &LemmyContext) -> Result<(), LemmyError> {
 110     let post_id = self.post_id;
 111     let post = blocking(context.pool(), move |conn| Post::read(conn, post_id)).await??;
 112
 113     let community_id = post.community_id;
 114     let community = blocking(context.pool(), move |conn| {
 115       Community::read(conn, community_id)
 116     })
 117     .await??;
 118
 119     let mut remove = Remove::new(
 120       mod_.actor_id.to_owned().into_inner(),
 121       self.ap_id.to_owned().into_inner(),
 122     );
 123     remove
 124       .set_many_contexts(lemmy_context())
 125       .set_id(generate_activity_id(RemoveType::Remove)?)
 126       .set_to(public())
 127       .set_many_ccs(vec![community.actor_id()]);
 128
 129     send_to_community(remove, mod_, &community, None, context).await?;
 130     Ok(())
 131   }
 132
 133   async fn send_undo_remove(
 134     &self,
 135     mod_: &Person,
 136     context: &LemmyContext,
 137   ) -> Result<(), LemmyError> {
 138     let post_id = self.post_id;
 139     let post = blocking(context.pool(), move |conn| Post::read(conn, post_id)).await??;
 140
 141     let community_id = post.community_id;
 142     let community = blocking(context.pool(), move |conn| {
 143       Community::read(conn, community_id)
 144     })
 145     .await??;
 146
 147     // Generate a fake delete activity, with the correct object
 148     let mut remove = Remove::new(
 149       mod_.actor_id.to_owned().into_inner(),
 150       self.ap_id.to_owned().into_inner(),
 151     );
 152     remove
 153       .set_many_contexts(lemmy_context())
 154       .set_id(generate_activity_id(RemoveType::Remove)?)
 155       .set_to(public())
 156       .set_many_ccs(vec![community.actor_id()]);
 157
 158     // Undo that fake activity
 159     let mut undo = Undo::new(
 160       mod_.actor_id.to_owned().into_inner(),
 161       remove.into_any_base()?,
 162     );
 163     undo
 164       .set_many_contexts(lemmy_context())
 165       .set_id(generate_activity_id(UndoType::Undo)?)
 166       .set_to(public())
 167       .set_many_ccs(vec![community.actor_id()]);
 168
 169     send_to_community(undo, mod_, &community, None, context).await?;
 170     Ok(())
 171   }
 172 }
 173
 174 #[async_trait::async_trait(?Send)]
 175 impl ApubLikeableType for Comment {
 176   async fn send_like(&self, creator: &Person, context: &LemmyContext) -> Result<(), LemmyError> {
 177     let post_id = self.post_id;
 178     let post = blocking(context.pool(), move |conn| Post::read(conn, post_id)).await??;
 179
 180     let community_id = post.community_id;
 181     let community = blocking(context.pool(), move |conn| {
 182       Community::read(conn, community_id)
 183     })
 184     .await??;
 185
 186     let mut like = Like::new(
 187       creator.actor_id.to_owned().into_inner(),
 188       self.ap_id.to_owned().into_inner(),
 189     );
 190     like
 191       .set_many_contexts(lemmy_context())
 192       .set_id(generate_activity_id(LikeType::Like)?)
 193       .set_to(public())
 194       .set_many_ccs(vec![community.actor_id()]);
 195
 196     send_to_community(like, creator, &community, None, context).await?;
 197     Ok(())
 198   }
 199
 200   async fn send_dislike(&self, creator: &Person, context: &LemmyContext) -> Result<(), LemmyError> {
 201     let post_id = self.post_id;
 202     let post = blocking(context.pool(), move |conn| Post::read(conn, post_id)).await??;
 203
 204     let community_id = post.community_id;
 205     let community = blocking(context.pool(), move |conn| {
 206       Community::read(conn, community_id)
 207     })
 208     .await??;
 209
 210     let mut dislike = Dislike::new(
 211       creator.actor_id.to_owned().into_inner(),
 212       self.ap_id.to_owned().into_inner(),
 213     );
 214     dislike
 215       .set_many_contexts(lemmy_context())
 216       .set_id(generate_activity_id(DislikeType::Dislike)?)
 217       .set_to(public())
 218       .set_many_ccs(vec![community.actor_id()]);
 219
 220     send_to_community(dislike, creator, &community, None, context).await?;
 221     Ok(())
 222   }
 223
 224   async fn send_undo_like(
 225     &self,
 226     creator: &Person,
 227     context: &LemmyContext,
 228   ) -> Result<(), LemmyError> {
 229     let post_id = self.post_id;
 230     let post = blocking(context.pool(), move |conn| Post::read(conn, post_id)).await??;
 231
 232     let community_id = post.community_id;
 233     let community = blocking(context.pool(), move |conn| {
 234       Community::read(conn, community_id)
 235     })
 236     .await??;
 237
 238     let mut like = Like::new(
 239       creator.actor_id.to_owned().into_inner(),
 240       self.ap_id.to_owned().into_inner(),
 241     );
 242     like
 243       .set_many_contexts(lemmy_context())
 244       .set_id(generate_activity_id(DislikeType::Dislike)?)
 245       .set_to(public())
 246       .set_many_ccs(vec![community.actor_id()]);
 247
 248     // Undo that fake activity
 249     let mut undo = Undo::new(
 250       creator.actor_id.to_owned().into_inner(),
 251       like.into_any_base()?,
 252     );
 253     undo
 254       .set_many_contexts(lemmy_context())
 255       .set_id(generate_activity_id(UndoType::Undo)?)
 256       .set_to(public())
 257       .set_many_ccs(vec![community.actor_id()]);
 258
 259     send_to_community(undo, creator, &community, None, context).await?;
 260     Ok(())
 261   }
 262 }