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

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