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, &context.settings())?;
  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     context: &LemmyContext,
 142   ) -> Result<Delete, LemmyError> {
 143     Ok(Delete {
 144       actor: ObjectId::new(actor.actor_id()),
 145       to: [PublicUrl::Public],
 146       object: object_id,
 147       cc: [ObjectId::new(community.actor_id())],
 148       kind: DeleteType::Delete,
 149       summary,
 150       id: generate_activity_id(
 151         DeleteType::Delete,
 152         &context.settings().get_protocol_and_hostname(),
 153       )?,
 154       context: lemmy_context(),
 155       unparsed: Default::default(),
 156     })
 157   }
 158   pub(in crate::activities::deletion) async fn send(
 159     actor: &Person,
 160     community: &Community,
 161     object_id: Url,
 162     summary: Option<String>,
 163     context: &LemmyContext,
 164   ) -> Result<(), LemmyError> {
 165     let delete = Delete::new(actor, community, object_id, summary, context)?;
 166     let delete_id = delete.id.clone();
 167
 168     let activity = AnnouncableActivities::Delete(delete);
 169     send_to_community_new(activity, &delete_id, actor, community, vec![], context).await
 170   }
 171 }
 172
 173 pub(in crate::activities) async fn receive_remove_action(
 174   actor: &ObjectId<Person>,
 175   object: &Url,
 176   reason: Option<String>,
 177   context: &LemmyContext,
 178   request_counter: &mut i32,
 179 ) -> Result<(), LemmyError> {
 180   let actor = actor.dereference(context, request_counter).await?;
 181   use UserOperationCrud::*;
 182   match DeletableObjects::read_from_db(object, context).await? {
 183     DeletableObjects::Community(community) => {
 184       if community.local {
 185         return Err(anyhow!("Only local admin can remove community").into());
 186       }
 187       let form = ModRemoveCommunityForm {
 188         mod_person_id: actor.id,
 189         community_id: community.id,
 190         removed: Some(true),
 191         reason,
 192         expires: None,
 193       };
 194       blocking(context.pool(), move |conn| {
 195         ModRemoveCommunity::create(conn, &form)
 196       })
 197       .await??;
 198       let deleted_community = blocking(context.pool(), move |conn| {
 199         Community::update_removed(conn, community.id, true)
 200       })
 201       .await??;
 202
 203       send_community_ws_message(deleted_community.id, RemoveCommunity, None, None, context).await?;
 204     }
 205     DeletableObjects::Post(post) => {
 206       let form = ModRemovePostForm {
 207         mod_person_id: actor.id,
 208         post_id: post.id,
 209         removed: Some(true),
 210         reason,
 211       };
 212       blocking(context.pool(), move |conn| {
 213         ModRemovePost::create(conn, &form)
 214       })
 215       .await??;
 216       let removed_post = blocking(context.pool(), move |conn| {
 217         Post::update_removed(conn, post.id, true)
 218       })
 219       .await??;
 220
 221       send_post_ws_message(removed_post.id, RemovePost, None, None, context).await?;
 222     }
 223     DeletableObjects::Comment(comment) => {
 224       let form = ModRemoveCommentForm {
 225         mod_person_id: actor.id,
 226         comment_id: comment.id,
 227         removed: Some(true),
 228         reason,
 229       };
 230       blocking(context.pool(), move |conn| {
 231         ModRemoveComment::create(conn, &form)
 232       })
 233       .await??;
 234       let removed_comment = blocking(context.pool(), move |conn| {
 235         Comment::update_removed(conn, comment.id, true)
 236       })
 237       .await??;
 238
 239       send_comment_ws_message_simple(removed_comment.id, RemoveComment, context).await?;
 240     }
 241   }
 242   Ok(())
 243 }