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   fn user_id(&self) -> i32 {
  36     self.id
  37   }
  38
  39   /// As a given local user, send out a follow request to a remote community.
  40   async fn send_follow(
  41     &self,
  42     follow_actor_id: &Url,
  43     context: &LemmyContext,
  44   ) -> Result<(), LemmyError> {
  45     let follow_actor_id = follow_actor_id.to_string();
  46     let community = blocking(context.pool(), move |conn| {
  47       Community::read_from_actor_id(conn, &follow_actor_id)
  48     })
  49     .await??;
  50
  51     let mut follow = Follow::new(self.actor_id.to_owned(), community.actor_id()?);
  52     follow
  53       .set_context(activitystreams::context())
  54       .set_id(generate_activity_id(FollowType::Follow)?)
  55       .set_to(community.actor_id()?);
  56
  57     send_activity_single_dest(follow, self, community.get_inbox_url()?, context).await?;
  58     Ok(())
  59   }
  60
  61   async fn send_unfollow(
  62     &self,
  63     follow_actor_id: &Url,
  64     context: &LemmyContext,
  65   ) -> Result<(), LemmyError> {
  66     let follow_actor_id = follow_actor_id.to_string();
  67     let community = blocking(context.pool(), move |conn| {
  68       Community::read_from_actor_id(conn, &follow_actor_id)
  69     })
  70     .await??;
  71
  72     let mut follow = Follow::new(self.actor_id.to_owned(), community.actor_id()?);
  73     follow
  74       .set_context(activitystreams::context())
  75       .set_id(generate_activity_id(FollowType::Follow)?)
  76       .set_to(community.actor_id()?);
  77
  78     // Undo that fake activity
  79     let mut undo = Undo::new(Url::parse(&self.actor_id)?, follow.into_any_base()?);
  80     undo
  81       .set_context(activitystreams::context())
  82       .set_id(generate_activity_id(UndoType::Undo)?)
  83       .set_to(community.actor_id()?);
  84
  85     send_activity_single_dest(undo, self, community.get_inbox_url()?, context).await?;
  86     Ok(())
  87   }
  88
  89   async fn send_accept_follow(
  90     &self,
  91     _follow: Follow,
  92     _context: &LemmyContext,
  93   ) -> Result<(), LemmyError> {
  94     unimplemented!()
  95   }
  96
  97   async fn send_delete(&self, _context: &LemmyContext) -> Result<(), LemmyError> {
  98     unimplemented!()
  99   }
 100
 101   async fn send_undo_delete(&self, _context: &LemmyContext) -> Result<(), LemmyError> {
 102     unimplemented!()
 103   }
 104
 105   async fn send_remove(&self, _context: &LemmyContext) -> Result<(), LemmyError> {
 106     unimplemented!()
 107   }
 108
 109   async fn send_undo_remove(&self, _context: &LemmyContext) -> Result<(), LemmyError> {
 110     unimplemented!()
 111   }
 112
 113   async fn send_announce(
 114     &self,
 115     _activity: AnyBase,
 116     _context: &LemmyContext,
 117   ) -> Result<(), LemmyError> {
 118     unimplemented!()
 119   }
 120
 121   async fn get_follower_inboxes(&self, _pool: &DbPool) -> Result<Vec<Url>, LemmyError> {
 122     unimplemented!()
 123   }
 124 }