crates/apub/src/activities/community/announce.rs

   1 use crate::{
   2   activities::{generate_activity_id, send_lemmy_activity, verify_activity, verify_is_public},
   3   activity_lists::AnnouncableActivities,
   4   fetcher::object_id::ObjectId,
   5   http::is_activity_already_known,
   6   insert_activity,
   7   objects::community::ApubCommunity,
   8   protocol::activities::community::announce::AnnounceActivity,
   9 };
  10 use activitystreams::{activity::kind::AnnounceType, public};
  11 use lemmy_apub_lib::{
  12   data::Data,
  13   traits::{ActivityFields, ActivityHandler, ActorType},
  14 };
  15 use lemmy_utils::LemmyError;
  16 use lemmy_websocket::LemmyContext;
  17 use url::Url;
  18
  19 #[async_trait::async_trait(?Send)]
  20 pub(crate) trait GetCommunity {
  21   async fn get_community(
  22     &self,
  23     context: &LemmyContext,
  24     request_counter: &mut i32,
  25   ) -> Result<ApubCommunity, LemmyError>;
  26 }
  27
  28 impl AnnounceActivity {
  29   pub async fn send(
  30     object: AnnouncableActivities,
  31     community: &ApubCommunity,
  32     additional_inboxes: Vec<Url>,
  33     context: &LemmyContext,
  34   ) -> Result<(), LemmyError> {
  35     let announce = AnnounceActivity {
  36       actor: ObjectId::new(community.actor_id()),
  37       to: vec![public()],
  38       object,
  39       cc: vec![community.followers_url.clone().into_inner()],
  40       kind: AnnounceType::Announce,
  41       id: generate_activity_id(
  42         &AnnounceType::Announce,
  43         &context.settings().get_protocol_and_hostname(),
  44       )?,
  45       unparsed: Default::default(),
  46     };
  47     let inboxes = community
  48       .get_follower_inboxes(additional_inboxes, context)
  49       .await?;
  50     send_lemmy_activity(context, &announce, &announce.id, community, inboxes, false).await
  51   }
  52 }
  53
  54 #[async_trait::async_trait(?Send)]
  55 impl ActivityHandler for AnnounceActivity {
  56   type DataType = LemmyContext;
  57   async fn verify(
  58     &self,
  59     context: &Data<LemmyContext>,
  60     request_counter: &mut i32,
  61   ) -> Result<(), LemmyError> {
  62     verify_is_public(&self.to)?;
  63     verify_activity(self, &context.settings())?;
  64     self.object.verify(context, request_counter).await?;
  65     Ok(())
  66   }
  67
  68   async fn receive(
  69     self,
  70     context: &Data<LemmyContext>,
  71     request_counter: &mut i32,
  72   ) -> Result<(), LemmyError> {
  73     if is_activity_already_known(context.pool(), self.object.id_unchecked()).await? {
  74       return Ok(());
  75     }
  76     insert_activity(
  77       self.object.id_unchecked(),
  78       self.object.clone(),
  79       false,
  80       true,
  81       context.pool(),
  82     )
  83     .await?;
  84     self.object.receive(context, request_counter).await
  85   }
  86 }