Some more cleanup.

server/src/apub/activities.rs

@@ -29,7 +29,7 @@ where
   let json = serde_json::to_string(&activity)?;
   debug!("Sending activitypub activity {} to {:?}", json, to);
   // TODO it needs to expand, the to field needs to expand and dedup the followers urls
-  // The inbox is determined by first retrieving the target actor's JSON-LD representation and then looking up the inbox property. If a recipient is a Collection or OrderedCollection, then the server MUST dereference the collection (with the user's credentials) and discover inboxes for each item in the collection. Servers MUST limit the number of layers of indirections through collections which will be performed, which MAY be one. 
+  // The inbox is determined by first retrieving the target actor's JSON-LD representation and then looking up the inbox property. If a recipient is a Collection or OrderedCollection, then the server MUST dereference the collection (with the user's credentials) and discover inboxes for each item in the collection. Servers MUST limit the number of layers of indirections through collections which will be performed, which MAY be one.
   for t in to {
     let to_url = Url::parse(&t)?;
     if !is_apub_id_valid(&to_url) {
@@ -61,7 +61,7 @@ fn get_follower_inboxes(conn: &PgConnection, community: &Community) -> Result<Ve
 
 /// Send out information about a newly created post, to the followers of the community.
 pub fn post_create(post: &Post, creator: &User_, conn: &PgConnection) -> Result<(), Error> {
-  let page = post.as_page(conn)?;
+  let page = post.to_apub(conn)?;
   let community = Community::read(conn, post.community_id)?;
   let mut create = Create::new();
   populate_object_props(
@@ -84,7 +84,7 @@ pub fn post_create(post: &Post, creator: &User_, conn: &PgConnection) -> Result<
 
 /// Send out information about an edited post, to the followers of the community.
 pub fn post_update(post: &Post, creator: &User_, conn: &PgConnection) -> Result<(), Error> {
-  let page = post.as_page(conn)?;
+  let page = post.to_apub(conn)?;
   let community = Community::read(conn, post.community_id)?;
   let mut update = Update::new();
   populate_object_props(
@@ -139,7 +139,11 @@ pub fn accept_follow(follow: &Follow, conn: &PgConnection) -> Result<(), Error>
     .get_object_xsd_any_uri()
     .unwrap()
     .to_string();
-  let actor_uri = follow.follow_props.get_actor_xsd_any_uri().unwrap().to_string();
+  let actor_uri = follow
+    .follow_props
+    .get_actor_xsd_any_uri()
+    .unwrap()
+    .to_string();
   let community = Community::read_from_actor_id(conn, &community_uri)?;
   let mut accept = Accept::new();
   accept
@@ -151,7 +155,7 @@ pub fn accept_follow(follow: &Follow, conn: &PgConnection) -> Result<(), Error>
         .follow_props
         .get_actor_xsd_any_uri()
         .unwrap()
-        .to_string()
+        .to_string(),
     )?;
   accept
     .accept_props

server/src/apub/community.rs

@@ -5,10 +5,9 @@ pub struct CommunityQuery {
   community_name: String,
 }
 
-// TODO turn these as_group, as_page, into apub trait... something like to_apub
+impl ToApub<GroupExt> for Community {
-impl Community {
   // Turn a Lemmy Community into an ActivityPub group that can be sent out over the network.
-  fn as_group(&self, conn: &PgConnection) -> Result<GroupExt, Error> {
+  fn to_apub(&self, conn: &PgConnection) -> Result<GroupExt, Error> {
     let mut group = Group::default();
     let oprops: &mut ObjectProperties = group.as_mut();
 
@@ -45,29 +44,26 @@ impl Community {
 
     Ok(group.extend(actor_props).extend(public_key.to_ext()))
   }
+}
 
-  pub fn get_followers_url(&self) -> String {
+impl ActorType for Community {
-    format!("{}/followers", &self.actor_id)
+  fn actor_id(&self) -> String {
-  }
+    self.actor_id.to_owned()
-  pub fn get_inbox_url(&self) -> String {
-    format!("{}/inbox", &self.actor_id)
-  }
-  pub fn get_outbox_url(&self) -> String {
-    format!("{}/outbox", &self.actor_id)
   }
 }
 
-impl CommunityForm {
+impl FromApub<GroupExt> for CommunityForm {
   /// Parse an ActivityPub group received from another instance into a Lemmy community.
-  pub fn from_group(group: &GroupExt, conn: &PgConnection) -> Result<Self, Error> {
+  fn from_apub(group: &GroupExt, conn: &PgConnection) -> Result<Self, Error> {
     let oprops = &group.base.base.object_props;
     let aprops = &group.base.extension;
     let public_key: &PublicKey = &group.extension.public_key;
 
-    let followers_uri = Url::parse(&aprops.get_followers().unwrap().to_string())?;
+    let _followers_uri = Url::parse(&aprops.get_followers().unwrap().to_string())?;
-    let outbox_uri = Url::parse(&aprops.get_outbox().to_string())?;
+    let _outbox_uri = Url::parse(&aprops.get_outbox().to_string())?;
-    let _outbox = fetch_remote_object::<OrderedCollection>(&outbox_uri)?;
+    // TODO don't do extra fetching here
-    let _followers = fetch_remote_object::<UnorderedCollection>(&followers_uri)?;
+    // let _outbox = fetch_remote_object::<OrderedCollection>(&outbox_uri)?;
+    // let _followers = fetch_remote_object::<UnorderedCollection>(&followers_uri)?;
     let apub_id = &oprops.get_attributed_to_xsd_any_uri().unwrap().to_string();
     let creator = get_or_fetch_and_upsert_remote_user(&apub_id, conn)?;
 
@@ -101,10 +97,9 @@ impl CommunityForm {
 pub async fn get_apub_community_http(
   info: Path<CommunityQuery>,
   db: DbPoolParam,
-  chat_server: ChatServerParam,
 ) -> Result<HttpResponse<Body>, Error> {
   let community = Community::read_from_name(&&db.get()?, &info.community_name)?;
-  let c = community.as_group(&db.get().unwrap())?;
+  let c = community.to_apub(&db.get().unwrap())?;
   Ok(create_apub_response(&c))
 }
 
@@ -113,14 +108,13 @@ pub async fn get_apub_community_http(
 pub async fn get_apub_community_followers(
   info: Path<CommunityQuery>,
   db: DbPoolParam,
-  chat_server: ChatServerParam,
 ) -> Result<HttpResponse<Body>, Error> {
   let community = Community::read_from_name(&&db.get()?, &info.community_name)?;
 
-  let connection = establish_unpooled_connection();
+  let conn = db.get()?;
+
   //As we are an object, we validated that the community id was valid
-  let community_followers =
+  let community_followers = CommunityFollowerView::for_community(&conn, community.id).unwrap();
-    CommunityFollowerView::for_community(&connection, community.id).unwrap();
 
   let mut collection = UnorderedCollection::default();
   let oprops: &mut ObjectProperties = collection.as_mut();
@@ -133,32 +127,33 @@ pub async fn get_apub_community_followers(
   Ok(create_apub_response(&collection))
 }
 
-/// Returns an UnorderedCollection with the latest posts from the community.
+// TODO should not be doing this
-pub async fn get_apub_community_outbox(
+// Returns an UnorderedCollection with the latest posts from the community.
-  info: Path<CommunityQuery>,
+//pub async fn get_apub_community_outbox(
-  db: DbPoolParam,
+//  info: Path<CommunityQuery>,
-  chat_server: ChatServerParam,
+//  db: DbPoolParam,
-) -> Result<HttpResponse<Body>, Error> {
+//  chat_server: ChatServerParam,
-  let community = Community::read_from_name(&&db.get()?, &info.community_name)?;
+//) -> Result<HttpResponse<Body>, Error> {
+//  let community = Community::read_from_name(&&db.get()?, &info.community_name)?;
 
-  let conn = establish_unpooled_connection();
+//  let conn = establish_unpooled_connection();
-  //As we are an object, we validated that the community id was valid
+//  //As we are an object, we validated that the community id was valid
-  let community_posts: Vec<Post> = Post::list_for_community(&conn, community.id)?;
+//  let community_posts: Vec<Post> = Post::list_for_community(&conn, community.id)?;
 
-  let mut collection = OrderedCollection::default();
+//  let mut collection = OrderedCollection::default();
-  let oprops: &mut ObjectProperties = collection.as_mut();
+//  let oprops: &mut ObjectProperties = collection.as_mut();
-  oprops
+//  oprops
-    .set_context_xsd_any_uri(context())?
+//    .set_context_xsd_any_uri(context())?
-    .set_id(community.actor_id)?;
+//    .set_id(community.actor_id)?;
-  collection
+//  collection
-    .collection_props
+//    .collection_props
-    .set_many_items_base_boxes(
+//    .set_many_items_base_boxes(
-      community_posts
+//      community_posts
-        .iter()
+//        .iter()
-        .map(|c| c.as_page(&conn).unwrap())
+//        .map(|c| c.as_page(&conn).unwrap())
-        .collect(),
+//        .collect(),
-    )?
+//    )?
-    .set_total_items(community_posts.len() as u64)?;
+//    .set_total_items(community_posts.len() as u64)?;
 
-  Ok(create_apub_response(&collection))
+//  Ok(create_apub_response(&collection))
-}
+//}

server/src/apub/community_inbox.rs

@@ -6,6 +6,7 @@ pub enum CommunityAcceptedObjects {
   Follow(Follow),
 }
 
+// TODO Consolidate community and user inboxes into a single shared one
 /// Handler for all incoming activities to community inboxes.
 pub async fn community_inbox(
   request: HttpRequest,
@@ -18,11 +19,12 @@ pub async fn community_inbox(
   let community_name = path.into_inner();
   debug!(
     "Community {} received activity {:?}",
-    &community_name,
+    &community_name, &input
-    &input
   );
   match input {
-    CommunityAcceptedObjects::Follow(f) => handle_follow(&f, &request, &community_name, db, chat_server),
+    CommunityAcceptedObjects::Follow(f) => {
+      handle_follow(&f, &request, &community_name, db, chat_server)
+    }
   }
 }
 
@@ -33,14 +35,14 @@ fn handle_follow(
   request: &HttpRequest,
   community_name: &str,
   db: DbPoolParam,
-  chat_server: ChatServerParam,
+  _chat_server: ChatServerParam,
 ) -> Result<HttpResponse, Error> {
   let user_uri = follow
     .follow_props
     .get_actor_xsd_any_uri()
     .unwrap()
     .to_string();
-  let community_uri = follow
+  let _community_uri = follow
     .follow_props
     .get_object_xsd_any_uri()
     .unwrap()

server/src/apub/fetcher.rs

@@ -11,40 +11,8 @@ fn _fetch_node_info(domain: &str) -> Result<NodeInfo, Error> {
   Ok(fetch_remote_object::<NodeInfo>(&well_known.links.href)?)
 }
 
-// // TODO: move these to db
-// // TODO use the last_refreshed_at
-// fn upsert_community(
-//   community_form: &CommunityForm,
-//   conn: &PgConnection,
-// ) -> Result<Community, Error> {
-//   let existing = Community::read_from_actor_id(conn, &community_form.actor_id);
-//   match existing {
-//     Err(NotFound {}) => Ok(Community::create(conn, &community_form)?),
-//     Ok(c) => Ok(Community::update(conn, c.id, &community_form)?),
-//     Err(e) => Err(Error::from(e)),
-//   }
-// }
-// fn upsert_user(user_form: &UserForm, conn: &PgConnection) -> Result<User_, Error> {
-//   let existing = User_::read_from_actor_id(conn, &user_form.actor_id);
-//   Ok(match existing {
-//     Err(NotFound {}) => User_::create(conn, &user_form)?,
-//     Ok(u) => User_::update(conn, u.id, &user_form)?,
-//     Err(e) => return Err(Error::from(e)),
-//   })
-// }
-
-fn upsert_post(post_form: &PostForm, conn: &PgConnection) -> Result<Post, Error> {
-  let existing = Post::read_from_apub_id(conn, &post_form.ap_id);
-  match existing {
-    Err(NotFound {}) => Ok(Post::create(conn, &post_form)?),
-    Ok(p) => Ok(Post::update(conn, p.id, &post_form)?),
-    Err(e) => Err(Error::from(e)),
-  }
-}
-
 /// Fetch any type of ActivityPub object, handling things like HTTP headers, deserialisation,
 /// timeouts etc.
-/// TODO: add an optional param last_updated and only fetch if its too old
 pub fn fetch_remote_object<Response>(url: &Url) -> Result<Response, Error>
 where
   Response: for<'de> Deserialize<'de>,
@@ -71,15 +39,14 @@ where
 pub enum SearchAcceptedObjects {
   Person(Box<PersonExt>),
   Group(Box<GroupExt>),
-  // Page(Box<Page>),
 }
 
 /// Attempt to parse the query as URL, and fetch an ActivityPub object from it.
 ///
 /// Some working examples for use with the docker/federation/ setup:
-/// http://lemmy_alpha:8540/federation/c/main
+/// http://lemmy_alpha:8540/c/main
-/// http://lemmy_alpha:8540/federation/u/lemmy_alpha
+/// http://lemmy_alpha:8540/u/lemmy_alpha
-/// http://lemmy_alpha:8540/federation/p/3
+/// http://lemmy_alpha:8540/p/3
 pub fn search_by_apub_id(query: &str, conn: &PgConnection) -> Result<SearchResponse, Error> {
   let query_url = Url::parse(&query)?;
   let mut response = SearchResponse {
@@ -91,65 +58,47 @@ pub fn search_by_apub_id(query: &str, conn: &PgConnection) -> Result<SearchRespo
   };
   match fetch_remote_object::<SearchAcceptedObjects>(&query_url)? {
     SearchAcceptedObjects::Person(p) => {
-      let user = get_or_fetch_and_upsert_remote_user(query, &conn)?;
+      let user_uri = p.base.base.object_props.get_id().unwrap().to_string();
+      let user = get_or_fetch_and_upsert_remote_user(&user_uri, &conn)?;
       response.users = vec![UserView::read(conn, user.id)?];
     }
     SearchAcceptedObjects::Group(g) => {
-      let community = get_or_fetch_and_upsert_remote_community(query, &conn)?;
+      let community_uri = g.base.base.object_props.get_id().unwrap().to_string();
+      let community = get_or_fetch_and_upsert_remote_community(&community_uri, &conn)?;
+      // TODO Maybe at some point in the future, fetch all the history of a community
       // fetch_community_outbox(&c, conn)?;
       response.communities = vec![CommunityView::read(conn, community.id, None)?];
     }
-    // SearchAcceptedObjects::Page(p) => {
-    //   let p = upsert_post(&PostForm::from_page(&p, conn)?, conn)?;
-    //   response.posts = vec![PostView::read(conn, p.id, None)?];
-    // }
   }
   Ok(response)
 }
 
-// TODO It should not be fetching data from a community outbox.
-// All posts, comments, comment likes, etc should be posts to our community_inbox
-// The only data we should be periodically fetching (if it hasn't been fetched in the last day
-// maybe), is community and user actors
-// and user actors
-/// Fetch all posts in the outbox of the given user, and insert them into the database.
-fn fetch_community_outbox(community: &Community, conn: &PgConnection) -> Result<Vec<Post>, Error> {
-  let outbox_url = Url::parse(&community.get_outbox_url())?;
-  let outbox = fetch_remote_object::<OrderedCollection>(&outbox_url)?;
-  let items = outbox.collection_props.get_many_items_base_boxes();
-
-  Ok(
-    items
-      .unwrap()
-      .map(|obox: &BaseBox| -> Result<PostForm, Error> {
-        let page = obox.clone().to_concrete::<Page>()?;
-        PostForm::from_page(&page, conn)
-      })
-      .map(|pf| upsert_post(&pf?, conn))
-      .collect::<Result<Vec<Post>, Error>>()?,
-  )
-}
-
 /// Check if a remote user exists, create if not found, if its too old update it.Fetch a user, insert/update it in the database and return the user.
-pub fn get_or_fetch_and_upsert_remote_user(apub_id: &str, conn: &PgConnection) -> Result<User_, Error> {
+pub fn get_or_fetch_and_upsert_remote_user(
+  apub_id: &str,
+  conn: &PgConnection,
+) -> Result<User_, Error> {
   match User_::read_from_actor_id(&conn, &apub_id) {
     Ok(u) => {
       // If its older than a day, re-fetch it
       // TODO the less than needs to be tested
-      if u.last_refreshed_at.lt(&(naive_now() - chrono::Duration::days(1))) {   
+      if u
+        .last_refreshed_at
+        .lt(&(naive_now() - chrono::Duration::days(1)))
+      {
         debug!("Fetching and updating from remote user: {}", apub_id);
         let person = fetch_remote_object::<PersonExt>(&Url::parse(apub_id)?)?;
-        let uf = UserForm::from_person(&person)?;
+        let mut uf = UserForm::from_apub(&person, &conn)?;
         uf.last_refreshed_at = Some(naive_now());
         Ok(User_::update(&conn, u.id, &uf)?)
       } else {
         Ok(u)
       }
-    },
+    }
     Err(NotFound {}) => {
       debug!("Fetching and creating remote user: {}", apub_id);
       let person = fetch_remote_object::<PersonExt>(&Url::parse(apub_id)?)?;
-      let uf = UserForm::from_person(&person)?;
+      let uf = UserForm::from_apub(&person, &conn)?;
       Ok(User_::create(conn, &uf)?)
     }
     Err(e) => Err(Error::from(e)),
@@ -157,27 +106,66 @@ pub fn get_or_fetch_and_upsert_remote_user(apub_id: &str, conn: &PgConnection) -
 }
 
 /// Check if a remote community exists, create if not found, if its too old update it.Fetch a community, insert/update it in the database and return the community.
-pub fn get_or_fetch_and_upsert_remote_community(apub_id: &str, conn: &PgConnection) -> Result<Community, Error> {
+pub fn get_or_fetch_and_upsert_remote_community(
+  apub_id: &str,
+  conn: &PgConnection,
+) -> Result<Community, Error> {
   match Community::read_from_actor_id(&conn, &apub_id) {
     Ok(c) => {
       // If its older than a day, re-fetch it
       // TODO the less than needs to be tested
-      if c.last_refreshed_at.lt(&(naive_now() - chrono::Duration::days(1))) {   
+      if c
+        .last_refreshed_at
+        .lt(&(naive_now() - chrono::Duration::days(1)))
+      {
         debug!("Fetching and updating from remote community: {}", apub_id);
         let group = fetch_remote_object::<GroupExt>(&Url::parse(apub_id)?)?;
-        let cf = CommunityForm::from_group(&group, conn)?;
+        let mut cf = CommunityForm::from_apub(&group, conn)?;
         cf.last_refreshed_at = Some(naive_now());
         Ok(Community::update(&conn, c.id, &cf)?)
       } else {
         Ok(c)
       }
-    },
+    }
     Err(NotFound {}) => {
       debug!("Fetching and creating remote community: {}", apub_id);
       let group = fetch_remote_object::<GroupExt>(&Url::parse(apub_id)?)?;
-      let cf = CommunityForm::from_group(&group, conn)?;
+      let cf = CommunityForm::from_apub(&group, conn)?;
       Ok(Community::create(conn, &cf)?)
     }
     Err(e) => Err(Error::from(e)),
   }
 }
+
+// TODO Maybe add post, comment searching / caching at a later time
+// fn upsert_post(post_form: &PostForm, conn: &PgConnection) -> Result<Post, Error> {
+//   let existing = Post::read_from_apub_id(conn, &post_form.ap_id);
+//   match existing {
+//     Err(NotFound {}) => Ok(Post::create(conn, &post_form)?),
+//     Ok(p) => Ok(Post::update(conn, p.id, &post_form)?),
+//     Err(e) => Err(Error::from(e)),
+//   }
+// }
+
+// TODO It should not be fetching data from a community outbox.
+// All posts, comments, comment likes, etc should be posts to our community_inbox
+// The only data we should be periodically fetching (if it hasn't been fetched in the last day
+// maybe), is community and user actors
+// and user actors
+// Fetch all posts in the outbox of the given user, and insert them into the database.
+// fn fetch_community_outbox(community: &Community, conn: &PgConnection) -> Result<Vec<Post>, Error> {
+//   let outbox_url = Url::parse(&community.get_outbox_url())?;
+//   let outbox = fetch_remote_object::<OrderedCollection>(&outbox_url)?;
+//   let items = outbox.collection_props.get_many_items_base_boxes();
+
+//   Ok(
+//     items
+//       .unwrap()
+//       .map(|obox: &BaseBox| -> Result<PostForm, Error> {
+//         let page = obox.clone().to_concrete::<Page>()?;
+//         PostForm::from_page(&page, conn)
+//       })
+//       .map(|pf| upsert_post(&pf?, conn))
+//       .collect::<Result<Vec<Post>, Error>>()?,
+//   )
+// }

server/src/apub/mod.rs

@@ -8,64 +8,48 @@ pub mod user;
 pub mod user_inbox;
 
 use activitystreams::{
-  context, public, BaseBox,
-  actor::{
-    Actor,
-    Person,
-    Group,
-    properties::ApActorProperties, 
-  },
   activity::{Accept, Create, Follow, Update},
-  object::{
+  actor::{properties::ApActorProperties, Actor, Group, Person},
-    Page,
+  collection::UnorderedCollection,
-    properties::ObjectProperties,
+  context,
-  },
+  ext::{Ext, Extensible, Extension},
-  ext::{
+  object::{properties::ObjectProperties, Page},
-    Ext,
+  public, BaseBox,
-    Extensible,
-    Extension,
-  },
-  collection::{
-    UnorderedCollection, 
-    OrderedCollection,
-  },
 };
 use actix_web::body::Body;
-use actix_web::{web, Result, HttpRequest, HttpResponse};
 use actix_web::web::Path;
-use url::Url;
+use actix_web::{web, HttpRequest, HttpResponse, Result};
-use failure::Error;
-use failure::_core::fmt::Debug;
-use log::debug;
-use isahc::prelude::*;
 use diesel::result::Error::NotFound;
 use diesel::PgConnection;
+use failure::Error;
+use failure::_core::fmt::Debug;
 use http::request::Builder;
 use http_signature_normalization::Config;
+use isahc::prelude::*;
+use log::debug;
 use openssl::hash::MessageDigest;
 use openssl::sign::{Signer, Verifier};
 use openssl::{pkey::PKey, rsa::Rsa};
 use serde::{Deserialize, Serialize};
 use std::collections::BTreeMap;
 use std::time::Duration;
+use url::Url;
 
-use crate::routes::{DbPoolParam, ChatServerParam};
+use crate::api::site::SearchResponse;
-use crate::routes::nodeinfo::{NodeInfo, NodeInfoWellKnown};
+use crate::db::community::{Community, CommunityFollower, CommunityFollowerForm, CommunityForm};
-use crate::{convert_datetime, naive_now, Settings};
-use crate::db::community::{Community, CommunityForm, CommunityFollower, CommunityFollowerForm};
 use crate::db::community_view::{CommunityFollowerView, CommunityView};
 use crate::db::post::{Post, PostForm};
-use crate::db::post_view::PostView;
 use crate::db::user::{UserForm, User_};
 use crate::db::user_view::UserView;
-// TODO check on unpooled connection
+use crate::db::{Crud, Followable, SearchType};
-use crate::db::{Crud, Followable, SearchType, establish_unpooled_connection};
+use crate::routes::nodeinfo::{NodeInfo, NodeInfoWellKnown};
-use crate::api::site::SearchResponse;
+use crate::routes::{ChatServerParam, DbPoolParam};
+use crate::{convert_datetime, naive_now, Settings};
 
-use signatures::{PublicKey, PublicKeyExtension, sign};
 use activities::accept_follow;
+use fetcher::{get_or_fetch_and_upsert_remote_community, get_or_fetch_and_upsert_remote_user};
 use signatures::verify;
-use fetcher::{fetch_remote_object, get_or_fetch_and_upsert_remote_user, get_or_fetch_and_upsert_remote_community};
+use signatures::{sign, PublicKey, PublicKeyExtension};
 
 type GroupExt = Ext<Ext<Group, ApActorProperties>, PublicKeyExtension>;
 type PersonExt = Ext<Ext<Person, ApActorProperties>, PublicKeyExtension>;
@@ -140,3 +124,35 @@ fn is_apub_id_valid(apub_id: &Url) -> bool {
     None => false,
   }
 }
+
+// TODO Not sure good names for these
+pub trait ToApub<Response> {
+  fn to_apub(&self, conn: &PgConnection) -> Result<Response, Error>;
+}
+
+pub trait FromApub<ApubType> {
+  fn from_apub(apub: &ApubType, conn: &PgConnection) -> Result<Self, Error>
+  where
+    Self: Sized;
+}
+
+pub trait ActorType {
+  fn actor_id(&self) -> String;
+
+  fn get_inbox_url(&self) -> String {
+    format!("{}/inbox", &self.actor_id())
+  }
+  fn get_outbox_url(&self) -> String {
+    format!("{}/outbox", &self.actor_id())
+  }
+
+  fn get_followers_url(&self) -> String {
+    format!("{}/followers", &self.actor_id())
+  }
+  fn get_following_url(&self) -> String {
+    format!("{}/following", &self.actor_id())
+  }
+  fn get_liked_url(&self) -> String {
+    format!("{}/liked", &self.actor_id())
+  }
+}

server/src/apub/post.rs

@@ -9,16 +9,15 @@ pub struct PostQuery {
 pub async fn get_apub_post(
   info: Path<PostQuery>,
   db: DbPoolParam,
-  chat_server: ChatServerParam,
 ) -> Result<HttpResponse<Body>, Error> {
   let id = info.post_id.parse::<i32>()?;
   let post = Post::read(&&db.get()?, id)?;
-  Ok(create_apub_response(&post.as_page(&db.get().unwrap())?))
+  Ok(create_apub_response(&post.to_apub(&db.get().unwrap())?))
 }
 
-impl Post {
+impl ToApub<Page> for Post {
   // Turn a Lemmy post into an ActivityPub page that can be sent out over the network.
-  pub fn as_page(&self, conn: &PgConnection) -> Result<Page, Error> {
+  fn to_apub(&self, conn: &PgConnection) -> Result<Page, Error> {
     let mut page = Page::default();
     let oprops: &mut ObjectProperties = page.as_mut();
     let creator = User_::read(conn, self.creator_id)?;
@@ -54,9 +53,9 @@ impl Post {
   }
 }
 
-impl PostForm {
+impl FromApub<Page> for PostForm {
   /// Parse an ActivityPub page received from another instance into a Lemmy post.
-  pub fn from_page(page: &Page, conn: &PgConnection) -> Result<PostForm, Error> {
+  fn from_apub(page: &Page, conn: &PgConnection) -> Result<PostForm, Error> {
     let oprops = &page.object_props;
     let creator_actor_id = &oprops.get_attributed_to_xsd_any_uri().unwrap().to_string();
     let creator = get_or_fetch_and_upsert_remote_user(&creator_actor_id, &conn)?;

server/src/apub/user.rs

@@ -5,52 +5,54 @@ pub struct UserQuery {
   user_name: String,
 }
 
-// Turn a Lemmy user into an ActivityPub person and return it as json.
+impl ToApub<PersonExt> for User_ {
-pub async fn get_apub_user(
+  // Turn a Lemmy Community into an ActivityPub group that can be sent out over the network.
-  info: Path<UserQuery>,
+  fn to_apub(&self, _conn: &PgConnection) -> Result<PersonExt, Error> {
-  db: DbPoolParam,
+    // TODO go through all these to_string and to_owned()
-  chat_server: ChatServerParam,
+    let mut person = Person::default();
-) -> Result<HttpResponse<Body>, Error> {
+    let oprops: &mut ObjectProperties = person.as_mut();
-  let user = User_::find_by_email_or_username(&&db.get()?, &info.user_name)?;
+    oprops
+      .set_context_xsd_any_uri(context())?
+      .set_id(self.actor_id.to_string())?
+      .set_name_xsd_string(self.name.to_owned())?
+      .set_published(convert_datetime(self.published))?;
 
-  let mut person = Person::default();
+    if let Some(u) = self.updated {
-  let oprops: &mut ObjectProperties = person.as_mut();
+      oprops.set_updated(convert_datetime(u))?;
-  oprops
+    }
-    .set_context_xsd_any_uri(context())?
-    .set_id(user.actor_id.to_string())?
-    .set_name_xsd_string(user.name.to_owned())?
-    .set_published(convert_datetime(user.published))?;
 
-  if let Some(u) = user.updated {
+    if let Some(i) = &self.preferred_username {
-    oprops.set_updated(convert_datetime(u))?;
+      oprops.set_name_xsd_string(i.to_owned())?;
+    }
+
+    let mut actor_props = ApActorProperties::default();
+
+    actor_props
+      .set_inbox(self.get_inbox_url())?
+      .set_outbox(self.get_outbox_url())?
+      .set_followers(self.get_followers_url())?
+      .set_following(self.get_following_url())?
+      .set_liked(self.get_liked_url())?;
+
+    let public_key = PublicKey {
+      id: format!("{}#main-key", self.actor_id),
+      owner: self.actor_id.to_owned(),
+      public_key_pem: self.public_key.to_owned().unwrap(),
+    };
+
+    Ok(person.extend(actor_props).extend(public_key.to_ext()))
   }
-
-  if let Some(i) = &user.preferred_username {
-    oprops.set_name_xsd_string(i.to_owned())?;
-  }
-
-  let mut actor_props = ApActorProperties::default();
-
-  actor_props
-    .set_inbox(format!("{}/inbox", &user.actor_id))?
-    .set_outbox(format!("{}/outbox", &user.actor_id))?
-    .set_following(format!("{}/following", &user.actor_id))?
-    .set_liked(format!("{}/liked", &user.actor_id))?;
-
-  let public_key = PublicKey {
-    id: format!("{}#main-key", user.actor_id),
-    owner: user.actor_id.to_owned(),
-    public_key_pem: user.public_key.unwrap(),
-  };
-
-  Ok(create_apub_response(
-    &person.extend(actor_props).extend(public_key.to_ext()),
-  ))
 }
 
-impl UserForm {
+impl ActorType for User_ {
+  fn actor_id(&self) -> String {
+    self.actor_id.to_owned()
+  }
+}
+
+impl FromApub<PersonExt> for UserForm {
   /// Parse an ActivityPub person received from another instance into a Lemmy user.
-  pub fn from_person(person: &PersonExt) -> Result<Self, Error> {
+  fn from_apub(person: &PersonExt, _conn: &PgConnection) -> Result<Self, Error> {
     let oprops = &person.base.base.object_props;
     let aprops = &person.base.extension;
     let public_key: &PublicKey = &person.extension.public_key;
@@ -83,3 +85,13 @@ impl UserForm {
     })
   }
 }
+
+/// Return the user json over HTTP.
+pub async fn get_apub_user_http(
+  info: Path<UserQuery>,
+  db: DbPoolParam,
+) -> Result<HttpResponse<Body>, Error> {
+  let user = User_::find_by_email_or_username(&&db.get()?, &info.user_name)?;
+  let u = user.to_apub(&db.get().unwrap())?;
+  Ok(create_apub_response(&u))
+}

server/src/apub/user_inbox.rs

@@ -14,17 +14,13 @@ pub async fn user_inbox(
   input: web::Json<UserAcceptedObjects>,
   path: web::Path<String>,
   db: DbPoolParam,
-  chat_server: ChatServerParam,
+  _chat_server: ChatServerParam,
 ) -> Result<HttpResponse, Error> {
   // TODO: would be nice if we could do the signature check here, but we cant access the actor property
   let input = input.into_inner();
   let conn = &db.get().unwrap();
   let username = path.into_inner();
-  debug!(
+  debug!("User {} received activity: {:?}", &username, &input);
-    "User {} received activity: {:?}",
-    &username,
-    &input
-  );
 
   match input {
     UserAcceptedObjects::Create(c) => handle_create(&c, &request, &username, &conn),
@@ -37,18 +33,18 @@ pub async fn user_inbox(
 fn handle_create(
   create: &Create,
   request: &HttpRequest,
-  username: &str,
+  _username: &str,
   conn: &PgConnection,
 ) -> Result<HttpResponse, Error> {
   // TODO before this even gets named, because we don't know what type of object it is, we need
   // to parse this out
-  let community_uri = create
+  let user_uri = create
     .create_props
     .get_actor_xsd_any_uri()
     .unwrap()
     .to_string();
-  // TODO: should do this in a generic way so we dont need to know if its a user or a community
+
-  let user = fetch_remote_user(&Url::parse(&community_uri)?, conn)?;
+  let user = get_or_fetch_and_upsert_remote_user(&user_uri, &conn)?;
   verify(request, &user.public_key.unwrap())?;
 
   let page = create
@@ -58,7 +54,7 @@ fn handle_create(
     .unwrap()
     .to_owned()
     .to_concrete::<Page>()?;
-  let post = PostForm::from_page(&page, conn)?;
+  let post = PostForm::from_apub(&page, conn)?;
   Post::create(conn, &post)?;
   // TODO: send the new post out via websocket
   Ok(HttpResponse::Ok().finish())
@@ -68,15 +64,16 @@ fn handle_create(
 fn handle_update(
   update: &Update,
   request: &HttpRequest,
-  username: &str,
+  _username: &str,
   conn: &PgConnection,
 ) -> Result<HttpResponse, Error> {
-  let community_uri = update
+  let user_uri = update
     .update_props
     .get_actor_xsd_any_uri()
     .unwrap()
     .to_string();
-  let user = fetch_remote_user(&Url::parse(&community_uri)?, conn)?;
+
+  let user = get_or_fetch_and_upsert_remote_user(&user_uri, &conn)?;
   verify(request, &user.public_key.unwrap())?;
 
   let page = update
@@ -86,7 +83,7 @@ fn handle_update(
     .unwrap()
     .to_owned()
     .to_concrete::<Page>()?;
-  let post = PostForm::from_page(&page, conn)?;
+  let post = PostForm::from_apub(&page, conn)?;
   let id = Post::read_from_apub_id(conn, &post.ap_id)?.id;
   Post::update(conn, id, &post)?;
   // TODO: send the new post out via websocket
@@ -105,7 +102,7 @@ fn handle_accept(
     .get_actor_xsd_any_uri()
     .unwrap()
     .to_string();
-    
+
   let community = get_or_fetch_and_upsert_remote_community(&community_uri, conn)?;
   verify(request, &community.public_key.unwrap())?;
 

server/src/routes/federation.rs

@@ -21,11 +21,12 @@ pub fn config(cfg: &mut web::ServiceConfig) {
             "/c/{community_name}/followers",
             web::get().to(get_apub_community_followers),
           )
-          .route(
+          // TODO This is only useful for history which we aren't doing right now
-            "/c/{community_name}/outbox",
+          // .route(
-            web::get().to(get_apub_community_outbox),
+          //   "/c/{community_name}/outbox",
-          )
+          //   web::get().to(get_apub_community_outbox),
-          .route("/u/{user_name}", web::get().to(get_apub_user))
+          // )
+          .route("/u/{user_name}", web::get().to(get_apub_user_http))
           .route("/post/{post_id}", web::get().to(get_apub_post)),
       )
       // Inboxes dont work with the header guard for some reason.