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