crates/apub/src/activities/send/community.rs

   1 use crate::{
   2   activities::generate_activity_id,
   3   activity_queue::{send_activity_single_dest, send_to_community, send_to_community_followers},
   4   check_is_apub_id_valid,
   5   extensions::context::lemmy_context,
   6   fetcher::{get_or_fetch_and_upsert_actor, person::get_or_fetch_and_upsert_person},
   7   generate_moderators_url,
   8   insert_activity,
   9   objects::ToApub,
  10   ActorType,
  11   CommunityType,
  12 };
  13 use activitystreams::{
  14   activity::{
  15     kind::{
  16       AcceptType,
  17       AddType,
  18       AnnounceType,
  19       BlockType,
  20       DeleteType,
  21       LikeType,
  22       RemoveType,
  23       UndoType,
  24       UpdateType,
  25     },
  26     Accept,
  27     ActorAndObjectRefExt,
  28     Add,
  29     Announce,
  30     Block,
  31     Delete,
  32     Follow,
  33     OptTargetRefExt,
  34     Remove,
  35     Undo,
  36     Update,
  37   },
  38   base::{AnyBase, BaseExt, ExtendsExt},
  39   object::ObjectExt,
  40   public,
  41 };
  42 use anyhow::Context;
  43 use itertools::Itertools;
  44 use lemmy_api_common::blocking;
  45 use lemmy_db_queries::DbPool;
  46 use lemmy_db_schema::source::{community::Community, person::Person};
  47 use lemmy_db_views_actor::community_follower_view::CommunityFollowerView;
  48 use lemmy_utils::{location_info, settings::structs::Settings, LemmyError};
  49 use lemmy_websocket::LemmyContext;
  50 use url::Url;
  51
  52 impl ActorType for Community {
  53   fn is_local(&self) -> bool {
  54     self.local
  55   }
  56   fn actor_id(&self) -> Url {
  57     self.actor_id.to_owned().into_inner()
  58   }
  59   fn name(&self) -> String {
  60     self.name.clone()
  61   }
  62   fn public_key(&self) -> Option<String> {
  63     self.public_key.to_owned()
  64   }
  65   fn private_key(&self) -> Option<String> {
  66     self.private_key.to_owned()
  67   }
  68
  69   fn get_shared_inbox_or_inbox_url(&self) -> Url {
  70     self
  71       .shared_inbox_url
  72       .clone()
  73       .unwrap_or_else(|| self.inbox_url.to_owned())
  74       .into()
  75   }
  76 }
  77
  78 #[async_trait::async_trait(?Send)]
  79 impl CommunityType for Community {
  80   fn followers_url(&self) -> Url {
  81     self.followers_url.clone().into_inner()
  82   }
  83
  84   /// As a local community, accept the follow request from a remote person.
  85   async fn send_accept_follow(
  86     &self,
  87     follow: Follow,
  88     context: &LemmyContext,
  89   ) -> Result<(), LemmyError> {
  90     let actor_uri = follow
  91       .actor()?
  92       .as_single_xsd_any_uri()
  93       .context(location_info!())?;
  94     let person = get_or_fetch_and_upsert_person(actor_uri, context, &mut 0).await?;
  95
  96     let mut accept = Accept::new(
  97       self.actor_id.to_owned().into_inner(),
  98       follow.into_any_base()?,
  99     );
 100     accept
 101       .set_many_contexts(lemmy_context())
 102       .set_id(generate_activity_id(AcceptType::Accept)?)
 103       .set_to(person.actor_id());
 104
 105     send_activity_single_dest(accept, self, person.inbox_url.into(), context).await?;
 106     Ok(())
 107   }
 108
 109   /// If a remote community is updated by a local mod, send the updated info to the community's
 110   /// instance.
 111   async fn send_update(&self, mod_: Person, context: &LemmyContext) -> Result<(), LemmyError> {
 112     if self.local {
 113       // Do nothing, other instances will automatically refetch the community
 114     } else {
 115       let mut update = Update::new(
 116         mod_.actor_id(),
 117         self.to_apub(context.pool()).await?.into_any_base()?,
 118       );
 119       update
 120         .set_many_contexts(lemmy_context())
 121         .set_id(generate_activity_id(UpdateType::Update)?)
 122         .set_to(public())
 123         .set_many_ccs(vec![self.actor_id()]);
 124       send_to_community(update, &mod_, self, None, context).await?;
 125     }
 126     Ok(())
 127   }
 128
 129   /// If the creator of a community deletes the community, send this to all followers.
 130   ///
 131   /// We need to handle deletion by a remote mod separately.
 132   async fn send_delete(&self, mod_: Person, context: &LemmyContext) -> Result<(), LemmyError> {
 133     // Local mod, send directly from community to followers
 134     if self.local {
 135       let mut delete = Delete::new(self.actor_id(), self.actor_id());
 136       delete
 137         .set_many_contexts(lemmy_context())
 138         .set_id(generate_activity_id(DeleteType::Delete)?)
 139         .set_to(public())
 140         .set_many_ccs(vec![self.followers_url()]);
 141
 142       send_to_community_followers(delete, self, None, context).await?;
 143     }
 144     // Remote mod, send from mod to community
 145     else {
 146       let mut delete = Delete::new(mod_.actor_id(), self.actor_id());
 147       delete
 148         .set_many_contexts(lemmy_context())
 149         .set_id(generate_activity_id(DeleteType::Delete)?)
 150         .set_to(public())
 151         .set_many_ccs(vec![self.actor_id()]);
 152
 153       send_to_community(delete, &mod_, self, None, context).await?;
 154     }
 155     Ok(())
 156   }
 157
 158   /// If the creator of a community reverts the deletion of a community, send this to all followers.
 159   ///
 160   /// We need to handle undelete by a remote mod separately.
 161   async fn send_undo_delete(&self, mod_: Person, context: &LemmyContext) -> Result<(), LemmyError> {
 162     // Local mod, send directly from community to followers
 163     if self.local {
 164       let mut delete = Delete::new(self.actor_id(), self.actor_id());
 165       delete
 166         .set_many_contexts(lemmy_context())
 167         .set_id(generate_activity_id(DeleteType::Delete)?)
 168         .set_to(public())
 169         .set_many_ccs(vec![self.followers_url()]);
 170
 171       let mut undo = Undo::new(self.actor_id(), delete.into_any_base()?);
 172       undo
 173         .set_many_contexts(lemmy_context())
 174         .set_id(generate_activity_id(UndoType::Undo)?)
 175         .set_to(public())
 176         .set_many_ccs(vec![self.followers_url()]);
 177
 178       send_to_community_followers(undo, self, None, context).await?;
 179     }
 180     // Remote mod, send from mod to community
 181     else {
 182       let mut delete = Delete::new(mod_.actor_id(), self.actor_id());
 183       delete
 184         .set_many_contexts(lemmy_context())
 185         .set_id(generate_activity_id(DeleteType::Delete)?)
 186         .set_to(public())
 187         .set_many_ccs(vec![self.actor_id()]);
 188
 189       let mut undo = Undo::new(mod_.actor_id(), delete.into_any_base()?);
 190       undo
 191         .set_many_contexts(lemmy_context())
 192         .set_id(generate_activity_id(UndoType::Undo)?)
 193         .set_to(public())
 194         .set_many_ccs(vec![self.actor_id()]);
 195
 196       send_to_community(undo, &mod_, self, None, context).await?;
 197     }
 198     Ok(())
 199   }
 200
 201   /// If an admin removes a community, send this to all followers.
 202   async fn send_remove(&self, context: &LemmyContext) -> Result<(), LemmyError> {
 203     let mut remove = Remove::new(self.actor_id(), self.actor_id());
 204     remove
 205       .set_many_contexts(lemmy_context())
 206       .set_id(generate_activity_id(RemoveType::Remove)?)
 207       .set_to(public())
 208       .set_many_ccs(vec![self.followers_url()]);
 209
 210     send_to_community_followers(remove, self, None, context).await?;
 211     Ok(())
 212   }
 213
 214   /// If an admin reverts the removal of a community, send this to all followers.
 215   async fn send_undo_remove(&self, context: &LemmyContext) -> Result<(), LemmyError> {
 216     let mut remove = Remove::new(self.actor_id(), self.actor_id());
 217     remove
 218       .set_many_contexts(lemmy_context())
 219       .set_id(generate_activity_id(RemoveType::Remove)?)
 220       .set_to(public())
 221       .set_many_ccs(vec![self.followers_url()]);
 222
 223     // Undo that fake activity
 224     let mut undo = Undo::new(self.actor_id(), remove.into_any_base()?);
 225     undo
 226       .set_many_contexts(lemmy_context())
 227       .set_id(generate_activity_id(LikeType::Like)?)
 228       .set_to(public())
 229       .set_many_ccs(vec![self.followers_url()]);
 230
 231     send_to_community_followers(undo, self, None, context).await?;
 232     Ok(())
 233   }
 234
 235   /// Wraps an activity sent to the community in an announce, and then sends the announce to all
 236   /// community followers.
 237   ///
 238   /// If we are announcing a local activity, it hasn't been stored in the database yet, and we need
 239   /// to do it here, so that it can be fetched by ID. Remote activities are inserted into DB in the
 240   /// inbox.
 241   ///
 242   /// If the `object` of the announced activity is an actor, the actor ID needs to be passed as
 243   /// `object_actor`, so that the announce can be delivered to that user.
 244   async fn send_announce(
 245     &self,
 246     activity: AnyBase,
 247     object_actor: Option<Url>,
 248     context: &LemmyContext,
 249   ) -> Result<(), LemmyError> {
 250     let inner_id = activity.id().context(location_info!())?;
 251     if inner_id.domain() == Some(&Settings::get().get_hostname_without_port()?) {
 252       insert_activity(inner_id, activity.clone(), true, false, context.pool()).await?;
 253     }
 254
 255     let mut ccs = vec![self.followers_url()];
 256     let mut object_actor_inbox: Option<Url> = None;
 257     if let Some(actor_id) = object_actor {
 258       // Ignore errors, maybe its not actually an actor
 259       // TODO: should pass the actual request counter in, but that seems complicated
 260       let actor = get_or_fetch_and_upsert_actor(&actor_id, context, &mut 0)
 261         .await
 262         .ok();
 263       if let Some(actor) = actor {
 264         ccs.push(actor_id);
 265         object_actor_inbox = Some(actor.get_shared_inbox_or_inbox_url());
 266       }
 267     }
 268     let mut announce = Announce::new(self.actor_id(), activity);
 269     announce
 270       .set_many_contexts(lemmy_context())
 271       .set_id(generate_activity_id(AnnounceType::Announce)?)
 272       .set_to(public())
 273       .set_many_ccs(ccs);
 274
 275     send_to_community_followers(announce, self, object_actor_inbox, context).await?;
 276
 277     Ok(())
 278   }
 279
 280   /// For a given community, returns the inboxes of all followers.
 281   async fn get_follower_inboxes(&self, pool: &DbPool) -> Result<Vec<Url>, LemmyError> {
 282     let id = self.id;
 283
 284     let follows = blocking(pool, move |conn| {
 285       CommunityFollowerView::for_community(conn, id)
 286     })
 287     .await??;
 288     let inboxes = follows
 289       .into_iter()
 290       .filter(|f| !f.follower.local)
 291       .map(|f| f.follower.shared_inbox_url.unwrap_or(f.follower.inbox_url))
 292       .map(|i| i.into_inner())
 293       .unique()
 294       // Don't send to blocked instances
 295       .filter(|inbox| check_is_apub_id_valid(inbox, false).is_ok())
 296       .collect();
 297
 298     Ok(inboxes)
 299   }
 300
 301   async fn send_add_mod(
 302     &self,
 303     actor: &Person,
 304     added_mod: Person,
 305     context: &LemmyContext,
 306   ) -> Result<(), LemmyError> {
 307     let mut add = Add::new(actor.actor_id(), added_mod.actor_id());
 308     add
 309       .set_many_contexts(lemmy_context())
 310       .set_id(generate_activity_id(AddType::Add)?)
 311       .set_to(public())
 312       .set_many_ccs(vec![self.actor_id()])
 313       .set_target(generate_moderators_url(&self.actor_id)?.into_inner());
 314
 315     send_to_community(add, actor, self, Some(added_mod.actor_id()), context).await?;
 316     Ok(())
 317   }
 318
 319   async fn send_remove_mod(
 320     &self,
 321     actor: &Person,
 322     removed_mod: Person,
 323     context: &LemmyContext,
 324   ) -> Result<(), LemmyError> {
 325     let mut remove = Remove::new(actor.actor_id(), removed_mod.actor_id());
 326     remove
 327       .set_many_contexts(lemmy_context())
 328       .set_id(generate_activity_id(RemoveType::Remove)?)
 329       .set_to(public())
 330       .set_many_ccs(vec![self.actor_id()])
 331       .set_target(generate_moderators_url(&self.actor_id)?.into_inner());
 332
 333     send_to_community(remove, actor, self, Some(removed_mod.actor_id()), context).await?;
 334     Ok(())
 335   }
 336
 337   async fn send_block_user(
 338     &self,
 339     actor: &Person,
 340     blocked_user: Person,
 341     context: &LemmyContext,
 342   ) -> Result<(), LemmyError> {
 343     let mut block = Block::new(actor.actor_id(), blocked_user.actor_id());
 344     block
 345       .set_many_contexts(lemmy_context())
 346       .set_id(generate_activity_id(BlockType::Block)?)
 347       .set_to(public())
 348       .set_many_ccs(vec![self.actor_id()]);
 349
 350     send_to_community(block, actor, self, Some(blocked_user.actor_id()), context).await?;
 351     Ok(())
 352   }
 353
 354   async fn send_undo_block_user(
 355     &self,
 356     actor: &Person,
 357     unblocked_user: Person,
 358     context: &LemmyContext,
 359   ) -> Result<(), LemmyError> {
 360     let mut block = Block::new(actor.actor_id(), unblocked_user.actor_id());
 361     block
 362       .set_many_contexts(lemmy_context())
 363       .set_id(generate_activity_id(BlockType::Block)?)
 364       .set_to(public())
 365       .set_many_ccs(vec![self.actor_id()]);
 366
 367     // Undo that fake activity
 368     let mut undo = Undo::new(actor.actor_id(), block.into_any_base()?);
 369     undo
 370       .set_many_contexts(lemmy_context())
 371       .set_id(generate_activity_id(UndoType::Undo)?)
 372       .set_to(public())
 373       .set_many_ccs(vec![self.actor_id()]);
 374
 375     send_to_community(undo, actor, self, Some(unblocked_user.actor_id()), context).await?;
 376     Ok(())
 377   }
 378 }