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

   1 use crate::{
   2   activities::{
   3     community::{
   4       announce::GetCommunity,
   5       get_community_from_moderators_url,
   6       send_activity_in_community,
   7     },
   8     generate_activity_id,
   9     verify_add_remove_moderator_target,
  10     verify_is_public,
  11     verify_mod_action,
  12     verify_person_in_community,
  13   },
  14   activity_lists::AnnouncableActivities,
  15   check_apub_id_valid,
  16   fetch_local_site_data,
  17   generate_moderators_url,
  18   local_instance,
  19   objects::{community::ApubCommunity, person::ApubPerson},
  20   protocol::activities::community::add_mod::AddMod,
  21   ActorType,
  22 };
  23 use activitypub_federation::{
  24   core::object_id::ObjectId,
  25   data::Data,
  26   traits::{ActivityHandler, Actor},
  27 };
  28 use activitystreams_kinds::{activity::AddType, public};
  29 use lemmy_api_common::utils::blocking;
  30 use lemmy_db_schema::{
  31   source::{
  32     community::{CommunityModerator, CommunityModeratorForm},
  33     moderator::{ModAddCommunity, ModAddCommunityForm},
  34   },
  35   traits::{Crud, Joinable},
  36 };
  37 use lemmy_utils::error::LemmyError;
  38 use lemmy_websocket::LemmyContext;
  39 use url::Url;
  40
  41 impl AddMod {
  42   #[tracing::instrument(skip_all)]
  43   pub async fn send(
  44     community: &ApubCommunity,
  45     added_mod: &ApubPerson,
  46     actor: &ApubPerson,
  47     context: &LemmyContext,
  48   ) -> Result<(), LemmyError> {
  49     let id = generate_activity_id(
  50       AddType::Add,
  51       &context.settings().get_protocol_and_hostname(),
  52     )?;
  53     let add = AddMod {
  54       actor: ObjectId::new(actor.actor_id()),
  55       to: vec![public()],
  56       object: ObjectId::new(added_mod.actor_id()),
  57       target: generate_moderators_url(&community.actor_id)?.into(),
  58       cc: vec![community.actor_id()],
  59       kind: AddType::Add,
  60       id: id.clone(),
  61       unparsed: Default::default(),
  62     };
  63
  64     let activity = AnnouncableActivities::AddMod(add);
  65     let inboxes = vec![added_mod.shared_inbox_or_inbox()];
  66     send_activity_in_community(activity, actor, community, inboxes, context).await
  67   }
  68 }
  69
  70 #[async_trait::async_trait(?Send)]
  71 impl ActivityHandler for AddMod {
  72   type DataType = LemmyContext;
  73   type Error = LemmyError;
  74
  75   fn id(&self) -> &Url {
  76     &self.id
  77   }
  78
  79   fn actor(&self) -> &Url {
  80     self.actor.inner()
  81   }
  82
  83   #[tracing::instrument(skip_all)]
  84   async fn verify(
  85     &self,
  86     context: &Data<LemmyContext>,
  87     request_counter: &mut i32,
  88   ) -> Result<(), LemmyError> {
  89     let local_site_data = blocking(context.pool(), fetch_local_site_data).await??;
  90     check_apub_id_valid(self.id(), &local_site_data, context.settings())
  91       .map_err(LemmyError::from_message)?;
  92
  93     verify_is_public(&self.to, &self.cc)?;
  94     let community = self.get_community(context, request_counter).await?;
  95     verify_person_in_community(&self.actor, &community, context, request_counter).await?;
  96     verify_mod_action(
  97       &self.actor,
  98       self.object.inner(),
  99       community.id,
 100       context,
 101       request_counter,
 102     )
 103     .await?;
 104     verify_add_remove_moderator_target(&self.target, &community)?;
 105     Ok(())
 106   }
 107
 108   #[tracing::instrument(skip_all)]
 109   async fn receive(
 110     self,
 111     context: &Data<LemmyContext>,
 112     request_counter: &mut i32,
 113   ) -> Result<(), LemmyError> {
 114     let community = self.get_community(context, request_counter).await?;
 115     let new_mod = self
 116       .object
 117       .dereference(context, local_instance(context), request_counter)
 118       .await?;
 119
 120     // If we had to refetch the community while parsing the activity, then the new mod has already
 121     // been added. Skip it here as it would result in a duplicate key error.
 122     let new_mod_id = new_mod.id;
 123     let moderated_communities = blocking(context.pool(), move |conn| {
 124       CommunityModerator::get_person_moderated_communities(conn, new_mod_id)
 125     })
 126     .await??;
 127     if !moderated_communities.contains(&community.id) {
 128       let form = CommunityModeratorForm {
 129         community_id: community.id,
 130         person_id: new_mod.id,
 131       };
 132       blocking(context.pool(), move |conn| {
 133         CommunityModerator::join(conn, &form)
 134       })
 135       .await??;
 136
 137       // write mod log
 138       let actor = self
 139         .actor
 140         .dereference(context, local_instance(context), request_counter)
 141         .await?;
 142       let form = ModAddCommunityForm {
 143         mod_person_id: actor.id,
 144         other_person_id: new_mod.id,
 145         community_id: community.id,
 146         removed: Some(false),
 147       };
 148       blocking(context.pool(), move |conn| {
 149         ModAddCommunity::create(conn, &form)
 150       })
 151       .await??;
 152     }
 153     // TODO: send websocket notification about added mod
 154     Ok(())
 155   }
 156 }
 157
 158 #[async_trait::async_trait(?Send)]
 159 impl GetCommunity for AddMod {
 160   #[tracing::instrument(skip_all)]
 161   async fn get_community(
 162     &self,
 163     context: &LemmyContext,
 164     request_counter: &mut i32,
 165   ) -> Result<ApubCommunity, LemmyError> {
 166     get_community_from_moderators_url(&self.target, context, request_counter).await
 167   }
 168 }