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