crates/apub/src/http/community.rs

   1 use crate::{
   2   activities::{
   3     community::announce::{AnnouncableActivities, AnnounceActivity},
   4     extract_community,
   5     following::{follow::FollowCommunity, undo::UndoFollowCommunity},
   6   },
   7   context::lemmy_context,
   8   generate_moderators_url,
   9   generate_outbox_url,
  10   http::{
  11     create_apub_response,
  12     create_apub_tombstone_response,
  13     payload_to_string,
  14     receive_activity,
  15   },
  16   objects::ToApub,
  17 };
  18 use activitystreams::{
  19   base::{AnyBase, BaseExt},
  20   collection::{CollectionExt, OrderedCollection, UnorderedCollection},
  21   url::Url,
  22 };
  23 use actix_web::{body::Body, web, web::Payload, HttpRequest, HttpResponse};
  24 use lemmy_api_common::blocking;
  25 use lemmy_apub_lib::traits::{ActivityFields, ActivityHandler};
  26 use lemmy_db_queries::source::{activity::Activity_, community::Community_};
  27 use lemmy_db_schema::source::{activity::Activity, community::Community};
  28 use lemmy_db_views_actor::{
  29   community_follower_view::CommunityFollowerView,
  30   community_moderator_view::CommunityModeratorView,
  31 };
  32 use lemmy_utils::LemmyError;
  33 use lemmy_websocket::LemmyContext;
  34 use log::trace;
  35 use serde::{Deserialize, Serialize};
  36
  37 #[derive(Deserialize)]
  38 pub(crate) struct CommunityQuery {
  39   community_name: String,
  40 }
  41
  42 /// Return the ActivityPub json representation of a local community over HTTP.
  43 pub(crate) async fn get_apub_community_http(
  44   info: web::Path<CommunityQuery>,
  45   context: web::Data<LemmyContext>,
  46 ) -> Result<HttpResponse<Body>, LemmyError> {
  47   let community = blocking(context.pool(), move |conn| {
  48     Community::read_from_name(conn, &info.community_name)
  49   })
  50   .await??;
  51
  52   if !community.deleted {
  53     let apub = community.to_apub(context.pool()).await?;
  54
  55     Ok(create_apub_response(&apub))
  56   } else {
  57     Ok(create_apub_tombstone_response(&community.to_tombstone()?))
  58   }
  59 }
  60
  61 #[derive(Clone, Debug, Deserialize, Serialize, ActivityHandler, ActivityFields)]
  62 #[serde(untagged)]
  63 #[activity_handler(LemmyContext)]
  64 pub enum GroupInboxActivities {
  65   FollowCommunity(FollowCommunity),
  66   UndoFollowCommunity(UndoFollowCommunity),
  67   AnnouncableActivities(AnnouncableActivities),
  68 }
  69
  70 /// Handler for all incoming receive to community inboxes.
  71 pub async fn community_inbox(
  72   request: HttpRequest,
  73   payload: Payload,
  74   _path: web::Path<String>,
  75   context: web::Data<LemmyContext>,
  76 ) -> Result<HttpResponse, LemmyError> {
  77   let unparsed = payload_to_string(payload).await?;
  78   trace!("Received community inbox activity {}", unparsed);
  79   let activity = serde_json::from_str::<GroupInboxActivities>(&unparsed)?;
  80
  81   receive_group_inbox(activity.clone(), request, &context).await?;
  82
  83   if let GroupInboxActivities::AnnouncableActivities(announcable) = activity {
  84     let community = extract_community(&announcable.cc(), &context, &mut 0).await?;
  85     if community.local {
  86       AnnounceActivity::send(announcable, &community, vec![], &context).await?;
  87     }
  88   }
  89   Ok(HttpResponse::Ok().finish())
  90 }
  91
  92 pub(in crate::http) async fn receive_group_inbox(
  93   activity: GroupInboxActivities,
  94   request: HttpRequest,
  95   context: &LemmyContext,
  96 ) -> Result<HttpResponse, LemmyError> {
  97   receive_activity(request, activity.clone(), context).await
  98 }
  99
 100 /// Returns an empty followers collection, only populating the size (for privacy).
 101 pub(crate) async fn get_apub_community_followers(
 102   info: web::Path<CommunityQuery>,
 103   context: web::Data<LemmyContext>,
 104 ) -> Result<HttpResponse<Body>, LemmyError> {
 105   let community = blocking(context.pool(), move |conn| {
 106     Community::read_from_name(conn, &info.community_name)
 107   })
 108   .await??;
 109
 110   let community_id = community.id;
 111   let community_followers = blocking(context.pool(), move |conn| {
 112     CommunityFollowerView::for_community(conn, community_id)
 113   })
 114   .await??;
 115
 116   let mut collection = UnorderedCollection::new();
 117   collection
 118     .set_many_contexts(lemmy_context())
 119     .set_id(community.followers_url.into())
 120     .set_total_items(community_followers.len() as u64);
 121   Ok(create_apub_response(&collection))
 122 }
 123
 124 /// Returns the community outbox, which is populated by a maximum of 20 posts (but no other
 125 /// activites like votes or comments).
 126 pub(crate) async fn get_apub_community_outbox(
 127   info: web::Path<CommunityQuery>,
 128   context: web::Data<LemmyContext>,
 129 ) -> Result<HttpResponse<Body>, LemmyError> {
 130   let community = blocking(context.pool(), move |conn| {
 131     Community::read_from_name(conn, &info.community_name)
 132   })
 133   .await??;
 134
 135   let community_actor_id = community.actor_id.to_owned();
 136   let activities = blocking(context.pool(), move |conn| {
 137     Activity::read_community_outbox(conn, &community_actor_id)
 138   })
 139   .await??;
 140
 141   let activities = activities
 142     .iter()
 143     .map(AnyBase::from_arbitrary_json)
 144     .collect::<Result<Vec<AnyBase>, serde_json::Error>>()?;
 145   let len = activities.len();
 146   let mut collection = OrderedCollection::new();
 147   collection
 148     .set_many_items(activities)
 149     .set_many_contexts(lemmy_context())
 150     .set_id(generate_outbox_url(&community.actor_id)?.into())
 151     .set_total_items(len as u64);
 152   Ok(create_apub_response(&collection))
 153 }
 154
 155 pub(crate) async fn get_apub_community_inbox(
 156   info: web::Path<CommunityQuery>,
 157   context: web::Data<LemmyContext>,
 158 ) -> Result<HttpResponse<Body>, LemmyError> {
 159   let community = blocking(context.pool(), move |conn| {
 160     Community::read_from_name(conn, &info.community_name)
 161   })
 162   .await??;
 163
 164   let mut collection = OrderedCollection::new();
 165   collection
 166     .set_id(community.inbox_url.into())
 167     .set_many_contexts(lemmy_context());
 168   Ok(create_apub_response(&collection))
 169 }
 170
 171 pub(crate) async fn get_apub_community_moderators(
 172   info: web::Path<CommunityQuery>,
 173   context: web::Data<LemmyContext>,
 174 ) -> Result<HttpResponse<Body>, LemmyError> {
 175   let community = blocking(context.pool(), move |conn| {
 176     Community::read_from_name(conn, &info.community_name)
 177   })
 178   .await??;
 179
 180   // The attributed to, is an ordered vector with the creator actor_ids first,
 181   // then the rest of the moderators
 182   // TODO Technically the instance admins can mod the community, but lets
 183   // ignore that for now
 184   let cid = community.id;
 185   let moderators = blocking(context.pool(), move |conn| {
 186     CommunityModeratorView::for_community(conn, cid)
 187   })
 188   .await??;
 189
 190   let moderators: Vec<Url> = moderators
 191     .into_iter()
 192     .map(|m| m.moderator.actor_id.into())
 193     .collect();
 194   let mut collection = OrderedCollection::new();
 195   collection
 196     .set_id(generate_moderators_url(&community.actor_id)?.into())
 197     .set_total_items(moderators.len() as u64)
 198     .set_many_items(moderators)
 199     .set_many_contexts(lemmy_context());
 200   Ok(create_apub_response(&collection))
 201 }