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())?;
  68     let id = generate_activity_id(UndoType::Undo)?;
  69     let undo_vote = UndoVote {
  70       actor: ObjectId::new(actor.actor_id()),
  71       to: [PublicUrl::Public],
  72       object,
  73       cc: [ObjectId::new(community.actor_id())],
  74       kind: UndoType::Undo,
  75       id: id.clone(),
  76       context: lemmy_context(),
  77       unparsed: Default::default(),
  78     };
  79     let activity = AnnouncableActivities::UndoVote(undo_vote);
  80     send_to_community_new(activity, &id, actor, &community, vec![], context).await
  81   }
  82 }
  83
  84 #[async_trait::async_trait(?Send)]
  85 impl ActivityHandler for UndoVote {
  86   async fn verify(
  87     &self,
  88     context: &LemmyContext,
  89     request_counter: &mut i32,
  90   ) -> Result<(), LemmyError> {
  91     verify_activity(self)?;
  92     verify_person_in_community(&self.actor, &self.cc[0], context, request_counter).await?;
  93     verify_urls_match(self.actor(), self.object.actor())?;
  94     self.object.verify(context, request_counter).await?;
  95     Ok(())
  96   }
  97
  98   async fn receive(
  99     self,
 100     context: &LemmyContext,
 101     request_counter: &mut i32,
 102   ) -> Result<(), LemmyError> {
 103     let actor = self.actor.dereference(context, request_counter).await?;
 104     let object = self
 105       .object
 106       .object
 107       .dereference(context, request_counter)
 108       .await?;
 109     match object {
 110       PostOrComment::Post(p) => undo_vote_post(actor, p.deref(), context).await,
 111       PostOrComment::Comment(c) => undo_vote_comment(actor, c.deref(), context).await,
 112     }
 113   }
 114 }