Merge branch 'refresh-actors' of foxhkron/kibou into master

src/activitypub/actor.rs

@@ -1,10 +1,13 @@
 use activitypub::activity::Activity;
+use activitypub::validator;
 use actor;
+use chrono::Duration;
 use chrono::Utc;
 use database;
 use env;
 use serde::{Deserialize, Serialize};
 use serde_json::{self, json};
+use web_handler;
 
 // ActivityStreams2/AcitivityPub properties are expressed in CamelCase
 #[allow(non_snake_case)]
@@ -60,7 +63,7 @@ pub fn add_follow(account: &str, source: &str, activity_id: &str) {
         follow_data.push(new_follow_data);
 
         actor.followers["activitypub"] = serde_json::to_value(follow_data).unwrap();
-        actor::update_followers(&database, &mut actor);
+        actor::update_followers(&database, actor);
     }
 }
 
@@ -80,13 +83,41 @@ pub fn remove_follow(account: &str, source: &str) {
         follow_data.remove(index);
 
         actor.followers["activitypub"] = serde_json::to_value(follow_data).unwrap();
-        actor::update_followers(&database, &mut actor);
+        actor::update_followers(&database, actor);
     }
 }
 
 // Refetches remote actor and detects changes to icon, username, keys and summary
-// [TODO]
-pub fn refresh() {}
+pub fn refresh(uri: String) {
+    std::thread::spawn(move || {
+        let expiration_time: chrono::DateTime<Utc> = Utc::now() - Duration::days(2);
+        let database = database::establish_connection();
+        let actor =
+            actor::get_actor_by_uri(&database, &uri).expect("Actor with this URI does not exist");
+
+        if actor.modified.timestamp() <= expiration_time.timestamp() && !actor.local {
+            println!("Refreshing actor {}", uri);
+
+            match web_handler::fetch_remote_object(&uri.to_string()) {
+                Ok(object) => {
+                    let parsed_object: serde_json::Value = serde_json::from_str(&object).unwrap();
+
+                    match validator::validate_actor(parsed_object) {
+                        Ok(actor) => {
+                            let serialized_actor: Actor = serde_json::from_value(actor).unwrap();
+
+                            actor::update(&database, create_internal_actor(serialized_actor));
+                        }
+                        Err(_) => {
+                            eprintln!("Unable to refresh actor, remote object is invalid: {}", uri)
+                        }
+                    }
+                }
+                Err(_) => eprintln!("Unable to refresh actor: {}", uri),
+            }
+        }
+    });
+}
 
 pub fn get_json_by_preferred_username(preferred_username: &str) -> serde_json::Value {
     let database = database::establish_connection();
@@ -182,5 +213,6 @@ pub fn create_internal_actor(ap_actor: Actor) -> actor::Actor {
         keys: serde_json::json!({"public" : ap_actor.publicKey["publicKeyPem"]}),
         followers: serde_json::json!({"activitypub": []}),
         created: Utc::now().naive_utc(),
+        modified: Utc::now().naive_utc(),
     }
 }

src/activitypub/validator.rs

@@ -1,3 +1,4 @@
+use activitypub;
 use activitypub::activity::Activity;
 use activitypub::activity::Object;
 use activitypub::controller::actor_exists;
@@ -32,6 +33,7 @@ pub fn validate_activity(
 
     let valid_actor = if activity.get("actor").is_some() {
         if actor_exists(activity["actor"].as_str().unwrap()) {
+            activitypub::actor::refresh(activity["actor"].as_str().unwrap().to_string());
             true
         } else {
             fetch_object_by_id(activity["actor"].as_str().unwrap().to_string());
@@ -98,6 +100,7 @@ pub fn validate_object(
 
     let valid_actor = if object.get("attributedTo").is_some() {
         if actor_exists(object["attributedTo"].as_str().unwrap()) {
+            activitypub::actor::refresh(object["attributedTo"].as_str().unwrap().to_string());
             true
         } else {
             fetch_object_by_id(object["attributedTo"].as_str().unwrap().to_string());

src/actor.rs

@@ -31,6 +31,7 @@ pub struct Actor {
     pub local: bool,
     pub keys: serde_json::Value,
     pub created: NaiveDateTime,
+    pub modified: NaiveDateTime,
 }
 
 impl Actor {
@@ -130,6 +131,7 @@ fn serialize_actor(sql_actor: QueryActor) -> Actor {
         local: sql_actor.local,
         followers: sql_actor.followers,
         created: sql_actor.created,
+        modified: sql_actor.modified,
     }
 }
 
@@ -235,17 +237,29 @@ pub fn create_actor(db_connection: &PgConnection, actor: &mut Actor) {
 /// Tests for this function are at `tests/actor.rs`
 /// - delete_local_actor()
 /// - delete_remote_actor()
-pub fn delete(db_connection: &PgConnection, actor: &mut Actor) {
+pub fn delete(db_connection: &PgConnection, actor: Actor) {
     diesel::delete(actors.filter(actor_uri.eq(&actor.actor_uri)))
         .execute(db_connection)
-        .expect("Error deleting user");
+        .expect("Could not delete actor");
 }
 
-pub fn update_followers(db_connection: &PgConnection, actor: &mut Actor) {
+pub fn update(db_connection: &PgConnection, actor: Actor) {
+    diesel::update(actors.filter(actor_uri.eq(&actor.actor_uri)))
+        .set((
+            username.eq(&actor.username),
+            summary.eq(&actor.summary),
+            icon.eq(&actor.icon),
+            keys.eq(&actor.keys),
+        ))
+        .execute(db_connection)
+        .expect("Could not update actor");
+}
+
+pub fn update_followers(db_connection: &PgConnection, actor: Actor) {
     diesel::update(actors.filter(actor_uri.eq(&actor.actor_uri)))
         .set(followers.eq(&actor.followers))
         .execute(db_connection)
-        .expect("Error updating followers");
+        .expect("Error occured while updating followers");
 }
 
 pub fn get_actor_by_acct(

src/bin/create_user.rs

@@ -58,6 +58,7 @@ fn main() {
         local: true,
         keys: serde_json::json!({}),
         created: Utc::now().naive_utc(),
+        modified: Utc::now().naive_utc(),
     };
 
     actor::create_actor(&database, &mut new_actor)

src/mastodon_api/controller.rs

@@ -87,6 +87,7 @@ pub fn account_create(form: &RegistrationForm) -> Option<Token> {
             local: true,
             keys: serde_json::json!({}),
             created: Utc::now().naive_utc(),
+            modified: Utc::now().naive_utc(),
         };
 
         actor::create_actor(&database, &mut new_actor);

src/tests/utils.rs

@@ -18,6 +18,7 @@ pub fn create_local_test_actor(username: &str) -> actor::Actor {
         local: true,
         followers: serde_json::json!({"activitypub": []}),
         created: Utc::now().naive_utc(),
+        modified: Utc::now().naive_utc(),
     };
 
     actor::create_actor(&database, &mut test_actor);
@@ -29,7 +30,7 @@ pub fn create_local_test_actor(username: &str) -> actor::Actor {
 
 pub fn delete_test_actor(mut actor: actor::Actor) {
     let database = database::establish_connection();
-    actor::delete(&database, &mut actor);
+    actor::delete(&database, actor);
 }
 
 pub fn create_remote_test_actor(username: &str) -> actor::Actor {
@@ -48,6 +49,7 @@ pub fn create_remote_test_actor(username: &str) -> actor::Actor {
         local: false,
         followers: serde_json::json!({"activitypub": []}),
         created: Utc::now().naive_utc(),
+        modified: Utc::now().naive_utc(),
     };
 
     actor::create_actor(&database, &mut test_actor);