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

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