Display remote profiles!

src/models/instance.rs

@@ -34,6 +34,10 @@ impl Instance {
             .into_iter().nth(0)
     }
 
+    pub fn local_id(conn: &PgConnection) -> i32 {
+        Instance::get_local(conn).unwrap().id
+    }
+
     pub fn insert<'a>(conn: &PgConnection, loc_dom: String, pub_dom: String, name: String, local: bool) -> Instance {
         diesel::insert_into(instances::table)
             .values(NewInstance {
@@ -54,6 +58,14 @@ impl Instance {
             .into_iter().nth(0)
     }
 
+    pub fn get_by_domain(conn: &PgConnection, domain: String) -> Option<Instance> {
+        instances::table.filter(instances::public_domain.eq(domain))
+            .limit(1)
+            .load::<Instance>(conn)
+            .expect("Couldn't load instance by domain")
+            .into_iter().nth(0)
+    }
+
     pub fn block(&self) {}
 
     pub fn has_admin(&self, conn: &PgConnection) -> bool {

src/models/users.rs

@@ -2,13 +2,17 @@ use bcrypt;
 use chrono::NaiveDateTime;
 use diesel::{self, QueryDsl, RunQueryDsl, ExpressionMethods, BelongingToDsl, PgConnection};
 use diesel::dsl::any;
+use reqwest::Client;
+use reqwest::header::{Accept, qitem};
+use reqwest::mime::Mime;
 use rocket::request::{self, FromRequest, Request};
 use rocket::outcome::IntoOutcome;
+use serde_json;
 
 use activity_pub::activity::Activity;
 use activity_pub::actor::{ActorType, Actor};
 use activity_pub::outbox::Outbox;
-use activity_pub::webfinger::Webfinger;
+use activity_pub::webfinger::{Webfinger, resolve};
 use db_conn::DbConn;
 use models::instance::Instance;
 use models::post_authors::PostAuthor;
@@ -17,7 +21,7 @@ use schema::users;
 
 pub const AUTH_COOKIE: &'static str = "user_id";
 
-#[derive(Queryable, Identifiable)]
+#[derive(Queryable, Identifiable, Serialize)]
 pub struct User {
     pub id: i32,
     pub username: String,
@@ -72,14 +76,77 @@ impl User {
             .into_iter().nth(0)
     }
 
-    pub fn find_by_name(conn: &PgConnection, username: String) -> Option<User> {
+    pub fn find_by_name(conn: &PgConnection, username: String, instance_id: i32) -> Option<User> {
         users::table.filter(users::username.eq(username))
+            .filter(users::instance_id.eq(instance_id))
             .limit(1)
             .load::<User>(conn)
             .expect("Error loading user by email")
             .into_iter().nth(0)
     }
 
+    pub fn find_local(conn: &PgConnection, username: String) -> Option<User> {
+        User::find_by_name(conn, username, Instance::local_id(conn))
+    }
+
+    pub fn find_by_fqn(conn: &PgConnection, fqn: String) -> Option<User> {
+        if fqn.contains("@") { // remote user
+            match Instance::get_by_domain(conn, String::from(fqn.split("@").last().unwrap())) {
+                Some(instance) => {
+                    match User::find_by_name(conn, String::from(fqn.split("@").nth(0).unwrap()), instance.id) {
+                        Some(u) => Some(u),
+                        None => User::fetch_from_webfinger(conn, fqn)
+                    }
+                },
+                None => User::fetch_from_webfinger(conn, fqn)
+            }
+        } else { // local user
+            User::find_local(conn, fqn)
+        }
+    }
+
+    fn fetch_from_webfinger(conn: &PgConnection, acct: String) -> Option<User> {
+        match resolve(acct) {
+            Ok(url) => {
+                let req = Client::new()
+                    .get(&url[..])
+                    .header(Accept(vec![qitem("application/activity+json".parse::<Mime>().unwrap())]))
+                    .send();
+                match req {
+                    Ok(mut res) => {
+                        let json: serde_json::Value = serde_json::from_str(&res.text().unwrap()).unwrap();
+                        Some(User::from_activity(conn, json, url.split("@").last().unwrap().to_string()))
+                    },
+                    Err(_) => None
+                }
+            },
+            Err(details) => {
+                println!("{}", details);
+                None
+            }
+        }
+    }
+
+    fn from_activity(conn: &PgConnection, acct: serde_json::Value, inst: String) -> User {
+        let instance = match Instance::get_by_domain(conn, inst.clone()) {
+            Some(instance) => instance,
+            None => {
+                Instance::insert(conn, String::from(""), inst.clone(), inst.clone(), false)
+            }
+        };
+        User::insert(conn, NewUser {
+            username: acct["preferredUsername"].as_str().unwrap().to_string(),
+            display_name: acct["name"].as_str().unwrap().to_string(),
+            outbox_url: acct["outbox"].as_str().unwrap().to_string(),
+            inbox_url: acct["inbox"].as_str().unwrap().to_string(),
+            is_admin: false,
+            summary: acct["summary"].as_str().unwrap().to_string(),
+            email: None,
+            hashed_password: None,
+            instance_id: instance.id
+        })
+    }
+
     pub fn hash_pass(pass: String) -> String {
         bcrypt::hash(pass.as_str(), bcrypt::DEFAULT_COST).unwrap()
     }