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, ActivityFields};
  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   activity: &dyn ActivityFields,
 102   community_id: &Url,
 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(activity.actor(), community_id, context, request_counter)
 114           .await?;
 115       }
 116       // community deletion is always a mod (or admin) action
 117       verify_mod_action(activity.actor(), c.actor_id(), context).await?;
 118     }
 119     DeletableObjects::Post(p) => {
 120       verify_delete_activity_post_or_comment(
 121         activity,
 122         &p.ap_id.into(),
 123         community_id,
 124         is_mod_action,
 125         context,
 126         request_counter,
 127       )
 128       .await?;
 129     }
 130     DeletableObjects::Comment(c) => {
 131       verify_delete_activity_post_or_comment(
 132         activity,
 133         &c.ap_id.into(),
 134         community_id,
 135         is_mod_action,
 136         context,
 137         request_counter,
 138       )
 139       .await?;
 140     }
 141   }
 142   Ok(())
 143 }
 144
 145 async fn verify_delete_activity_post_or_comment(
 146   activity: &dyn ActivityFields,
 147   object_id: &Url,
 148   community_id: &Url,
 149   is_mod_action: bool,
 150   context: &LemmyContext,
 151   request_counter: &mut i32,
 152 ) -> Result<(), LemmyError> {
 153   verify_person_in_community(activity.actor(), community_id, context, request_counter).await?;
 154   if is_mod_action {
 155     verify_mod_action(activity.actor(), community_id.clone(), context).await?;
 156   } else {
 157     // domain of post ap_id and post.creator ap_id are identical, so we just check the former
 158     verify_domains_match(activity.actor(), object_id)?;
 159   }
 160   Ok(())
 161 }
 162
 163 struct WebsocketMessages {
 164   community: UserOperationCrud,
 165   post: UserOperationCrud,
 166   comment: UserOperationCrud,
 167 }
 168
 169 /// Write deletion or restoring of an object to the database, and send websocket message.
 170 /// TODO: we should do something similar for receive_remove_action(), but its much more complicated
 171 ///       because of the mod log
 172 async fn receive_delete_action(
 173   object: &Url,
 174   actor: &Url,
 175   ws_messages: WebsocketMessages,
 176   deleted: bool,
 177   context: &LemmyContext,
 178   request_counter: &mut i32,
 179 ) -> Result<(), LemmyError> {
 180   match DeletableObjects::read_from_db(object, context).await? {
 181     DeletableObjects::Community(community) => {
 182       if community.local {
 183         let mod_ = get_or_fetch_and_upsert_person(actor, context, request_counter).await?;
 184         let object = community.actor_id();
 185         send_apub_delete(&mod_, &community.clone(), object, true, context).await?;
 186       }
 187
 188       let community = blocking(context.pool(), move |conn| {
 189         Community::update_deleted(conn, community.id, deleted)
 190       })
 191       .await??;
 192       send_community_ws_message(community.id, ws_messages.community, None, None, context).await?;
 193     }
 194     DeletableObjects::Post(post) => {
 195       let deleted_post = blocking(context.pool(), move |conn| {
 196         Post::update_deleted(conn, post.id, deleted)
 197       })
 198       .await??;
 199       send_post_ws_message(deleted_post.id, ws_messages.post, None, None, context).await?;
 200     }
 201     DeletableObjects::Comment(comment) => {
 202       let deleted_comment = blocking(context.pool(), move |conn| {
 203         Comment::update_deleted(conn, comment.id, deleted)
 204       })
 205       .await??;
 206       send_comment_ws_message_simple(deleted_comment.id, ws_messages.comment, context).await?;
 207     }
 208   }
 209   Ok(())
 210 }