X-Git-Url: http://these/git/?a=blobdiff_plain;f=crates%2Fapub%2Fsrc%2Factivities%2Fcreate_or_update%2Fpost.rs;h=4767114f98b55edeb1eda6ab82743f85729e15d2;hb=5d23ef960e3361d1cc38c1aff1d907d8da58b90f;hp=286001828ecbc03791303a76a30f1416b4ca9faf;hpb=7b86441bab1a60f48d7bd4ff1ac37d6788d3cbf9;p=lemmy.git

diff --git a/crates/apub/src/activities/create_or_update/post.rs b/crates/apub/src/activities/create_or_update/post.rs
index 28600182..4767114f 100644
--- a/crates/apub/src/activities/create_or_update/post.rs
+++ b/crates/apub/src/activities/create_or_update/post.rs
@@ -1,139 +1,168 @@
 use crate::{
   activities::{
     check_community_deleted_or_removed,
-    community::{announce::GetCommunity, send_activity_in_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, post::ApubPost},
-  protocol::activities::{create_or_update::post::CreateOrUpdatePost, CreateOrUpdateType},
+  protocol::{
+    activities::{create_or_update::page::CreateOrUpdatePage, CreateOrUpdateType},
+    InCommunity,
+  },
+  SendActivity,
+};
+use activitypub_federation::{
+  config::Data,
+  kinds::public,
+  protocol::verification::{verify_domains_match, verify_urls_match},
+  traits::{ActivityHandler, Actor, Object},
 };
-use activitystreams_kinds::public;
-use lemmy_api_common::utils::blocking;
-use lemmy_apub_lib::{
-  data::Data,
-  object_id::ObjectId,
-  traits::{ActivityHandler, ActorType, ApubObject},
-  verify::{verify_domains_match, verify_urls_match},
+use lemmy_api_common::{
+  context::LemmyContext,
+  post::{EditPost, PostResponse},
 };
 use lemmy_db_schema::{
+  aggregates::structs::PostAggregates,
+  newtypes::PersonId,
   source::{
     community::Community,
-    post::{PostLike, PostLikeForm},
+    person::Person,
+    post::{Post, PostLike, PostLikeForm},
   },
   traits::{Crud, Likeable},
 };
-use lemmy_utils::LemmyError;
-use lemmy_websocket::{send::send_post_ws_message, LemmyContext, UserOperationCrud};
+use lemmy_utils::error::{LemmyError, LemmyErrorType};
+use url::Url;
+
+#[async_trait::async_trait]
+impl SendActivity for EditPost {
+  type Response = PostResponse;
+
+  async fn send_activity(
+    _request: &Self,
+    response: &Self::Response,
+    context: &Data<LemmyContext>,
+  ) -> Result<(), LemmyError> {
+    CreateOrUpdatePage::send(
+      response.post_view.post.clone(),
+      response.post_view.creator.id,
+      CreateOrUpdateType::Update,
+      context.reset_request_count(),
+    )
+    .await
+  }
+}
 
-impl CreateOrUpdatePost {
+impl CreateOrUpdatePage {
   pub(crate) async fn new(
     post: ApubPost,
     actor: &ApubPerson,
     community: &ApubCommunity,
     kind: CreateOrUpdateType,
-    context: &LemmyContext,
-  ) -> Result<CreateOrUpdatePost, LemmyError> {
+    context: &Data<LemmyContext>,
+  ) -> Result<CreateOrUpdatePage, LemmyError> {
     let id = generate_activity_id(
       kind.clone(),
       &context.settings().get_protocol_and_hostname(),
     )?;
-    Ok(CreateOrUpdatePost {
-      actor: ObjectId::new(actor.actor_id()),
+    Ok(CreateOrUpdatePage {
+      actor: actor.id().into(),
       to: vec![public()],
-      object: post.into_apub(context).await?,
-      cc: vec![community.actor_id()],
+      object: post.into_json(context).await?,
+      cc: vec![community.id()],
       kind,
       id: id.clone(),
-      unparsed: Default::default(),
+      audience: Some(community.id().into()),
     })
   }
 
   #[tracing::instrument(skip_all)]
-  pub async fn send(
-    post: ApubPost,
-    actor: &ApubPerson,
+  pub(crate) async fn send(
+    post: Post,
+    person_id: PersonId,
     kind: CreateOrUpdateType,
-    context: &LemmyContext,
+    context: Data<LemmyContext>,
   ) -> Result<(), LemmyError> {
+    let post = ApubPost(post);
     let community_id = post.community_id;
-    let community: ApubCommunity = blocking(context.pool(), move |conn| {
-      Community::read(conn, community_id)
-    })
-    .await??
-    .into();
+    let person: ApubPerson = Person::read(&mut context.pool(), person_id).await?.into();
+    let community: ApubCommunity = Community::read(&mut context.pool(), community_id)
+      .await?
+      .into();
 
-    let create_or_update = CreateOrUpdatePost::new(post, actor, &community, kind, context).await?;
-    let id = create_or_update.id.clone();
-    let activity = AnnouncableActivities::CreateOrUpdatePost(Box::new(create_or_update));
-    send_activity_in_community(activity, &id, actor, &community, vec![], context).await
+    let create_or_update =
+      CreateOrUpdatePage::new(post, &person, &community, kind, &context).await?;
+    let is_mod_action = create_or_update.object.is_mod_action(&context).await?;
+    let activity = AnnouncableActivities::CreateOrUpdatePost(create_or_update);
+    send_activity_in_community(
+      activity,
+      &person,
+      &community,
+      vec![],
+      is_mod_action,
+      &context,
+    )
+    .await?;
+    Ok(())
   }
 }
 
-#[async_trait::async_trait(?Send)]
-impl ActivityHandler for CreateOrUpdatePost {
+#[async_trait::async_trait]
+impl ActivityHandler for CreateOrUpdatePage {
   type DataType = LemmyContext;
+  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<LemmyContext>,
-    request_counter: &mut i32,
-  ) -> Result<(), LemmyError> {
+  async fn verify(&self, context: &Data<LemmyContext>) -> 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?;
+    let community = self.community(context).await?;
+    verify_person_in_community(&self.actor, &community, context).await?;
     check_community_deleted_or_removed(&community)?;
 
     match self.kind {
       CreateOrUpdateType::Create => {
         verify_domains_match(self.actor.inner(), self.object.id.inner())?;
         verify_urls_match(self.actor.inner(), self.object.creator()?.inner())?;
-        // Check that the post isnt locked or stickied, as that isnt possible for newly created posts.
+        // Check that the post isnt locked, as that isnt possible for newly created posts.
         // However, when fetching a remote post we generate a new create activity with the current
-        // locked/stickied value, so this check may fail. So only check if its a local community,
+        // locked value, so this check may fail. So only check if its a local community,
         // because then we will definitely receive all create and update activities separately.
-        let is_stickied_or_locked =
-          self.object.stickied == Some(true) || self.object.comments_enabled == Some(false);
-        if community.local && is_stickied_or_locked {
-          return Err(LemmyError::from_message(
-            "New post cannot be stickied or locked",
-          ));
+        let is_locked = self.object.comments_enabled == Some(false);
+        if community.local && is_locked {
+          return Err(LemmyErrorType::NewPostCannotBeLocked)?;
         }
       }
       CreateOrUpdateType::Update => {
         let is_mod_action = self.object.is_mod_action(context).await?;
         if is_mod_action {
-          verify_mod_action(
-            &self.actor,
-            self.object.id.inner(),
-            &community,
-            context,
-            request_counter,
-          )
-          .await?;
+          verify_mod_action(&self.actor, self.object.id.inner(), community.id, context).await?;
         } else {
           verify_domains_match(self.actor.inner(), self.object.id.inner())?;
           verify_urls_match(self.actor.inner(), self.object.creator()?.inner())?;
         }
       }
     }
-    ApubPost::verify(&self.object, self.actor.inner(), context, request_counter).await?;
+    ApubPost::verify(&self.object, self.actor.inner(), context).await?;
     Ok(())
   }
 
   #[tracing::instrument(skip_all)]
-  async fn receive(
-    self,
-    context: &Data<LemmyContext>,
-    request_counter: &mut i32,
-  ) -> Result<(), LemmyError> {
-    let post = ApubPost::from_apub(self.object, context, request_counter).await?;
+  async fn receive(self, context: &Data<LemmyContext>) -> Result<(), LemmyError> {
+    let post = ApubPost::from_json(self.object, context).await?;
 
     // author likes their own post by default
     let like_form = PostLikeForm {
@@ -141,31 +170,11 @@ impl ActivityHandler for CreateOrUpdatePost {
       person_id: post.creator_id,
       score: 1,
     };
-    blocking(context.pool(), move |conn: &'_ _| {
-      PostLike::like(conn, &like_form)
-    })
-    .await??;
+    PostLike::like(&mut context.pool(), &like_form).await?;
 
-    let notif_type = match self.kind {
-      CreateOrUpdateType::Create => UserOperationCrud::CreatePost,
-      CreateOrUpdateType::Update => UserOperationCrud::EditPost,
-    };
-    send_post_ws_message(post.id, notif_type, None, None, context).await?;
-    Ok(())
-  }
-}
+    // Calculate initial hot_rank for post
+    PostAggregates::update_hot_rank(&mut context.pool(), post.id).await?;
 
-#[async_trait::async_trait(?Send)]
-impl GetCommunity for CreateOrUpdatePost {
-  #[tracing::instrument(skip_all)]
-  async fn get_community(
-    &self,
-    context: &LemmyContext,
-    request_counter: &mut i32,
-  ) -> Result<ApubCommunity, LemmyError> {
-    self
-      .object
-      .extract_community(context, request_counter)
-      .await
+    Ok(())
   }
 }