X-Git-Url: http://these/git/?a=blobdiff_plain;f=crates%2Fapub%2Fsrc%2Factivities%2Fvoting%2Fvote.rs;h=81bed456f80166f082ef9d1ecc01330c7e705a46;hb=HEAD;hp=0f5a2b5c40231d1222f304e69e91b6cd505c0cc3;hpb=b8d7f00d58c0c76c70436b2a070f19351d5ccbd5;p=lemmy.git

diff --git a/crates/apub/src/activities/voting/vote.rs b/crates/apub/src/activities/voting/vote.rs
index 0f5a2b5c..81bed456 100644
--- a/crates/apub/src/activities/voting/vote.rs
+++ b/crates/apub/src/activities/voting/vote.rs
@@ -1,133 +1,84 @@
 use crate::{
   activities::{
-    community::announce::AnnouncableActivities,
-    generate_activity_id,
-    verify_activity,
-    verify_person_in_community,
+    generate_activity_id, verify_person_in_community,
     voting::{vote_comment, vote_post},
   },
-  activity_queue::send_to_community_new,
-  extensions::context::lemmy_context,
-  fetcher::{
-    objects::get_or_fetch_and_insert_post_or_comment,
-    person::get_or_fetch_and_upsert_person,
+  insert_received_activity,
+  objects::{community::ApubCommunity, person::ApubPerson},
+  protocol::{
+    activities::voting::vote::{Vote, VoteType},
+    InCommunity,
   },
-  ActorType,
   PostOrComment,
 };
-use anyhow::anyhow;
-use lemmy_api_common::blocking;
-use lemmy_apub_lib::{values::PublicUrl, ActivityCommonFields, ActivityHandler};
-use lemmy_db_queries::Crud;
-use lemmy_db_schema::{
-  source::{community::Community, person::Person},
-  CommunityId,
+use activitypub_federation::{
+  config::Data,
+  fetch::object_id::ObjectId,
+  traits::{ActivityHandler, Actor},
 };
-use lemmy_utils::LemmyError;
-use lemmy_websocket::LemmyContext;
-use serde::{Deserialize, Serialize};
-use std::{convert::TryFrom, ops::Deref};
-use strum_macros::ToString;
+use anyhow::anyhow;
+use lemmy_api_common::context::LemmyContext;
+use lemmy_db_schema::source::local_site::LocalSite;
+use lemmy_utils::error::LemmyError;
 use url::Url;
 
-#[derive(Clone, Debug, ToString, Deserialize, Serialize)]
-pub enum VoteType {
-  Like,
-  Dislike,
+impl Vote {
+  pub(in crate::activities::voting) fn new(
+    object_id: ObjectId<PostOrComment>,
+    actor: &ApubPerson,
+    community: &ApubCommunity,
+    kind: VoteType,
+    context: &Data<LemmyContext>,
+  ) -> Result<Vote, LemmyError> {
+    Ok(Vote {
+      actor: actor.id().into(),
+      object: object_id,
+      kind: kind.clone(),
+      id: generate_activity_id(kind, &context.settings().get_protocol_and_hostname())?,
+      audience: Some(community.id().into()),
+    })
+  }
 }
 
-impl TryFrom<i16> for VoteType {
+#[async_trait::async_trait]
+impl ActivityHandler for Vote {
+  type DataType = LemmyContext;
   type Error = LemmyError;
 
-  fn try_from(value: i16) -> Result<Self, Self::Error> {
-    match value {
-      1 => Ok(VoteType::Like),
-      -1 => Ok(VoteType::Dislike),
-      _ => Err(anyhow!("invalid vote value").into()),
-    }
-  }
-}
-
-impl From<&VoteType> for i16 {
-  fn from(value: &VoteType) -> i16 {
-    match value {
-      VoteType::Like => 1,
-      VoteType::Dislike => -1,
-    }
+  fn id(&self) -> &Url {
+    &self.id
   }
-}
-
-#[derive(Clone, Debug, Deserialize, Serialize)]
-#[serde(rename_all = "camelCase")]
-pub struct Vote {
-  pub(in crate::activities::voting) to: PublicUrl,
-  pub(in crate::activities::voting) object: Url,
-  pub(in crate::activities::voting) cc: [Url; 1],
-  #[serde(rename = "type")]
-  pub(in crate::activities::voting) kind: VoteType,
-  #[serde(flatten)]
-  pub(in crate::activities::voting) common: ActivityCommonFields,
-}
-
-impl Vote {
-  pub async fn send(
-    object: &PostOrComment,
-    actor: &Person,
-    community_id: CommunityId,
-    kind: VoteType,
-    context: &LemmyContext,
-  ) -> Result<(), LemmyError> {
-    let community = blocking(context.pool(), move |conn| {
-      Community::read(conn, community_id)
-    })
-    .await??;
-    let id = generate_activity_id(kind.clone())?;
 
-    let vote = Vote {
-      to: PublicUrl::Public,
-      object: object.ap_id(),
-      cc: [community.actor_id()],
-      kind,
-      common: ActivityCommonFields {
-        context: lemmy_context(),
-        id: id.clone(),
-        actor: actor.actor_id(),
-        unparsed: Default::default(),
-      },
-    };
-    let activity = AnnouncableActivities::Vote(vote);
-    send_to_community_new(activity, &id, actor, &community, vec![], context).await
+  fn actor(&self) -> &Url {
+    self.actor.inner()
   }
-}
 
-#[async_trait::async_trait(?Send)]
-impl ActivityHandler for Vote {
-  async fn verify(
-    &self,
-    context: &LemmyContext,
-    request_counter: &mut i32,
-  ) -> Result<(), LemmyError> {
-    verify_activity(self.common())?;
-    verify_person_in_community(&self.common.actor, &self.cc[0], context, request_counter).await?;
+  #[tracing::instrument(skip_all)]
+  async fn verify(&self, context: &Data<LemmyContext>) -> Result<(), LemmyError> {
+    insert_received_activity(&self.id, context).await?;
+    let community = self.community(context).await?;
+    verify_person_in_community(&self.actor, &community, context).await?;
+    let enable_downvotes = LocalSite::read(&mut context.pool())
+      .await
+      .map(|l| l.enable_downvotes)
+      .unwrap_or(true);
+    let enable_federated_downvotes = LocalSite::read(&mut context.pool())
+      .await
+      .map(|l| l.enable_federated_downvotes)
+      .unwrap_or(true);
+    if self.kind == VoteType::Dislike && (!enable_downvotes || !enable_federated_downvotes) {
+      return Err(anyhow!("Downvotes disabled").into());
+    }
     Ok(())
   }
 
-  async fn receive(
-    &self,
-    context: &LemmyContext,
-    request_counter: &mut i32,
-  ) -> Result<(), LemmyError> {
-    let actor =
-      get_or_fetch_and_upsert_person(&self.common.actor, context, request_counter).await?;
-    let object =
-      get_or_fetch_and_insert_post_or_comment(&self.object, context, request_counter).await?;
+  #[tracing::instrument(skip_all)]
+  async fn receive(self, context: &Data<LemmyContext>) -> Result<(), LemmyError> {
+    let actor = self.actor.dereference(context).await?;
+    let object = self.object.dereference(context).await?;
     match object {
-      PostOrComment::Post(p) => vote_post(&self.kind, actor, p.deref(), context).await,
-      PostOrComment::Comment(c) => vote_comment(&self.kind, actor, c.deref(), context).await,
+      PostOrComment::Post(p) => vote_post(&self.kind, actor, &p, context).await,
+      PostOrComment::Comment(c) => vote_comment(&self.kind, actor, &c, context).await,
     }
   }
-
-  fn common(&self) -> &ActivityCommonFields {
-    &self.common
-  }
 }