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

   1 use crate::{
   2   activities::{
   3     deletion::{delete::Delete, undo_delete::UndoDelete},
   4     verify_mod_action,
   5     verify_person_in_community,
   6   },
   7   fetcher::person::get_or_fetch_and_upsert_person,
   8   ActorType,
   9 };
  10 use lemmy_api_common::blocking;
  11 use lemmy_apub_lib::{verify_domains_match, ActivityCommonFields};
  12 use lemmy_db_queries::{
  13   source::{comment::Comment_, community::Community_, post::Post_},
  14   ApubObject,
  15 };
  16 use lemmy_db_schema::{
  17   source::{comment::Comment, community::Community, person::Person, post::Post},
  18   DbUrl,
  19 };
  20 use lemmy_utils::LemmyError;
  21 use lemmy_websocket::{
  22   send::{send_comment_ws_message_simple, send_community_ws_message, send_post_ws_message},
  23   LemmyContext,
  24   UserOperationCrud,
  25 };
  26 use url::Url;
  27
  28 pub mod delete;
  29 pub mod undo_delete;
  30
  31 pub async fn send_apub_delete(
  32   actor: &Person,
  33   community: &Community,
  34   object_id: Url,
  35   deleted: bool,
  36   context: &LemmyContext,
  37 ) -> Result<(), LemmyError> {
  38   if deleted {
  39     Delete::send(actor, community, object_id, None, context).await
  40   } else {
  41     UndoDelete::send(actor, community, object_id, None, context).await
  42   }
  43 }
  44
  45 // TODO: remove reason is actually optional in lemmy. we set an empty string in that case, but its
  46 //       ugly
  47 pub async fn send_apub_remove(
  48   actor: &Person,
  49   community: &Community,
  50   object_id: Url,
  51   reason: String,
  52   removed: bool,
  53   context: &LemmyContext,
  54 ) -> Result<(), LemmyError> {
  55   if removed {
  56     Delete::send(actor, community, object_id, Some(reason), context).await
  57   } else {
  58     UndoDelete::send(actor, community, object_id, Some(reason), context).await
  59   }
  60 }
  61
  62 pub enum DeletableObjects {
  63   Community(Box<Community>),
  64   Comment(Box<Comment>),
  65   Post(Box<Post>),
  66 }
  67
  68 impl DeletableObjects {
  69   pub(crate) async fn read_from_db(
  70     ap_id: &Url,
  71     context: &LemmyContext,
  72   ) -> Result<DeletableObjects, LemmyError> {
  73     let id: DbUrl = ap_id.clone().into();
  74
  75     if let Some(c) = DeletableObjects::read_type_from_db::<Community>(id.clone(), context).await? {
  76       return Ok(DeletableObjects::Community(Box::new(c)));
  77     }
  78     if let Some(p) = DeletableObjects::read_type_from_db::<Post>(id.clone(), context).await? {
  79       return Ok(DeletableObjects::Post(Box::new(p)));
  80     }
  81     if let Some(c) = DeletableObjects::read_type_from_db::<Comment>(id.clone(), context).await? {
  82       return Ok(DeletableObjects::Comment(Box::new(c)));
  83     }
  84     Err(diesel::NotFound.into())
  85   }
  86
  87   // TODO: a method like this should be provided by fetcher module
  88   async fn read_type_from_db<Type: ApubObject + Send + 'static>(
  89     ap_id: DbUrl,
  90     context: &LemmyContext,
  91   ) -> Result<Option<Type>, LemmyError> {
  92     blocking(context.pool(), move |conn| {
  93       Type::read_from_apub_id(conn, &ap_id).ok()
  94     })
  95     .await
  96   }
  97 }
  98
  99 pub(in crate::activities) async fn verify_delete_activity(
 100   object: &Url,
 101   cc: &Url,
 102   common: &ActivityCommonFields,
 103   is_mod_action: bool,
 104   context: &LemmyContext,
 105   request_counter: &mut i32,
 106 ) -> Result<(), LemmyError> {
 107   let object = DeletableObjects::read_from_db(object, context).await?;
 108   match object {
 109     DeletableObjects::Community(c) => {
 110       if c.local {
 111         // can only do this check for local community, in remote case it would try to fetch the
 112         // deleted community (which fails)
 113         verify_person_in_community(&common.actor, cc, context, request_counter).await?;
 114       }
 115       // community deletion is always a mod (or admin) action
 116       verify_mod_action(&common.actor, c.actor_id(), context).await?;
 117     }
 118     DeletableObjects::Post(p) => {
 119       verify_delete_activity_post_or_comment(
 120         cc,
 121         common,
 122         &p.ap_id.into(),
 123         is_mod_action,
 124         context,
 125         request_counter,
 126       )
 127       .await?;
 128     }
 129     DeletableObjects::Comment(c) => {
 130       verify_delete_activity_post_or_comment(
 131         cc,
 132         common,
 133         &c.ap_id.into(),
 134         is_mod_action,
 135         context,
 136         request_counter,
 137       )
 138       .await?;
 139     }
 140   }
 141   Ok(())
 142 }
 143
 144 async fn verify_delete_activity_post_or_comment(
 145   cc: &Url,
 146   common: &ActivityCommonFields,
 147   object_id: &Url,
 148   is_mod_action: bool,
 149   context: &LemmyContext,
 150   request_counter: &mut i32,
 151 ) -> Result<(), LemmyError> {
 152   verify_person_in_community(&common.actor, cc, context, request_counter).await?;
 153   if is_mod_action {
 154     verify_mod_action(&common.actor, cc.clone(), context).await?;
 155   } else {
 156     // domain of post ap_id and post.creator ap_id are identical, so we just check the former
 157     verify_domains_match(&common.actor, object_id)?;
 158   }
 159   Ok(())
 160 }
 161
 162 struct WebsocketMessages {
 163   community: UserOperationCrud,
 164   post: UserOperationCrud,
 165   comment: UserOperationCrud,
 166 }
 167
 168 /// Write deletion or restoring of an object to the database, and send websocket message.
 169 /// TODO: we should do something similar for receive_remove_action(), but its much more complicated
 170 ///       because of the mod log
 171 async fn receive_delete_action(
 172   object: &Url,
 173   actor: &Url,
 174   ws_messages: WebsocketMessages,
 175   deleted: bool,
 176   context: &LemmyContext,
 177   request_counter: &mut i32,
 178 ) -> Result<(), LemmyError> {
 179   match DeletableObjects::read_from_db(object, context).await? {
 180     DeletableObjects::Community(community) => {
 181       if community.local {
 182         let mod_ = get_or_fetch_and_upsert_person(actor, context, request_counter).await?;
 183         let object = community.actor_id();
 184         send_apub_delete(&mod_, &community.clone(), object, true, context).await?;
 185       }
 186
 187       let community = blocking(context.pool(), move |conn| {
 188         Community::update_deleted(conn, community.id, deleted)
 189       })
 190       .await??;
 191       send_community_ws_message(community.id, ws_messages.community, None, None, context).await?;
 192     }
 193     DeletableObjects::Post(post) => {
 194       let deleted_post = blocking(context.pool(), move |conn| {
 195         Post::update_deleted(conn, post.id, deleted)
 196       })
 197       .await??;
 198       send_post_ws_message(deleted_post.id, ws_messages.post, None, None, context).await?;
 199     }
 200     DeletableObjects::Comment(comment) => {
 201       let deleted_comment = blocking(context.pool(), move |conn| {
 202         Comment::update_deleted(conn, comment.id, deleted)
 203       })
 204       .await??;
 205       send_comment_ws_message_simple(deleted_comment.id, ws_messages.comment, context).await?;
 206     }
 207   }
 208   Ok(())
 209 }