crates/apub/src/activities/deletion/delete.rs

   1 use crate::{
   2   activities::{
   3     community::announce::AnnouncableActivities,
   4     deletion::{
   5       receive_delete_action,
   6       verify_delete_activity,
   7       DeletableObjects,
   8       WebsocketMessages,
   9     },
  10     generate_activity_id,
  11     verify_activity,
  12   },
  13   activity_queue::send_to_community_new,
  14   extensions::context::lemmy_context,
  15   fetcher::object_id::ObjectId,
  16   ActorType,
  17 };
  18 use activitystreams::{
  19   activity::kind::DeleteType,
  20   base::AnyBase,
  21   primitives::OneOrMany,
  22   unparsed::Unparsed,
  23 };
  24 use anyhow::anyhow;
  25 use lemmy_api_common::blocking;
  26 use lemmy_apub_lib::{values::PublicUrl, ActivityFields, ActivityHandler};
  27 use lemmy_db_queries::{
  28   source::{comment::Comment_, community::Community_, post::Post_},
  29   Crud,
  30 };
  31 use lemmy_db_schema::source::{
  32   comment::Comment,
  33   community::Community,
  34   moderator::{
  35     ModRemoveComment,
  36     ModRemoveCommentForm,
  37     ModRemoveCommunity,
  38     ModRemoveCommunityForm,
  39     ModRemovePost,
  40     ModRemovePostForm,
  41   },
  42   person::Person,
  43   post::Post,
  44 };
  45 use lemmy_utils::LemmyError;
  46 use lemmy_websocket::{
  47   send::{send_comment_ws_message_simple, send_community_ws_message, send_post_ws_message},
  48   LemmyContext,
  49   UserOperationCrud,
  50 };
  51 use serde::{Deserialize, Serialize};
  52 use serde_with::skip_serializing_none;
  53 use url::Url;
  54
  55 /// This is very confusing, because there are four distinct cases to handle:
  56 /// - user deletes their post
  57 /// - user deletes their comment
  58 /// - remote community mod deletes local community
  59 /// - remote community deletes itself (triggered by a mod)
  60 ///
  61 /// TODO: we should probably change how community deletions work to simplify this. Probably by
  62 /// wrapping it in an announce just like other activities, instead of having the community send it.
  63 #[skip_serializing_none]
  64 #[derive(Clone, Debug, Deserialize, Serialize, ActivityFields)]
  65 #[serde(rename_all = "camelCase")]
  66 pub struct Delete {
  67   actor: ObjectId<Person>,
  68   to: [PublicUrl; 1],
  69   pub(in crate::activities::deletion) object: Url,
  70   pub(in crate::activities::deletion) cc: [ObjectId<Community>; 1],
  71   #[serde(rename = "type")]
  72   kind: DeleteType,
  73   /// If summary is present, this is a mod action (Remove in Lemmy terms). Otherwise, its a user
  74   /// deleting their own content.
  75   pub(in crate::activities::deletion) summary: Option<String>,
  76   id: Url,
  77   #[serde(rename = "@context")]
  78   context: OneOrMany<AnyBase>,
  79   #[serde(flatten)]
  80   unparsed: Unparsed,
  81 }
  82
  83 #[async_trait::async_trait(?Send)]
  84 impl ActivityHandler for Delete {
  85   async fn verify(
  86     &self,
  87     context: &LemmyContext,
  88     request_counter: &mut i32,
  89   ) -> Result<(), LemmyError> {
  90     verify_activity(self)?;
  91     verify_delete_activity(
  92       &self.object,
  93       self,
  94       &self.cc[0],
  95       self.summary.is_some(),
  96       context,
  97       request_counter,
  98     )
  99     .await?;
 100     Ok(())
 101   }
 102
 103   async fn receive(
 104     self,
 105     context: &LemmyContext,
 106     request_counter: &mut i32,
 107   ) -> Result<(), LemmyError> {
 108     if let Some(reason) = self.summary {
 109       // We set reason to empty string if it doesn't exist, to distinguish between delete and
 110       // remove. Here we change it back to option, so we don't write it to db.
 111       let reason = if reason.is_empty() {
 112         None
 113       } else {
 114         Some(reason)
 115       };
 116       receive_remove_action(&self.actor, &self.object, reason, context, request_counter).await
 117     } else {
 118       receive_delete_action(
 119         &self.object,
 120         &self.actor,
 121         WebsocketMessages {
 122           community: UserOperationCrud::DeleteCommunity,
 123           post: UserOperationCrud::DeletePost,
 124           comment: UserOperationCrud::DeleteComment,
 125         },
 126         true,
 127         context,
 128         request_counter,
 129       )
 130       .await
 131     }
 132   }
 133 }
 134
 135 impl Delete {
 136   pub(in crate::activities::deletion) fn new(
 137     actor: &Person,
 138     community: &Community,
 139     object_id: Url,
 140     summary: Option<String>,
 141   ) -> Result<Delete, LemmyError> {
 142     Ok(Delete {
 143       actor: ObjectId::new(actor.actor_id()),
 144       to: [PublicUrl::Public],
 145       object: object_id,
 146       cc: [ObjectId::new(community.actor_id())],
 147       kind: DeleteType::Delete,
 148       summary,
 149       id: generate_activity_id(DeleteType::Delete)?,
 150       context: lemmy_context(),
 151       unparsed: Default::default(),
 152     })
 153   }
 154   pub(in crate::activities::deletion) async fn send(
 155     actor: &Person,
 156     community: &Community,
 157     object_id: Url,
 158     summary: Option<String>,
 159     context: &LemmyContext,
 160   ) -> Result<(), LemmyError> {
 161     let delete = Delete::new(actor, community, object_id, summary)?;
 162     let delete_id = delete.id.clone();
 163
 164     let activity = AnnouncableActivities::Delete(delete);
 165     send_to_community_new(activity, &delete_id, actor, community, vec![], context).await
 166   }
 167 }
 168
 169 pub(in crate::activities) async fn receive_remove_action(
 170   actor: &ObjectId<Person>,
 171   object: &Url,
 172   reason: Option<String>,
 173   context: &LemmyContext,
 174   request_counter: &mut i32,
 175 ) -> Result<(), LemmyError> {
 176   let actor = actor.dereference(context, request_counter).await?;
 177   use UserOperationCrud::*;
 178   match DeletableObjects::read_from_db(object, context).await? {
 179     DeletableObjects::Community(community) => {
 180       if community.local {
 181         return Err(anyhow!("Only local admin can remove community").into());
 182       }
 183       let form = ModRemoveCommunityForm {
 184         mod_person_id: actor.id,
 185         community_id: community.id,
 186         removed: Some(true),
 187         reason,
 188         expires: None,
 189       };
 190       blocking(context.pool(), move |conn| {
 191         ModRemoveCommunity::create(conn, &form)
 192       })
 193       .await??;
 194       let deleted_community = blocking(context.pool(), move |conn| {
 195         Community::update_removed(conn, community.id, true)
 196       })
 197       .await??;
 198
 199       send_community_ws_message(deleted_community.id, RemoveCommunity, None, None, context).await?;
 200     }
 201     DeletableObjects::Post(post) => {
 202       let form = ModRemovePostForm {
 203         mod_person_id: actor.id,
 204         post_id: post.id,
 205         removed: Some(true),
 206         reason,
 207       };
 208       blocking(context.pool(), move |conn| {
 209         ModRemovePost::create(conn, &form)
 210       })
 211       .await??;
 212       let removed_post = blocking(context.pool(), move |conn| {
 213         Post::update_removed(conn, post.id, true)
 214       })
 215       .await??;
 216
 217       send_post_ws_message(removed_post.id, RemovePost, None, None, context).await?;
 218     }
 219     DeletableObjects::Comment(comment) => {
 220       let form = ModRemoveCommentForm {
 221         mod_person_id: actor.id,
 222         comment_id: comment.id,
 223         removed: Some(true),
 224         reason,
 225       };
 226       blocking(context.pool(), move |conn| {
 227         ModRemoveComment::create(conn, &form)
 228       })
 229       .await??;
 230       let removed_comment = blocking(context.pool(), move |conn| {
 231         Comment::update_removed(conn, comment.id, true)
 232       })
 233       .await??;
 234
 235       send_comment_ws_message_simple(removed_comment.id, RemoveComment, context).await?;
 236     }
 237   }
 238   Ok(())
 239 }