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::activity::kind::UndoType;
  23 use lemmy_api_common::blocking;
  24 use lemmy_apub_lib::{values::PublicUrl, verify_urls_match, ActivityCommonFields, ActivityHandler};
  25 use lemmy_db_queries::Crud;
  26 use lemmy_db_schema::{
  27   source::{community::Community, person::Person},
  28   CommunityId,
  29 };
  30 use lemmy_utils::LemmyError;
  31 use lemmy_websocket::LemmyContext;
  32 use std::ops::Deref;
  33 use url::Url;
  34
  35 #[derive(Clone, Debug, serde::Deserialize, serde::Serialize)]
  36 #[serde(rename_all = "camelCase")]
  37 pub struct UndoVote {
  38   to: PublicUrl,
  39   object: Vote,
  40   cc: [Url; 1],
  41   #[serde(rename = "type")]
  42   kind: UndoType,
  43   #[serde(flatten)]
  44   common: ActivityCommonFields,
  45 }
  46
  47 impl UndoVote {
  48   pub async fn send(
  49     object: &PostOrComment,
  50     actor: &Person,
  51     community_id: CommunityId,
  52     kind: VoteType,
  53     context: &LemmyContext,
  54   ) -> Result<(), LemmyError> {
  55     let community = blocking(context.pool(), move |conn| {
  56       Community::read(conn, community_id)
  57     })
  58     .await??;
  59     let id = generate_activity_id(UndoType::Undo)?;
  60
  61     let undo_vote = UndoVote {
  62       to: PublicUrl::Public,
  63       object: Vote {
  64         to: PublicUrl::Public,
  65         object: object.ap_id(),
  66         cc: [community.actor_id()],
  67         kind: kind.clone(),
  68         common: ActivityCommonFields {
  69           context: lemmy_context(),
  70           id: generate_activity_id(kind)?,
  71           actor: actor.actor_id(),
  72           unparsed: Default::default(),
  73         },
  74       },
  75       cc: [community.actor_id()],
  76       kind: UndoType::Undo,
  77       common: ActivityCommonFields {
  78         context: lemmy_context(),
  79         id: id.clone(),
  80         actor: actor.actor_id(),
  81         unparsed: Default::default(),
  82       },
  83     };
  84     let activity = AnnouncableActivities::UndoVote(undo_vote);
  85     send_to_community_new(activity, &id, actor, &community, vec![], context).await
  86   }
  87 }
  88
  89 #[async_trait::async_trait(?Send)]
  90 impl ActivityHandler for UndoVote {
  91   async fn verify(
  92     &self,
  93     context: &LemmyContext,
  94     request_counter: &mut i32,
  95   ) -> Result<(), LemmyError> {
  96     verify_activity(self.common())?;
  97     verify_person_in_community(&self.common.actor, &self.cc[0], context, request_counter).await?;
  98     verify_urls_match(&self.common.actor, &self.object.common().actor)?;
  99     self.object.verify(context, request_counter).await?;
 100     Ok(())
 101   }
 102
 103   async fn receive(
 104     self,
 105     context: &LemmyContext,
 106     request_counter: &mut i32,
 107   ) -> Result<(), LemmyError> {
 108     let actor =
 109       get_or_fetch_and_upsert_person(&self.common.actor, context, request_counter).await?;
 110     let object =
 111       get_or_fetch_and_insert_post_or_comment(&self.object.object, context, request_counter)
 112         .await?;
 113     match object {
 114       PostOrComment::Post(p) => undo_vote_post(actor, p.deref(), context).await,
 115       PostOrComment::Comment(c) => undo_vote_comment(actor, c.deref(), context).await,
 116     }
 117   }
 118
 119   fn common(&self) -> &ActivityCommonFields {
 120     &self.common
 121   }
 122 }