use activitypub::{ activity::Create, object::{Note, properties::ObjectProperties} }; use chrono; use diesel::{self, PgConnection, RunQueryDsl, QueryDsl, ExpressionMethods, dsl::any}; use serde_json; use activity_pub::{ ap_url, Id, IntoId, PUBLIC_VISIBILTY, actor::Actor, inbox::FromActivity, object::Object }; use models::{ instance::Instance, posts::Post, users::User }; use schema::comments; use safe_string::SafeString; #[derive(Queryable, Identifiable, Serialize, Clone)] pub struct Comment { pub id: i32, pub content: SafeString, pub in_response_to_id: Option, pub post_id: i32, pub author_id: i32, pub creation_date: chrono::NaiveDateTime, pub ap_url: Option, pub sensitive: bool, pub spoiler_text: String } #[derive(Insertable)] #[table_name = "comments"] pub struct NewComment { pub content: SafeString, pub in_response_to_id: Option, pub post_id: i32, pub author_id: i32, pub ap_url: Option, pub sensitive: bool, pub spoiler_text: String } impl Comment { pub fn insert (conn: &PgConnection, new: NewComment) -> Comment { diesel::insert_into(comments::table) .values(new) .get_result(conn) .expect("Error saving new comment") } pub fn get(conn: &PgConnection, id: i32) -> Option { comments::table.filter(comments::id.eq(id)) .limit(1) .load::(conn) .expect("Error loading comment by id") .into_iter().nth(0) } pub fn find_by_post(conn: &PgConnection, post_id: i32) -> Vec { comments::table.filter(comments::post_id.eq(post_id)) .load::(conn) .expect("Error loading comment by post id") } pub fn find_by_ap_url(conn: &PgConnection, ap_url: String) -> Option { comments::table.filter(comments::ap_url.eq(ap_url)) .limit(1) .load::(conn) .expect("Error loading comment by AP URL") .into_iter().nth(0) } pub fn get_author(&self, conn: &PgConnection) -> User { User::get(conn, self.author_id).unwrap() } pub fn get_post(&self, conn: &PgConnection) -> Post { Post::get(conn, self.post_id).unwrap() } pub fn into_activity(&self, conn: &PgConnection) -> Note { let mut to = self.get_author(conn).get_followers(conn).into_iter().map(|f| f.ap_url).collect::>(); to.append(&mut self.get_post(conn).get_receivers_urls(conn)); to.push(PUBLIC_VISIBILTY.to_string()); let mut comment = Note::default(); comment.object_props = ObjectProperties { id: Some(serde_json::to_value(self.ap_url.clone()).unwrap()), summary: Some(serde_json::to_value(self.spoiler_text.clone()).unwrap()), content: Some(serde_json::to_value(self.content.clone()).unwrap()), in_reply_to: Some(serde_json::to_value(self.in_response_to_id.map_or_else(|| self.get_post(conn).ap_url, |id| { let comm = Comment::get(conn, id).unwrap(); comm.ap_url.clone().unwrap_or(comm.compute_id(conn)) })).unwrap()), published: Some(serde_json::to_value(self.creation_date).unwrap()), attributed_to: Some(serde_json::to_value(self.get_author(conn).compute_id(conn)).unwrap()), to: Some(serde_json::to_value(to).unwrap()), cc: Some(serde_json::to_value(Vec::::new()).unwrap()), ..ObjectProperties::default() }; comment } pub fn create_activity(&self, conn: &PgConnection) -> Create { let mut act = Create::default(); act.create_props.set_actor_link(self.get_author(conn).into_id()).unwrap(); act.create_props.set_object_object(self.into_activity(conn)).unwrap(); act.object_props.set_id_string(format!("{}/activity", self.ap_url.clone().unwrap())).unwrap(); act } pub fn count_local(conn: &PgConnection) -> usize { use schema::users; let local_authors = users::table.filter(users::instance_id.eq(Instance::local_id(conn))).select(users::id); comments::table.filter(comments::author_id.eq(any(local_authors))) .load::(conn) .expect("Couldn't load local comments") .len() } } impl FromActivity for Comment { fn from_activity(conn: &PgConnection, note: Note, actor: Id) -> Comment { 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: SafeString::new(¬e.object_props.content_string().unwrap()), spoiler_text: note.object_props.summary_string().unwrap_or(String::from("")), 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.into()).unwrap().id, sensitive: false // "sensitive" is not a standard property, we need to think about how to support it with the activitypub crate }) } } impl Object for Comment { fn serialize(&self, conn: &PgConnection) -> serde_json::Value { let mut to = self.get_author(conn).get_followers(conn).into_iter().map(|f| f.ap_url).collect::>(); to.append(&mut self.get_post(conn).get_receivers_urls(conn)); to.push(PUBLIC_VISIBILTY.to_string()); json!({ "id": self.compute_id(conn), "type": "Note", "summary": self.spoiler_text, "content": self.content, "inReplyTo": self.in_response_to_id.map_or_else(|| self.get_post(conn).ap_url, |id| { let comm = Comment::get(conn, id).unwrap(); comm.ap_url.clone().unwrap_or(comm.compute_id(conn)) }), "published": self.creation_date, "attributedTo": self.get_author(conn).compute_id(conn), "to": to, "cc": [], "sensitive": self.sensitive, }) } fn compute_id(&self, conn: &PgConnection) -> String { ap_url(format!("{}#comment-{}", self.get_post(conn).compute_id(conn), self.id)) } }