crates/apub/src/activities/voting/undo_vote.rs

   1 use crate::{
   2   activities::{
   3     community::announce::AnnouncableActivities,
   4     generate_activity_id,
   5     verify_activity,
   6     verify_person_in_community,
   7     voting::{
   8       undo_vote_comment,
   9       undo_vote_post,
  10       vote::{Vote, VoteType},
  11     },
  12   },
  13   activity_queue::send_to_community_new,
  14   extensions::context::lemmy_context,
  15   fetcher::object_id::ObjectId,
  16   ActorType,
  17   PostOrComment,
  18 };
  19 use activitystreams::{
  20   activity::kind::UndoType,
  21   base::AnyBase,
  22   primitives::OneOrMany,
  23   unparsed::Unparsed,
  24 };
  25 use lemmy_api_common::blocking;
  26 use lemmy_apub_lib::{values::PublicUrl, verify_urls_match, ActivityFields, ActivityHandler};
  27 use lemmy_db_queries::Crud;
  28 use lemmy_db_schema::{
  29   source::{community::Community, person::Person},
  30   CommunityId,
  31 };
  32 use lemmy_utils::LemmyError;
  33 use lemmy_websocket::LemmyContext;
  34 use serde::{Deserialize, Serialize};
  35 use std::ops::Deref;
  36 use url::Url;
  37
  38 #[derive(Clone, Debug, Deserialize, Serialize, ActivityFields)]
  39 #[serde(rename_all = "camelCase")]
  40 pub struct UndoVote {
  41   actor: ObjectId<Person>,
  42   to: [PublicUrl; 1],
  43   object: Vote,
  44   cc: [ObjectId<Community>; 1],
  45   #[serde(rename = "type")]
  46   kind: UndoType,
  47   id: Url,
  48   #[serde(rename = "@context")]
  49   context: OneOrMany<AnyBase>,
  50   #[serde(flatten)]
  51   unparsed: Unparsed,
  52 }
  53
  54 impl UndoVote {
  55   pub async fn send(
  56     object: &PostOrComment,
  57     actor: &Person,
  58     community_id: CommunityId,
  59     kind: VoteType,
  60     context: &LemmyContext,
  61   ) -> Result<(), LemmyError> {
  62     let community = blocking(context.pool(), move |conn| {
  63       Community::read(conn, community_id)
  64     })
  65     .await??;
  66
  67     let object = Vote::new(object, actor, &community, kind.clone(), context)?;
  68     let id = generate_activity_id(
  69       UndoType::Undo,
  70       &context.settings().get_protocol_and_hostname(),
  71     )?;
  72     let undo_vote = UndoVote {
  73       actor: ObjectId::new(actor.actor_id()),
  74       to: [PublicUrl::Public],
  75       object,
  76       cc: [ObjectId::new(community.actor_id())],
  77       kind: UndoType::Undo,
  78       id: id.clone(),
  79       context: lemmy_context(),
  80       unparsed: Default::default(),
  81     };
  82     let activity = AnnouncableActivities::UndoVote(undo_vote);
  83     send_to_community_new(activity, &id, actor, &community, vec![], context).await
  84   }
  85 }
  86
  87 #[async_trait::async_trait(?Send)]
  88 impl ActivityHandler for UndoVote {
  89   async fn verify(
  90     &self,
  91     context: &LemmyContext,
  92     request_counter: &mut i32,
  93   ) -> Result<(), LemmyError> {
  94     verify_activity(self, &context.settings())?;
  95     verify_person_in_community(&self.actor, &self.cc[0], context, request_counter).await?;
  96     verify_urls_match(self.actor(), self.object.actor())?;
  97     self.object.verify(context, request_counter).await?;
  98     Ok(())
  99   }
 100
 101   async fn receive(
 102     self,
 103     context: &LemmyContext,
 104     request_counter: &mut i32,
 105   ) -> Result<(), LemmyError> {
 106     let actor = self.actor.dereference(context, request_counter).await?;
 107     let object = self
 108       .object
 109       .object
 110       .dereference(context, request_counter)
 111       .await?;
 112     match object {
 113       PostOrComment::Post(p) => undo_vote_post(actor, p.deref(), context).await,
 114       PostOrComment::Comment(c) => undo_vote_comment(actor, c.deref(), context).await,
 115     }
 116   }
 117 }