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::{
  16     objects::get_or_fetch_and_insert_post_or_comment,
  17     person::get_or_fetch_and_upsert_person,
  18   },
  19   ActorType,
  20   PostOrComment,
  21 };
  22 use activitystreams::{
  23   activity::kind::UndoType,
  24   base::AnyBase,
  25   primitives::OneOrMany,
  26   unparsed::Unparsed,
  27 };
  28 use lemmy_api_common::blocking;
  29 use lemmy_apub_lib::{values::PublicUrl, verify_urls_match, ActivityFields, ActivityHandler};
  30 use lemmy_db_queries::Crud;
  31 use lemmy_db_schema::{
  32   source::{community::Community, person::Person},
  33   CommunityId,
  34 };
  35 use lemmy_utils::LemmyError;
  36 use lemmy_websocket::LemmyContext;
  37 use serde::{Deserialize, Serialize};
  38 use std::ops::Deref;
  39 use url::Url;
  40
  41 #[derive(Clone, Debug, Deserialize, Serialize, ActivityFields)]
  42 #[serde(rename_all = "camelCase")]
  43 pub struct UndoVote {
  44   actor: Url,
  45   to: PublicUrl,
  46   object: Vote,
  47   cc: [Url; 1],
  48   #[serde(rename = "type")]
  49   kind: UndoType,
  50   id: Url,
  51   #[serde(rename = "@context")]
  52   context: OneOrMany<AnyBase>,
  53   #[serde(flatten)]
  54   unparsed: Unparsed,
  55 }
  56
  57 impl UndoVote {
  58   pub async fn send(
  59     object: &PostOrComment,
  60     actor: &Person,
  61     community_id: CommunityId,
  62     kind: VoteType,
  63     context: &LemmyContext,
  64   ) -> Result<(), LemmyError> {
  65     let community = blocking(context.pool(), move |conn| {
  66       Community::read(conn, community_id)
  67     })
  68     .await??;
  69
  70     let object = Vote::new(object, actor, &community, kind.clone())?;
  71     let id = generate_activity_id(UndoType::Undo)?;
  72     let undo_vote = UndoVote {
  73       actor: actor.actor_id(),
  74       to: PublicUrl::Public,
  75       object,
  76       cc: [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)?;
  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 = get_or_fetch_and_upsert_person(&self.actor, context, request_counter).await?;
 107     let object =
 108       get_or_fetch_and_insert_post_or_comment(&self.object.object, context, request_counter)
 109         .await?;
 110     match object {
 111       PostOrComment::Post(p) => undo_vote_post(actor, p.deref(), context).await,
 112       PostOrComment::Comment(c) => undo_vote_comment(actor, c.deref(), context).await,
 113     }
 114   }
 115 }