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