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