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

   1 use crate::{
   2   activities::{generate_activity_id, send_lemmy_activity, verify_is_public, verify_person},
   3   check_apub_id_valid,
   4   fetch_local_site_data,
   5   local_instance,
   6   objects::{instance::remote_instance_inboxes, person::ApubPerson},
   7   protocol::activities::deletion::delete_user::DeleteUser,
   8 };
   9 use activitypub_federation::{
  10   core::object_id::ObjectId,
  11   data::Data,
  12   traits::ActivityHandler,
  13   utils::verify_urls_match,
  14 };
  15 use activitystreams_kinds::{activity::DeleteType, public};
  16 use lemmy_api_common::utils::{blocking, delete_user_account};
  17 use lemmy_utils::error::LemmyError;
  18 use lemmy_websocket::LemmyContext;
  19 use url::Url;
  20
  21 /// This can be separate from Delete activity because it doesn't need to be handled in shared inbox
  22 /// (cause instance actor doesn't have shared inbox).
  23 #[async_trait::async_trait(?Send)]
  24 impl ActivityHandler for DeleteUser {
  25   type DataType = LemmyContext;
  26   type Error = LemmyError;
  27
  28   fn id(&self) -> &Url {
  29     &self.id
  30   }
  31
  32   fn actor(&self) -> &Url {
  33     self.actor.inner()
  34   }
  35
  36   async fn verify(
  37     &self,
  38     context: &Data<LemmyContext>,
  39     request_counter: &mut i32,
  40   ) -> Result<(), LemmyError> {
  41     let local_site_data = blocking(context.pool(), fetch_local_site_data).await??;
  42     check_apub_id_valid(self.id(), &local_site_data, context.settings())
  43       .map_err(LemmyError::from_message)?;
  44     verify_is_public(&self.to, &[])?;
  45     verify_person(&self.actor, context, request_counter).await?;
  46     verify_urls_match(self.actor.inner(), self.object.inner())?;
  47     Ok(())
  48   }
  49
  50   async fn receive(
  51     self,
  52     context: &Data<LemmyContext>,
  53     request_counter: &mut i32,
  54   ) -> Result<(), LemmyError> {
  55     let actor = self
  56       .actor
  57       .dereference(context, local_instance(context), request_counter)
  58       .await?;
  59     delete_user_account(
  60       actor.id,
  61       context.pool(),
  62       context.settings(),
  63       context.client(),
  64     )
  65     .await?;
  66     Ok(())
  67   }
  68 }
  69
  70 impl DeleteUser {
  71   #[tracing::instrument(skip_all)]
  72   pub async fn send(actor: &ApubPerson, context: &LemmyContext) -> Result<(), LemmyError> {
  73     let actor_id = ObjectId::new(actor.actor_id.clone());
  74     let id = generate_activity_id(
  75       DeleteType::Delete,
  76       &context.settings().get_protocol_and_hostname(),
  77     )?;
  78     let delete = DeleteUser {
  79       actor: actor_id.clone(),
  80       to: vec![public()],
  81       object: actor_id,
  82       kind: DeleteType::Delete,
  83       id: id.clone(),
  84       cc: vec![],
  85     };
  86
  87     let inboxes = remote_instance_inboxes(context.pool()).await?;
  88     send_lemmy_activity(context, delete, actor, inboxes, true).await?;
  89     Ok(())
  90   }
  91 }