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

diff --git a/crates/apub/src/activities/voting/vote.rs b/crates/apub/src/activities/voting/vote.rs
index e74dea10..81bed456 100644
--- a/crates/apub/src/activities/voting/vote.rs
+++ b/crates/apub/src/activities/voting/vote.rs
@@ -1,137 +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::object_id::ObjectId,
-  ActorType,
+  insert_received_activity,
+  objects::{community::ApubCommunity, person::ApubPerson},
+  protocol::{
+    activities::voting::vote::{Vote, VoteType},
+    InCommunity,
+  },
   PostOrComment,
 };
-use activitystreams::{base::AnyBase, primitives::OneOrMany, unparsed::Unparsed};
-use anyhow::anyhow;
-use lemmy_api_common::blocking;
-use lemmy_apub_lib::{values::PublicUrl, ActivityFields, 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 TryFrom<i16> for VoteType {
-  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,
-    }
-  }
-}
-
-#[derive(Clone, Debug, Deserialize, Serialize, ActivityFields)]
-#[serde(rename_all = "camelCase")]
-pub struct Vote {
-  actor: ObjectId<Person>,
-  to: [PublicUrl; 1],
-  pub(in crate::activities::voting) object: ObjectId<PostOrComment>,
-  cc: [ObjectId<Community>; 1],
-  #[serde(rename = "type")]
-  pub(in crate::activities::voting) kind: VoteType,
-  id: Url,
-  #[serde(rename = "@context")]
-  context: OneOrMany<AnyBase>,
-  #[serde(flatten)]
-  unparsed: Unparsed,
-}
-
 impl Vote {
   pub(in crate::activities::voting) fn new(
-    object: &PostOrComment,
-    actor: &Person,
-    community: &Community,
+    object_id: ObjectId<PostOrComment>,
+    actor: &ApubPerson,
+    community: &ApubCommunity,
     kind: VoteType,
-    context: &LemmyContext,
+    context: &Data<LemmyContext>,
   ) -> Result<Vote, LemmyError> {
     Ok(Vote {
-      actor: ObjectId::new(actor.actor_id()),
-      to: [PublicUrl::Public],
-      object: ObjectId::new(object.ap_id()),
-      cc: [ObjectId::new(community.actor_id())],
+      actor: actor.id().into(),
+      object: object_id,
       kind: kind.clone(),
       id: generate_activity_id(kind, &context.settings().get_protocol_and_hostname())?,
-      context: lemmy_context(),
-      unparsed: Default::default(),
+      audience: Some(community.id().into()),
     })
   }
+}
 
-  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 vote = Vote::new(object, actor, &community, kind, context)?;
-    let vote_id = vote.id.clone();
+#[async_trait::async_trait]
+impl ActivityHandler for Vote {
+  type DataType = LemmyContext;
+  type Error = LemmyError;
 
-    let activity = AnnouncableActivities::Vote(vote);
-    send_to_community_new(activity, &vote_id, actor, &community, vec![], context).await
+  fn id(&self) -> &Url {
+    &self.id
   }
-}
 
-#[async_trait::async_trait(?Send)]
-impl ActivityHandler for Vote {
-  async fn verify(
-    &self,
-    context: &LemmyContext,
-    request_counter: &mut i32,
-  ) -> Result<(), LemmyError> {
-    verify_activity(self, &context.settings())?;
-    verify_person_in_community(&self.actor, &self.cc[0], context, request_counter).await?;
+  fn actor(&self) -> &Url {
+    self.actor.inner()
+  }
+
+  #[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 = self.actor.dereference(context, request_counter).await?;
-    let object = self.object.dereference(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,
     }
   }
 }