WIP: use the activitystreams crate

2018-05-16 19:20:44 +01:00
parent 1870f52332
commit c779b1c58a
14 changed files with 365 additions and 177 deletions
@@ -1,100 +1,138 @@
+use activitystreams_types::{
+    actor::Person,
+    activity::{Create, Follow, Like, Undo},
+    object::{Article, Note}
+};
+use activitystreams::activity::Activity;
 use diesel::PgConnection;
+use failure::Error;
 use serde_json;

-use activity_pub::activity;
-use activity_pub::actor::Actor;
-use activity_pub::outbox::broadcast;
+// use activity_pub::broadcast;
+use activity_pub::actor::Actor as APActor;
 use activity_pub::sign::*;
 use models::blogs::Blog;
 use models::comments::*;
-use models::follows::*;
-use models::likes::*;
+use models::likes;
 use models::posts::*;
 use models::users::User;

+#[derive(Fail, Debug)]
+enum InboxError {
+    #[fail(display = "The `type` property is required, but was not present")]
+    NoType,
+    #[fail(display = "Invalid activity type")]
+    InvalidType,
+    #[fail(display = "Couldn't undo activity")]
+    CantUndo
+}
+
 pub trait Inbox {
    fn received(&self, conn: &PgConnection, act: serde_json::Value);

-    fn save(&self, conn: &PgConnection, act: serde_json::Value) {
-        match act["type"].as_str().unwrap() {
-            "Create" => {
-                match act["object"]["type"].as_str().unwrap() {
-                    "Article" => {
-                        Post::insert(conn, NewPost {
-                            blog_id: 0, // TODO
-                            slug: String::from(""), // TODO
-                            title: String::from(""), // TODO
-                            content: act["object"]["content"].as_str().unwrap().to_string(),
-                            published: true,
-                            license: String::from("CC-0"),
-                            ap_url: act["object"]["url"].as_str().unwrap().to_string()
-                        });
-                    },
-                    "Note" => {
-                        let previous_comment = Comment::find_by_ap_url(conn, act["object"]["inReplyTo"].as_str().unwrap().to_string());
-                        Comment::insert(conn, NewComment {
-                            content: act["object"]["content"].as_str().unwrap().to_string(),
-                            spoiler_text: act["object"]["summary"].as_str().unwrap_or("").to_string(),
-                            ap_url: Some(act["object"]["id"].as_str().unwrap().to_string()),
-                            in_response_to_id: previous_comment.clone().map(|c| c.id),
-                            post_id: previous_comment
-                                .map(|c| c.post_id)
-                                .unwrap_or_else(|| Post::find_by_ap_url(conn, act["object"]["inReplyTo"].as_str().unwrap().to_string()).unwrap().id),
-                            author_id: User::from_url(conn, act["actor"].as_str().unwrap().to_string()).unwrap().id,
-                            sensitive: act["object"]["sensitive"].as_bool().unwrap_or(false)
-                        });
-                    }
-                    x => println!("Received a new {}, but didn't saved it", x)
-                }
-            },
-            "Follow" => {
-                let follow_act = activity::Follow::deserialize(act.clone());
-                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_act, from.id, u.id),
-                    None => {
-                        let blog = Blog::from_url(conn, follow_act.get_target_id()).unwrap();
-                        self.accept_follow(conn, &from, &blog, &follow_act, from.id, blog.id)
-                    }
-                };
+    fn new_article(&self, conn: &PgConnection, article: Article) -> Result<(), Error> {
+        Post::insert(conn, NewPost {
+            blog_id: 0, // TODO
+            slug: String::from(""), // TODO
+            title: article.object_props.name_string().unwrap(),
+            content: article.object_props.content_string().unwrap(),
+            published: true,
+            license: String::from("CC-0"),
+            ap_url: article.object_props.url_string()?
+        });
+        Ok(())
+    }
+
+    fn new_comment(&self, conn: &PgConnection, note: Note, actor_id: String) -> Result<(), Error> {
+        let previous_url = note.object_props.in_reply_to.clone().unwrap().as_str().unwrap().to_string();
+        let previous_comment = Comment::find_by_ap_url(conn, previous_url.clone());
+        Comment::insert(conn, NewComment {
+            content: note.object_props.content_string().unwrap(),
+            spoiler_text: note.object_props.summary_string().unwrap(),
+            ap_url: note.object_props.id_string().ok(),
+            in_response_to_id: previous_comment.clone().map(|c| c.id),
+            post_id: previous_comment
+                .map(|c| c.post_id)
+                .unwrap_or_else(|| Post::find_by_ap_url(conn, previous_url).unwrap().id),
+            author_id: User::from_url(conn, actor_id).unwrap().id,
+            sensitive: false // "sensitive" is not a standard property, we need to think about how to support it with the activitystreams crate
+        });
+        Ok(())
+    }
+
+    fn follow(&self, conn: &PgConnection, follow: Follow) -> Result<(), Error> {
+        let from = User::from_url(conn, follow.actor.as_str().unwrap().to_string()).unwrap();
+        match User::from_url(conn, follow.object.as_str().unwrap().to_string()) {
+            Some(u) => self.accept_follow(conn, &from, &u, &follow, from.id, u.id),
+            None => {
+                let blog = Blog::from_url(conn, follow.object.as_str().unwrap().to_string()).unwrap();
+                self.accept_follow(conn, &from, &blog, &follow, from.id, blog.id)
            }
-            "Like" => {
-                let liker = User::from_url(conn, act["actor"].as_str().unwrap().to_string());
-                let post = Post::find_by_ap_url(conn, act["object"].as_str().unwrap().to_string());
-                Like::insert(conn, NewLike {
-                    post_id: post.unwrap().id,
-                    user_id: liker.unwrap().id,
-                    ap_url: act["id"].as_str().unwrap().to_string()
-                });
-            },
-            "Undo" => {
-                match act["object"]["type"].as_str().unwrap() {
-                    "Like" => {
-                        let like = Like::find_by_ap_url(conn, act["object"]["id"].as_str().unwrap().to_string()).unwrap();
-                        like.delete(conn);
+        };
+        Ok(())
+    }
+
+    fn like(&self, conn: &PgConnection, like: Like) -> Result<(), Error> {
+        let liker = User::from_url(conn, like.actor.as_str().unwrap().to_string());
+        let post = Post::find_by_ap_url(conn, like.object.as_str().unwrap().to_string());
+        likes::Like::insert(conn, likes::NewLike {
+            post_id: post.unwrap().id,
+            user_id: liker.unwrap().id,
+            ap_url: like.object_props.id_string()?
+        });
+        Ok(())
+    }
+
+    fn unlike(&self, conn: &PgConnection, undo: Undo) -> Result<(), Error> {
+        let like = likes::Like::find_by_ap_url(conn, undo.object_object::<Like>()?.object_props.id_string()?).unwrap();
+        like.delete(conn);
+        Ok(())
+    }
+
+    fn save(&self, conn: &PgConnection, act: serde_json::Value) -> Result<(), Error> {
+        match act["type"].as_str() {
+            Some(t) => {
+                match t {
+                    "Create" => {
+                        let act: Create = serde_json::from_value(act.clone())?;
+                        match act.object["type"].as_str().unwrap() {
+                            "Article" => self.new_article(conn, act.object_object().unwrap()),
+                            "Note" => self.new_comment(conn, act.object_object().unwrap(), act.actor_object::<Person>()?.object_props.id_string()?),
+                            _ => Err(InboxError::InvalidType)?
+                        }
+                    },
+                    "Follow" => self.follow(conn, serde_json::from_value(act.clone())?),
+                    "Like" => self.like(conn, serde_json::from_value(act.clone())?),
+                    "Undo" => {
+                        let act: Undo = serde_json::from_value(act.clone())?;
+                        match act.object["type"].as_str().unwrap() {
+                            "Like" => self.unlike(conn, act),
+                            _ => Err(InboxError::CantUndo)?
+                        }
                    }
-                    x => println!("Wanted to Undo a {}, but it is not supported yet", x)
+                    _ => Err(InboxError::InvalidType)?
                }
            },
-            x => println!("Received unknow activity type: {}", x)
+            None => Err(InboxError::NoType)?
        }
    }

-    fn accept_follow<A: Actor + Signer, B: Actor + Clone, T: activity::Activity>(
+    fn accept_follow<A: Signer, B: Clone, T: Activity>(
        &self,
-        conn: &PgConnection,
-        from: &A,
-        target: &B,
-        follow: &T,
-        from_id: i32,
-        target_id: i32
+        _conn: &PgConnection,
+        _from: &A,
+        _target: &B,
+        _follow: &T,
+        _from_id: i32,
+        _target_id: i32
    ) {
-        Follow::insert(conn, NewFollow {
-            follower_id: from_id,
-            following_id: target_id
-        });
+        // TODO
+        //Follow::insert(conn, NewFollow {
+        //    follower_id: from_id,
+        //    following_id: target_id
+        //});

-        let accept = activity::Accept::new(target, follow, conn);
-        broadcast(conn, from, accept, vec![target.clone()]);
+        //let accept = activity::Accept::new(target, follow, conn);
+        //broadcast(conn, from, accept, vec![target.clone()]);
    }
 }
@@ -1,13 +1,20 @@
-use rocket::http::ContentType;
-use rocket::response::Content;
+use activitystreams_traits::{Activity, Object, Link};
+use array_tool::vec::Uniq;
+use diesel::PgConnection;
+use reqwest::Client;
+use rocket::http::{ContentType, Status};
+use rocket::response::{Response, Responder, Content};
+use rocket::request::Request;
 use rocket_contrib::Json;
 use serde_json;

-pub mod activity;
+use self::sign::Signable;
+
+// pub mod activity;
 pub mod actor;
 pub mod inbox;
 pub mod object;
-pub mod outbox;
+// pub mod outbox;
 pub mod request;
 pub mod sign;
 pub mod webfinger;
@@ -54,3 +61,59 @@ pub fn context() -> serde_json::Value {
 pub fn activity_pub(json: serde_json::Value) -> ActivityPub {
    Content(ContentType::new("application", "activity+json"), Json(json))
 }
+
+pub struct ActivityStream<T> (T);
+
+impl<T> ActivityStream<T> {
+    pub fn new(t: T) -> ActivityStream<T> {
+        ActivityStream(t)
+    }
+}
+
+impl<'r, O: Object> Responder<'r> for ActivityStream<O> {
+    fn respond_to(self, request: &Request) -> Result<Response<'r>, Status> {
+        serde_json::to_string(&self.0).respond_to(request)
+    }
+}
+
+pub fn broadcast<A: Activity + Clone, S: actor::Actor + sign::Signer, T: actor::Actor>(conn: &PgConnection, sender: &S, act: A, to: Vec<T>) {
+    let boxes = to.into_iter()
+        .map(|u| u.get_shared_inbox_url().unwrap_or(u.get_inbox_url()))
+        .collect::<Vec<String>>()
+        .unique();
+    for inbox in boxes {
+        // TODO: run it in Sidekiq or something like that
+        
+        let mut act = serde_json::to_value(act.clone()).unwrap();
+        act["@context"] = context();
+        let signed = act.sign(sender, conn);
+
+        let res = Client::new()
+            .post(&inbox[..])
+            .headers(request::headers())
+            .header(request::signature(sender, request::headers(), conn))
+            .header(request::digest(signed.to_string()))
+            .body(signed.to_string())
+            .send();
+        match res {
+            Ok(mut r) => println!("Successfully sent activity to inbox ({})\n\n{:?}", inbox, r.text().unwrap()),
+            Err(e) => println!("Error while sending to inbox ({:?})", e)
+        }
+    }
+}
+
+#[derive(Serialize, Deserialize)]
+pub struct Id {
+    #[serde(flatten)]
+    id: String
+}
+
+impl Id {
+    pub fn new<T: Into<String>>(id: T) -> Id {
+        Id {
+            id: id.into()
+        }
+    }
+}
+
+impl Link for Id {}
@@ -1,3 +1,4 @@
+use activitystreams_traits::{Activity, Object};
 use array_tool::vec::Uniq;
 use diesel::PgConnection;
 use reqwest::Client;
@@ -8,64 +9,7 @@ use serde_json;
 use std::sync::Arc;

 use activity_pub::{activity_pub, ActivityPub, context};
-use activity_pub::activity::Activity;
 use activity_pub::actor::Actor;
 use activity_pub::request;
 use activity_pub::sign::*;

-pub struct Outbox {
-    id: String,
-    items: Vec<Arc<Activity>>
-}
-
-impl Outbox {
-    pub fn new(id: String, items: Vec<Arc<Activity>>) -> Outbox {
-        Outbox {
-            id: id,
-            items: items
-        }
-    }
-
-    fn serialize(&self) -> ActivityPub {
-        let items = self.items.clone().into_iter().map(|i| i.serialize()).collect::<Vec<serde_json::Value>>();
-        activity_pub(json!({
-            "@context": context(),
-            "type": "OrderedCollection",
-            "id": self.id,
-            "totalItems": items.len(),
-            "orderedItems": items
-        }))
-    }
-}
-
-impl<'r> Responder<'r> for Outbox {
-    fn respond_to(self, request: &Request) -> Result<Response<'r>, Status> {
-        self.serialize().respond_to(request)
-    }
-}
-
-pub fn broadcast<A: Activity + Clone, S: Actor + Signer, T: Actor>(conn: &PgConnection, sender: &S, act: A, to: Vec<T>) {
-    let boxes = to.into_iter()
-        .map(|u| u.get_shared_inbox_url().unwrap_or(u.get_inbox_url()))
-        .collect::<Vec<String>>()
-        .unique();
-    for inbox in boxes {
-        // TODO: run it in Sidekiq or something like that        
-        
-        let mut act = act.serialize();
-        act["@context"] = context();
-        let signed = act.sign(sender, conn);
-        
-        let res = Client::new()
-            .post(&inbox[..])
-            .headers(request::headers())
-            .header(request::signature(sender, request::headers(), conn))
-            .header(request::digest(signed.to_string()))
-            .body(signed.to_string())
-            .send();
-        match res {
-            Ok(mut r) => println!("Successfully sent activity to inbox ({})\n\n{:?}", inbox, r.text().unwrap()),
-            Err(e) => println!("Error while sending to inbox ({:?})", e)
-        }
-    }
-}