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

   1 use crate::{
   2   activities::{
   3     check_community_deleted_or_removed,
   4     community::send_activity_in_community,
   5     generate_activity_id,
   6     verify_is_public,
   7     verify_mod_action,
   8     verify_person_in_community,
   9   },
  10   activity_lists::AnnouncableActivities,
  11   insert_received_activity,
  12   objects::community::ApubCommunity,
  13   protocol::{
  14     activities::community::lock_page::{LockPage, LockType, UndoLockPage},
  15     InCommunity,
  16   },
  17 };
  18 use activitypub_federation::{
  19   config::Data,
  20   fetch::object_id::ObjectId,
  21   kinds::{activity::UndoType, public},
  22   traits::ActivityHandler,
  23 };
  24 use lemmy_api_common::context::LemmyContext;
  25 use lemmy_db_schema::{
  26   source::{
  27     community::Community,
  28     person::Person,
  29     post::{Post, PostUpdateForm},
  30   },
  31   traits::Crud,
  32 };
  33 use lemmy_utils::error::LemmyError;
  34 use url::Url;
  35
  36 #[async_trait::async_trait]
  37 impl ActivityHandler for LockPage {
  38   type DataType = LemmyContext;
  39   type Error = LemmyError;
  40
  41   fn id(&self) -> &Url {
  42     &self.id
  43   }
  44
  45   fn actor(&self) -> &Url {
  46     self.actor.inner()
  47   }
  48
  49   async fn verify(&self, context: &Data<Self::DataType>) -> Result<(), Self::Error> {
  50     verify_is_public(&self.to, &self.cc)?;
  51     let community = self.community(context).await?;
  52     verify_person_in_community(&self.actor, &community, context).await?;
  53     check_community_deleted_or_removed(&community)?;
  54     verify_mod_action(&self.actor, self.object.inner(), community.id, context).await?;
  55     Ok(())
  56   }
  57
  58   async fn receive(self, context: &Data<Self::DataType>) -> Result<(), Self::Error> {
  59     let form = PostUpdateForm::builder().locked(Some(true)).build();
  60     let post = self.object.dereference(context).await?;
  61     Post::update(&mut context.pool(), post.id, &form).await?;
  62     Ok(())
  63   }
  64 }
  65
  66 #[async_trait::async_trait]
  67 impl ActivityHandler for UndoLockPage {
  68   type DataType = LemmyContext;
  69   type Error = LemmyError;
  70
  71   fn id(&self) -> &Url {
  72     &self.id
  73   }
  74
  75   fn actor(&self) -> &Url {
  76     self.actor.inner()
  77   }
  78
  79   async fn verify(&self, context: &Data<Self::DataType>) -> Result<(), Self::Error> {
  80     insert_received_activity(&self.id, context).await?;
  81     verify_is_public(&self.to, &self.cc)?;
  82     let community = self.community(context).await?;
  83     verify_person_in_community(&self.actor, &community, context).await?;
  84     check_community_deleted_or_removed(&community)?;
  85     verify_mod_action(
  86       &self.actor,
  87       self.object.object.inner(),
  88       community.id,
  89       context,
  90     )
  91     .await?;
  92     Ok(())
  93   }
  94
  95   async fn receive(self, context: &Data<Self::DataType>) -> Result<(), Self::Error> {
  96     let form = PostUpdateForm::builder().locked(Some(false)).build();
  97     let post = self.object.object.dereference(context).await?;
  98     Post::update(&mut context.pool(), post.id, &form).await?;
  99     Ok(())
 100   }
 101 }
 102
 103 pub(crate) async fn send_lock_post(
 104   post: Post,
 105   actor: Person,
 106   locked: bool,
 107   context: Data<LemmyContext>,
 108 ) -> Result<(), LemmyError> {
 109   let community: ApubCommunity = Community::read(&mut context.pool(), post.community_id)
 110     .await?
 111     .into();
 112   let id = generate_activity_id(
 113     LockType::Lock,
 114     &context.settings().get_protocol_and_hostname(),
 115   )?;
 116   let community_id = community.actor_id.inner().clone();
 117   let lock = LockPage {
 118     actor: actor.actor_id.clone().into(),
 119     to: vec![public()],
 120     object: ObjectId::from(post.ap_id),
 121     cc: vec![community_id.clone()],
 122     kind: LockType::Lock,
 123     id,
 124     audience: Some(community_id.into()),
 125   };
 126   let activity = if locked {
 127     AnnouncableActivities::LockPost(lock)
 128   } else {
 129     let id = generate_activity_id(
 130       UndoType::Undo,
 131       &context.settings().get_protocol_and_hostname(),
 132     )?;
 133     let undo = UndoLockPage {
 134       actor: lock.actor.clone(),
 135       to: vec![public()],
 136       cc: lock.cc.clone(),
 137       kind: UndoType::Undo,
 138       id,
 139       audience: lock.audience.clone(),
 140       object: lock,
 141     };
 142     AnnouncableActivities::UndoLockPost(undo)
 143   };
 144   send_activity_in_community(activity, &actor.into(), &community, vec![], true, &context).await?;
 145   Ok(())
 146 }