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       to: [ObjectId::new(person.actor_id())],
  32       object: follow,
  33       kind: AcceptType::Accept,
  34       id: generate_activity_id(
  35         AcceptType::Accept,
  36         &context.settings().get_protocol_and_hostname(),
  37       )?,
  38       unparsed: Default::default(),
  39     };
  40     let inbox = vec![person.inbox_url()];
  41     send_lemmy_activity(context, &accept, &accept.id, &community, inbox, true).await
  42   }
  43 }
  44
  45 /// Handle accepted follows
  46 #[async_trait::async_trait(?Send)]
  47 impl ActivityHandler for AcceptFollowCommunity {
  48   type DataType = LemmyContext;
  49   async fn verify(
  50     &self,
  51     context: &Data<LemmyContext>,
  52     request_counter: &mut i32,
  53   ) -> Result<(), LemmyError> {
  54     verify_activity(&self.id, self.actor.inner(), &context.settings())?;
  55     verify_urls_match(self.to[0].inner(), self.object.actor.inner())?;
  56     verify_urls_match(self.actor.inner(), self.object.to[0].inner())?;
  57     self.object.verify(context, request_counter).await?;
  58     Ok(())
  59   }
  60
  61   async fn receive(
  62     self,
  63     context: &Data<LemmyContext>,
  64     request_counter: &mut i32,
  65   ) -> Result<(), LemmyError> {
  66     let actor = self.actor.dereference(context, request_counter).await?;
  67     let to = self.to[0].dereference(context, request_counter).await?;
  68     // This will throw an error if no follow was requested
  69     blocking(context.pool(), move |conn| {
  70       CommunityFollower::follow_accepted(conn, actor.id, to.id)
  71     })
  72     .await??;
  73
  74     Ok(())
  75   }
  76 }