3 following::follow::FollowCommunity,
8 context::lemmy_context,
9 fetcher::object_id::ObjectId,
12 use activitystreams::{
13 activity::kind::AcceptType,
15 primitives::OneOrMany,
18 use lemmy_api_common::blocking;
21 traits::{ActivityFields, ActivityHandler, ActorType},
22 verify::verify_urls_match,
24 use lemmy_db_queries::Followable;
25 use lemmy_db_schema::source::{
26 community::{Community, CommunityFollower},
29 use lemmy_utils::LemmyError;
30 use lemmy_websocket::LemmyContext;
31 use serde::{Deserialize, Serialize};
34 #[derive(Clone, Debug, Deserialize, Serialize, ActivityFields)]
35 #[serde(rename_all = "camelCase")]
36 pub struct AcceptFollowCommunity {
37 actor: ObjectId<Community>,
39 object: FollowCommunity,
40 #[serde(rename = "type")]
43 #[serde(rename = "@context")]
44 context: OneOrMany<AnyBase>,
49 impl AcceptFollowCommunity {
51 follow: FollowCommunity,
52 context: &LemmyContext,
53 request_counter: &mut i32,
54 ) -> Result<(), LemmyError> {
55 let community = follow.object.dereference_local(context).await?;
59 .dereference(context, request_counter)
61 let accept = AcceptFollowCommunity {
62 actor: ObjectId::new(community.actor_id()),
63 to: ObjectId::new(person.actor_id()),
65 kind: AcceptType::Accept,
66 id: generate_activity_id(
68 &context.settings().get_protocol_and_hostname(),
70 context: lemmy_context(),
71 unparsed: Default::default(),
73 let inbox = vec![person.inbox_url.into()];
74 send_lemmy_activity(context, &accept, &accept.id, &community, inbox, true).await
78 /// Handle accepted follows
79 #[async_trait::async_trait(?Send)]
80 impl ActivityHandler for AcceptFollowCommunity {
81 type DataType = LemmyContext;
84 context: &Data<LemmyContext>,
85 request_counter: &mut i32,
86 ) -> Result<(), LemmyError> {
87 verify_activity(self, &context.settings())?;
88 verify_urls_match(self.to.inner(), self.object.actor())?;
89 verify_urls_match(self.actor(), self.object.to.inner())?;
90 verify_community(&self.actor, context, request_counter).await?;
91 self.object.verify(context, request_counter).await?;
97 context: &Data<LemmyContext>,
98 request_counter: &mut i32,
99 ) -> Result<(), LemmyError> {
100 let actor = self.actor.dereference(context, request_counter).await?;
101 let to = self.to.dereference(context, request_counter).await?;
102 // This will throw an error if no follow was requested
103 blocking(context.pool(), move |conn| {
104 CommunityFollower::follow_accepted(conn, actor.id, to.id)