lemmy_apub/src/activities/send/user.rs

   1 use crate::{
   2   activities::send::generate_activity_id,
   3   activity_queue::send_activity_single_dest,
   4   ActorType,
   5 };
   6 use activitystreams::{
   7   activity::{
   8     kind::{FollowType, UndoType},
   9     Follow,
  10     Undo,
  11   },
  12   base::{AnyBase, BaseExt, ExtendsExt},
  13   object::ObjectExt,
  14 };
  15 use lemmy_db::{community::Community, user::User_, DbPool};
  16 use lemmy_structs::blocking;
  17 use lemmy_utils::LemmyError;
  18 use lemmy_websocket::LemmyContext;
  19 use url::Url;
  20
  21 #[async_trait::async_trait(?Send)]
  22 impl ActorType for User_ {
  23   fn actor_id_str(&self) -> String {
  24     self.actor_id.to_owned()
  25   }
  26
  27   fn public_key(&self) -> Option<String> {
  28     self.public_key.to_owned()
  29   }
  30
  31   fn private_key(&self) -> Option<String> {
  32     self.private_key.to_owned()
  33   }
  34
  35   /// As a given local user, send out a follow request to a remote community.
  36   async fn send_follow(
  37     &self,
  38     follow_actor_id: &Url,
  39     context: &LemmyContext,
  40   ) -> Result<(), LemmyError> {
  41     let follow_actor_id = follow_actor_id.to_string();
  42     let community = blocking(context.pool(), move |conn| {
  43       Community::read_from_actor_id(conn, &follow_actor_id)
  44     })
  45     .await??;
  46
  47     let mut follow = Follow::new(self.actor_id.to_owned(), community.actor_id()?);
  48     follow
  49       .set_context(activitystreams::context())
  50       .set_id(generate_activity_id(FollowType::Follow)?)
  51       .set_to(community.actor_id()?);
  52
  53     send_activity_single_dest(follow, self, community.get_inbox_url()?, context).await?;
  54     Ok(())
  55   }
  56
  57   async fn send_unfollow(
  58     &self,
  59     follow_actor_id: &Url,
  60     context: &LemmyContext,
  61   ) -> Result<(), LemmyError> {
  62     let follow_actor_id = follow_actor_id.to_string();
  63     let community = blocking(context.pool(), move |conn| {
  64       Community::read_from_actor_id(conn, &follow_actor_id)
  65     })
  66     .await??;
  67
  68     let mut follow = Follow::new(self.actor_id.to_owned(), community.actor_id()?);
  69     follow
  70       .set_context(activitystreams::context())
  71       .set_id(generate_activity_id(FollowType::Follow)?)
  72       .set_to(community.actor_id()?);
  73
  74     // Undo that fake activity
  75     let mut undo = Undo::new(Url::parse(&self.actor_id)?, follow.into_any_base()?);
  76     undo
  77       .set_context(activitystreams::context())
  78       .set_id(generate_activity_id(UndoType::Undo)?)
  79       .set_to(community.actor_id()?);
  80
  81     send_activity_single_dest(undo, self, community.get_inbox_url()?, context).await?;
  82     Ok(())
  83   }
  84
  85   async fn send_accept_follow(
  86     &self,
  87     _follow: Follow,
  88     _context: &LemmyContext,
  89   ) -> Result<(), LemmyError> {
  90     unimplemented!()
  91   }
  92
  93   async fn send_delete(&self, _context: &LemmyContext) -> Result<(), LemmyError> {
  94     unimplemented!()
  95   }
  96
  97   async fn send_undo_delete(&self, _context: &LemmyContext) -> Result<(), LemmyError> {
  98     unimplemented!()
  99   }
 100
 101   async fn send_remove(&self, _context: &LemmyContext) -> Result<(), LemmyError> {
 102     unimplemented!()
 103   }
 104
 105   async fn send_undo_remove(&self, _context: &LemmyContext) -> Result<(), LemmyError> {
 106     unimplemented!()
 107   }
 108
 109   async fn send_announce(
 110     &self,
 111     _activity: AnyBase,
 112     _context: &LemmyContext,
 113   ) -> Result<(), LemmyError> {
 114     unimplemented!()
 115   }
 116
 117   async fn get_follower_inboxes(&self, _pool: &DbPool) -> Result<Vec<Url>, LemmyError> {
 118     unimplemented!()
 119   }
 120 }