X-Git-Url: http://these/git/?a=blobdiff_plain;f=crates%2Fapub%2Fsrc%2Factivities%2Fcommunity%2Fupdate.rs;h=fe2477d6efdf6a63102edee0e3396521a4ff07cb;hb=e9e76549a88cfbdab36f00d302cceabcaaa24f4c;hp=b444f4f5eb6e49e1418a26fa07aa9a08a959d907;hpb=235cc8b22897bfb3e71ba3dbd725d36863fea8ba;p=lemmy.git

diff --git a/crates/apub/src/activities/community/update.rs b/crates/apub/src/activities/community/update.rs
index b444f4f5..fe2477d6 100644
--- a/crates/apub/src/activities/community/update.rs
+++ b/crates/apub/src/activities/community/update.rs
@@ -1,58 +1,73 @@
 use crate::{
   activities::{
-    community::{announce::GetCommunity, send_activity_in_community},
+    community::send_activity_in_community,
     generate_activity_id,
     verify_is_public,
     verify_mod_action,
     verify_person_in_community,
   },
   activity_lists::AnnouncableActivities,
-  check_apub_id_valid,
-  fetch_local_site_data,
-  local_instance,
+  insert_received_activity,
   objects::{community::ApubCommunity, person::ApubPerson},
-  protocol::activities::community::update::UpdateCommunity,
-  ActorType,
+  protocol::{activities::community::update::UpdateCommunity, InCommunity},
+  SendActivity,
 };
 use activitypub_federation::{
-  core::object_id::ObjectId,
-  data::Data,
-  traits::{ActivityHandler, ApubObject},
+  config::Data,
+  kinds::{activity::UpdateType, public},
+  traits::{ActivityHandler, Actor, Object},
+};
+use lemmy_api_common::{
+  community::{CommunityResponse, EditCommunity, HideCommunity},
+  context::LemmyContext,
+  utils::local_user_view_from_jwt,
 };
-use activitystreams_kinds::{activity::UpdateType, public};
-use lemmy_api_common::utils::blocking;
 use lemmy_db_schema::{source::community::Community, traits::Crud};
 use lemmy_utils::error::LemmyError;
-use lemmy_websocket::{send::send_community_ws_message, LemmyContext, UserOperationCrud};
 use url::Url;
 
+#[async_trait::async_trait]
+impl SendActivity for EditCommunity {
+  type Response = CommunityResponse;
+
+  async fn send_activity(
+    request: &Self,
+    _response: &Self::Response,
+    context: &Data<LemmyContext>,
+  ) -> Result<(), LemmyError> {
+    let local_user_view = local_user_view_from_jwt(&request.auth, context).await?;
+    let community = Community::read(&mut context.pool(), request.community_id).await?;
+    UpdateCommunity::send(community.into(), &local_user_view.person.into(), context).await
+  }
+}
+
 impl UpdateCommunity {
   #[tracing::instrument(skip_all)]
   pub async fn send(
     community: ApubCommunity,
     actor: &ApubPerson,
-    context: &LemmyContext,
+    context: &Data<LemmyContext>,
   ) -> Result<(), LemmyError> {
     let id = generate_activity_id(
       UpdateType::Update,
       &context.settings().get_protocol_and_hostname(),
     )?;
     let update = UpdateCommunity {
-      actor: ObjectId::new(actor.actor_id()),
+      actor: actor.id().into(),
       to: vec![public()],
-      object: Box::new(community.clone().into_apub(context).await?),
-      cc: vec![community.actor_id()],
+      object: Box::new(community.clone().into_json(context).await?),
+      cc: vec![community.id()],
       kind: UpdateType::Update,
       id: id.clone(),
-      unparsed: Default::default(),
+      audience: Some(community.id().into()),
     };
 
     let activity = AnnouncableActivities::UpdateCommunity(update);
-    send_activity_in_community(activity, actor, &community, vec![], context).await
+    send_activity_in_community(activity, actor, &community, vec![], true, context).await
   }
 }
 
-#[async_trait::async_trait(?Send)]
+#[async_trait::async_trait]
 impl ActivityHandler for UpdateCommunity {
   type DataType = LemmyContext;
   type Error = LemmyError;
@@ -66,73 +81,38 @@ impl ActivityHandler for UpdateCommunity {
   }
 
   #[tracing::instrument(skip_all)]
-  async fn verify(
-    &self,
-    context: &Data<LemmyContext>,
-    request_counter: &mut i32,
-  ) -> Result<(), LemmyError> {
-    let local_site_data = blocking(context.pool(), fetch_local_site_data).await??;
-    check_apub_id_valid(self.id(), &local_site_data, context.settings())
-      .map_err(LemmyError::from_message)?;
+  async fn verify(&self, context: &Data<Self::DataType>) -> Result<(), LemmyError> {
+    insert_received_activity(&self.id, context).await?;
     verify_is_public(&self.to, &self.cc)?;
-    let community = self.get_community(context, request_counter).await?;
-    verify_person_in_community(&self.actor, &community, context, request_counter).await?;
-    verify_mod_action(
-      &self.actor,
-      self.object.id.inner(),
-      community.id,
-      context,
-      request_counter,
-    )
-    .await?;
-    ApubCommunity::verify(
-      &self.object,
-      &community.actor_id.clone().into(),
-      context,
-      request_counter,
-    )
-    .await?;
+    let community = self.community(context).await?;
+    verify_person_in_community(&self.actor, &community, context).await?;
+    verify_mod_action(&self.actor, self.object.id.inner(), community.id, context).await?;
+    ApubCommunity::verify(&self.object, &community.actor_id.clone().into(), context).await?;
     Ok(())
   }
 
   #[tracing::instrument(skip_all)]
-  async fn receive(
-    self,
-    context: &Data<LemmyContext>,
-    request_counter: &mut i32,
-  ) -> Result<(), LemmyError> {
-    let community = self.get_community(context, request_counter).await?;
+  async fn receive(self, context: &Data<Self::DataType>) -> Result<(), LemmyError> {
+    let community = self.community(context).await?;
 
     let community_update_form = self.object.into_update_form();
 
-    let updated_community = blocking(context.pool(), move |conn| {
-      Community::update(conn, community.id, &community_update_form)
-    })
-    .await??;
-
-    send_community_ws_message(
-      updated_community.id,
-      UserOperationCrud::EditCommunity,
-      None,
-      None,
-      context,
-    )
-    .await?;
+    Community::update(&mut context.pool(), community.id, &community_update_form).await?;
     Ok(())
   }
 }
 
-#[async_trait::async_trait(?Send)]
-impl GetCommunity for UpdateCommunity {
-  #[tracing::instrument(skip_all)]
-  async fn get_community(
-    &self,
-    context: &LemmyContext,
-    request_counter: &mut i32,
-  ) -> Result<ApubCommunity, LemmyError> {
-    let cid = ObjectId::new(self.object.id.clone());
-    cid
-      .dereference(context, local_instance(context), request_counter)
-      .await
+#[async_trait::async_trait]
+impl SendActivity for HideCommunity {
+  type Response = CommunityResponse;
+
+  async fn send_activity(
+    request: &Self,
+    _response: &Self::Response,
+    context: &Data<LemmyContext>,
+  ) -> Result<(), LemmyError> {
+    let local_user_view = local_user_view_from_jwt(&request.auth, context).await?;
+    let community = Community::read(&mut context.pool(), request.community_id).await?;
+    UpdateCommunity::send(community.into(), &local_user_view.person.into(), context).await
   }
 }