crates/apub/src/activities/following/accept.rs

   1 use crate::{
   2   activities::{following::follow::FollowCommunity, generate_activity_id, verify_activity},
   3   context::lemmy_context,
   4   fetcher::object_id::ObjectId,
   5   objects::{community::ApubCommunity, person::ApubPerson},
   6   send_lemmy_activity,
   7 };
   8 use activitystreams::{
   9   activity::kind::AcceptType,
  10   base::AnyBase,
  11   primitives::OneOrMany,
  12   unparsed::Unparsed,
  13 };
  14 use lemmy_api_common::blocking;
  15 use lemmy_apub_lib::{
  16   data::Data,
  17   traits::{ActivityFields, ActivityHandler, ActorType},
  18   verify::verify_urls_match,
  19 };
  20 use lemmy_db_schema::{source::community::CommunityFollower, traits::Followable};
  21 use lemmy_utils::LemmyError;
  22 use lemmy_websocket::LemmyContext;
  23 use serde::{Deserialize, Serialize};
  24 use url::Url;
  25
  26 #[derive(Clone, Debug, Deserialize, Serialize, ActivityFields)]
  27 #[serde(rename_all = "camelCase")]
  28 pub struct AcceptFollowCommunity {
  29   actor: ObjectId<ApubCommunity>,
  30   to: [ObjectId<ApubPerson>; 1],
  31   object: FollowCommunity,
  32   #[serde(rename = "type")]
  33   kind: AcceptType,
  34   id: Url,
  35   #[serde(rename = "@context")]
  36   context: OneOrMany<AnyBase>,
  37   #[serde(flatten)]
  38   unparsed: Unparsed,
  39 }
  40
  41 impl AcceptFollowCommunity {
  42   pub async fn send(
  43     follow: FollowCommunity,
  44     context: &LemmyContext,
  45     request_counter: &mut i32,
  46   ) -> Result<(), LemmyError> {
  47     let community = follow.object.dereference_local(context).await?;
  48     let person = follow
  49       .actor
  50       .clone()
  51       .dereference(context, request_counter)
  52       .await?;
  53     let accept = AcceptFollowCommunity {
  54       actor: ObjectId::new(community.actor_id()),
  55       to: [ObjectId::new(person.actor_id())],
  56       object: follow,
  57       kind: AcceptType::Accept,
  58       id: generate_activity_id(
  59         AcceptType::Accept,
  60         &context.settings().get_protocol_and_hostname(),
  61       )?,
  62       context: lemmy_context(),
  63       unparsed: Default::default(),
  64     };
  65     let inbox = vec![person.inbox_url()];
  66     send_lemmy_activity(context, &accept, &accept.id, &community, inbox, true).await
  67   }
  68 }
  69
  70 /// Handle accepted follows
  71 #[async_trait::async_trait(?Send)]
  72 impl ActivityHandler for AcceptFollowCommunity {
  73   type DataType = LemmyContext;
  74   async fn verify(
  75     &self,
  76     context: &Data<LemmyContext>,
  77     request_counter: &mut i32,
  78   ) -> Result<(), LemmyError> {
  79     verify_activity(self, &context.settings())?;
  80     verify_urls_match(self.to[0].inner(), self.object.actor())?;
  81     verify_urls_match(self.actor(), self.object.to[0].inner())?;
  82     self.object.verify(context, request_counter).await?;
  83     Ok(())
  84   }
  85
  86   async fn receive(
  87     self,
  88     context: &Data<LemmyContext>,
  89     request_counter: &mut i32,
  90   ) -> Result<(), LemmyError> {
  91     let actor = self.actor.dereference(context, request_counter).await?;
  92     let to = self.to[0].dereference(context, request_counter).await?;
  93     // This will throw an error if no follow was requested
  94     blocking(context.pool(), move |conn| {
  95       CommunityFollower::follow_accepted(conn, actor.id, to.id)
  96     })
  97     .await??;
  98
  99     Ok(())
 100   }
 101 }