lemmy_apub/src/activities/send/user.rs

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