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