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

diff --git a/crates/apub/src/activities/community/update.rs b/crates/apub/src/activities/community/update.rs
index b4ffb7fc..fe2477d6 100644
--- a/crates/apub/src/activities/community/update.rs
+++ b/crates/apub/src/activities/community/update.rs
@@ -1,121 +1,118 @@
 use crate::{
   activities::{
-    community::{announce::GetCommunity, send_to_community},
+    community::send_activity_in_community,
     generate_activity_id,
-    verify_activity,
     verify_is_public,
     verify_mod_action,
     verify_person_in_community,
   },
   activity_lists::AnnouncableActivities,
+  insert_received_activity,
   objects::{community::ApubCommunity, person::ApubPerson},
-  protocol::activities::community::update::UpdateCommunity,
+  protocol::{activities::community::update::UpdateCommunity, InCommunity},
+  SendActivity,
 };
-use activitystreams::{activity::kind::UpdateType, public};
-use lemmy_api_common::blocking;
-use lemmy_apub_lib::{
-  data::Data,
-  object_id::ObjectId,
-  traits::{ActivityHandler, ActorType, ApubObject},
+use activitypub_federation::{
+  config::Data,
+  kinds::{activity::UpdateType, public},
+  traits::{ActivityHandler, Actor, Object},
 };
-use lemmy_db_schema::{
-  source::community::{Community, CommunityForm},
-  traits::Crud,
+use lemmy_api_common::{
+  community::{CommunityResponse, EditCommunity, HideCommunity},
+  context::LemmyContext,
+  utils::local_user_view_from_jwt,
 };
-use lemmy_utils::LemmyError;
-use lemmy_websocket::{send::send_community_ws_message, LemmyContext, UserOperationCrud};
+use lemmy_db_schema::{source::community::Community, traits::Crud};
+use lemmy_utils::error::LemmyError;
+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_to_community(activity, &id, 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;
-  async fn verify(
-    &self,
-    context: &Data<LemmyContext>,
-    request_counter: &mut i32,
-  ) -> Result<(), LemmyError> {
+  type Error = LemmyError;
+
+  fn id(&self) -> &Url {
+    &self.id
+  }
+
+  fn actor(&self) -> &Url {
+    self.actor.inner()
+  }
+
+  #[tracing::instrument(skip_all)]
+  async fn verify(&self, context: &Data<Self::DataType>) -> Result<(), LemmyError> {
+    insert_received_activity(&self.id, context).await?;
     verify_is_public(&self.to, &self.cc)?;
-    verify_activity(&self.id, self.actor.inner(), &context.settings())?;
-    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, &community, 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(())
   }
 
-  async fn receive(
-    self,
-    context: &Data<LemmyContext>,
-    request_counter: &mut i32,
-  ) -> Result<(), LemmyError> {
-    let community = self.get_community(context, request_counter).await?;
+  #[tracing::instrument(skip_all)]
+  async fn receive(self, context: &Data<Self::DataType>) -> Result<(), LemmyError> {
+    let community = self.community(context).await?;
 
-    let updated_community = self.object.into_form()?;
-    let cf = CommunityForm {
-      name: updated_community.name,
-      title: updated_community.title,
-      description: updated_community.description,
-      nsfw: updated_community.nsfw,
-      // TODO: icon and banner would be hosted on the other instance, ideally we would copy it to ours
-      icon: updated_community.icon,
-      banner: updated_community.banner,
-      ..CommunityForm::default()
-    };
-    let updated_community = blocking(context.pool(), move |conn| {
-      Community::update(conn, community.id, &cf)
-    })
-    .await??;
+    let community_update_form = self.object.into_update_form();
 
-    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 {
-  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, 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
   }
 }