crates/apub/src/activities/create_or_update/private_message.rs

   1 use crate::{
   2   activities::{generate_activity_id, send_lemmy_activity, verify_person},
   3   objects::{person::ApubPerson, private_message::ApubPrivateMessage},
   4   protocol::activities::{
   5     create_or_update::private_message::CreateOrUpdatePrivateMessage,
   6     CreateOrUpdateType,
   7   },
   8   ActorType,
   9 };
  10 use activitypub_federation::{
  11   core::object_id::ObjectId,
  12   data::Data,
  13   traits::{ActivityHandler, Actor, ApubObject},
  14   utils::verify_domains_match,
  15 };
  16 use lemmy_db_schema::{source::person::Person, traits::Crud};
  17 use lemmy_utils::error::LemmyError;
  18 use lemmy_websocket::{send::send_pm_ws_message, LemmyContext, UserOperationCrud};
  19 use url::Url;
  20
  21 impl CreateOrUpdatePrivateMessage {
  22   #[tracing::instrument(skip_all)]
  23   pub async fn send(
  24     private_message: ApubPrivateMessage,
  25     actor: &ApubPerson,
  26     kind: CreateOrUpdateType,
  27     context: &LemmyContext,
  28   ) -> Result<(), LemmyError> {
  29     let recipient_id = private_message.recipient_id;
  30     let recipient: ApubPerson = Person::read(context.pool(), recipient_id).await?.into();
  31
  32     let id = generate_activity_id(
  33       kind.clone(),
  34       &context.settings().get_protocol_and_hostname(),
  35     )?;
  36     let create_or_update = CreateOrUpdatePrivateMessage {
  37       id: id.clone(),
  38       actor: ObjectId::new(actor.actor_id()),
  39       to: [ObjectId::new(recipient.actor_id())],
  40       object: private_message.into_apub(context).await?,
  41       kind,
  42       unparsed: Default::default(),
  43     };
  44     let inbox = vec![recipient.shared_inbox_or_inbox()];
  45     send_lemmy_activity(context, create_or_update, actor, inbox, true).await
  46   }
  47 }
  48
  49 #[async_trait::async_trait(?Send)]
  50 impl ActivityHandler for CreateOrUpdatePrivateMessage {
  51   type DataType = LemmyContext;
  52   type Error = LemmyError;
  53
  54   fn id(&self) -> &Url {
  55     &self.id
  56   }
  57
  58   fn actor(&self) -> &Url {
  59     self.actor.inner()
  60   }
  61
  62   #[tracing::instrument(skip_all)]
  63   async fn verify(
  64     &self,
  65     context: &Data<LemmyContext>,
  66     request_counter: &mut i32,
  67   ) -> Result<(), LemmyError> {
  68     verify_person(&self.actor, context, request_counter).await?;
  69     verify_domains_match(self.actor.inner(), self.object.id.inner())?;
  70     verify_domains_match(self.to[0].inner(), self.object.to[0].inner())?;
  71     ApubPrivateMessage::verify(&self.object, self.actor.inner(), context, request_counter).await?;
  72     Ok(())
  73   }
  74
  75   #[tracing::instrument(skip_all)]
  76   async fn receive(
  77     self,
  78     context: &Data<LemmyContext>,
  79     request_counter: &mut i32,
  80   ) -> Result<(), LemmyError> {
  81     let private_message =
  82       ApubPrivateMessage::from_apub(self.object, context, request_counter).await?;
  83
  84     let notif_type = match self.kind {
  85       CreateOrUpdateType::Create => UserOperationCrud::CreatePrivateMessage,
  86       CreateOrUpdateType::Update => UserOperationCrud::EditPrivateMessage,
  87     };
  88     send_pm_ws_message(private_message.id, notif_type, None, context).await?;
  89
  90     Ok(())
  91   }
  92 }