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

   1 use crate::{
   2   activities::{generate_activity_id, send_lemmy_activity, verify_activity},
   3   protocol::activities::following::{accept::AcceptFollowCommunity, follow::FollowCommunity},
   4 };
   5 use activitystreams::activity::kind::AcceptType;
   6 use lemmy_api_common::blocking;
   7 use lemmy_apub_lib::{
   8   data::Data,
   9   object_id::ObjectId,
  10   traits::{ActivityHandler, ActorType},
  11   verify::verify_urls_match,
  12 };
  13 use lemmy_db_schema::{source::community::CommunityFollower, traits::Followable};
  14 use lemmy_utils::LemmyError;
  15 use lemmy_websocket::LemmyContext;
  16
  17 impl AcceptFollowCommunity {
  18   pub async fn send(
  19     follow: FollowCommunity,
  20     context: &LemmyContext,
  21     request_counter: &mut i32,
  22   ) -> Result<(), LemmyError> {
  23     let community = follow.object.dereference_local(context).await?;
  24     let person = follow
  25       .actor
  26       .clone()
  27       .dereference(context, request_counter)
  28       .await?;
  29     let accept = AcceptFollowCommunity {
  30       actor: ObjectId::new(community.actor_id()),
  31       object: follow,
  32       kind: AcceptType::Accept,
  33       id: generate_activity_id(
  34         AcceptType::Accept,
  35         &context.settings().get_protocol_and_hostname(),
  36       )?,
  37       unparsed: Default::default(),
  38     };
  39     let inbox = vec![person.inbox_url()];
  40     send_lemmy_activity(context, &accept, &accept.id, &community, inbox, true).await
  41   }
  42 }
  43
  44 /// Handle accepted follows
  45 #[async_trait::async_trait(?Send)]
  46 impl ActivityHandler for AcceptFollowCommunity {
  47   type DataType = LemmyContext;
  48   async fn verify(
  49     &self,
  50     context: &Data<LemmyContext>,
  51     request_counter: &mut i32,
  52   ) -> Result<(), LemmyError> {
  53     verify_activity(&self.id, self.actor.inner(), &context.settings())?;
  54     verify_urls_match(self.actor.inner(), self.object.object.inner())?;
  55     self.object.verify(context, request_counter).await?;
  56     Ok(())
  57   }
  58
  59   async fn receive(
  60     self,
  61     context: &Data<LemmyContext>,
  62     request_counter: &mut i32,
  63   ) -> Result<(), LemmyError> {
  64     let person = self.actor.dereference(context, request_counter).await?;
  65     let community = self
  66       .object
  67       .actor
  68       .dereference(context, request_counter)
  69       .await?;
  70     // This will throw an error if no follow was requested
  71     blocking(context.pool(), move |conn| {
  72       CommunityFollower::follow_accepted(conn, person.id, community.id)
  73     })
  74     .await??;
  75
  76     Ok(())
  77   }
  78 }