Accept follow requests

src/activity_pub/activity.rs

@@ -7,35 +7,52 @@ use activity_pub::object::Object;
 
 #[derive(Clone)]
 pub enum Activity {
-    Create(CreatePayload)
+    Create(Payload),
+    Accept(Payload)
 }
 impl Activity {
     pub fn serialize(&self) -> serde_json::Value {
+        json!({
+            "type": self.get_type(),
+            "actor": self.payload().by,
+            "object": self.payload().object,
+            "published": self.payload().date.to_rfc3339()
+        })
+    }
+
+    pub fn get_type(&self) -> String {
         match self {
-            Activity::Create(data) => json!({
-                "type": "Create",
-                "actor": data.by,
-                "object": data.object,
-                "published": data.date.to_rfc3339()
-            })
+            Activity::Accept(_) => String::from("Accept"),
+            Activity::Create(_) => String::from("Create")
+        }
+    }
+
+    pub fn payload(&self) -> Payload {
+        match self {
+            Activity::Accept(p) => p.clone(),
+            Activity::Create(p) => p.clone()
         }
     }
 
     pub fn create<T: Object, U: Actor>(by: &U, obj: T, conn: &PgConnection) -> Activity {
-        Activity::Create(CreatePayload::new(serde_json::Value::String(by.compute_id(conn)), obj.serialize(conn)))
+        Activity::Create(Payload::new(serde_json::Value::String(by.compute_id(conn)), obj.serialize(conn)))
+    }
+
+    pub fn accept<A: Actor>(by: &A, what: String, conn: &PgConnection) -> Activity {
+        Activity::Accept(Payload::new(serde_json::Value::String(by.compute_id(conn)), serde_json::Value::String(what)))
     }
 }
 
 #[derive(Clone)]
-pub struct CreatePayload {
+pub struct Payload {
     by: serde_json::Value,
     object: serde_json::Value,
     date: chrono::DateTime<chrono::Utc>
 }
 
-impl CreatePayload {
-    pub fn new(by: serde_json::Value, obj: serde_json::Value) -> CreatePayload {
-        CreatePayload {
+impl Payload {
+    pub fn new(by: serde_json::Value, obj: serde_json::Value) -> Payload {
+        Payload {
             by: by,
             object: obj,
             date: chrono::Utc::now()

src/activity_pub/actor.rs

@@ -19,7 +19,7 @@ impl ToString for ActorType {
     }
 }
 
-pub trait Actor {
+pub trait Actor: Sized {
     fn get_box_prefix() -> &'static str;
 
     fn get_actor_id(&self) -> String;
@@ -76,4 +76,6 @@ pub trait Actor {
             Err(_) => println!("Error while sending to inbox")
         }
     }
+
+    fn from_url(conn: &PgConnection, url: String) -> Option<Self>;
 }

src/activity_pub/inbox.rs

@@ -1,9 +1,15 @@
 use diesel::PgConnection;
+use diesel::associations::Identifiable;
 use serde_json;
 
+use activity_pub::activity::Activity;
+use activity_pub::actor::Actor;
+use models::blogs::Blog;
+use models::follows::{Follow, NewFollow};
 use models::posts::{Post, NewPost};
+use models::users::User;
 
-pub trait Inbox {
+pub trait Inbox: Actor + Sized {
     fn received(&self, conn: &PgConnection, act: serde_json::Value);
 
     fn save(&self, conn: &PgConnection, act: serde_json::Value) {
@@ -23,7 +29,30 @@ pub trait Inbox {
                     x => println!("Received a new {}, but didn't saved it", x)
                 }
             },
+            "Follow" => {
+                let follow_id = act["object"].as_str().unwrap().to_string();
+                let from = User::from_url(conn, act["actor"].as_str().unwrap().to_string()).unwrap();
+                match User::from_url(conn, act["object"].as_str().unwrap().to_string()) {
+                    Some(u) => self.accept_follow(conn, &from, &u, follow_id, from.id, u.id),
+                    None => {
+                        let blog = Blog::from_url(conn, follow_id.clone()).unwrap();
+                        self.accept_follow(conn, &from, &blog, follow_id, from.id, blog.id)
+                    }
+                };
+                
+                // TODO: notification
+            }
             x => println!("Received unknow activity type: {}", x)
         }
     }
+
+    fn accept_follow<A: Actor, B: Actor>(&self, conn: &PgConnection, from: &A, target: &B, follow_id: String, from_id: i32, target_id: i32) {
+        Follow::insert(conn, NewFollow {
+            follower_id: from_id,
+            following_id: target_id
+        });
+
+        let accept = Activity::accept(target, follow_id, conn);
+        from.send_to_inbox(conn, accept)
+    }
 }