Plume/src/models/comments.rs

142 lines
5.0 KiB
Rust
Raw Normal View History

2018-06-10 13:13:07 +02:00
use activitypub::{
2018-05-19 00:04:30 +02:00
activity::Create,
object::{Note, properties::ObjectProperties}
};
2018-05-09 22:35:02 +02:00
use chrono;
use diesel::{self, PgConnection, RunQueryDsl, QueryDsl, ExpressionMethods};
2018-05-10 17:36:32 +02:00
use serde_json;
2018-05-09 22:35:02 +02:00
2018-05-19 09:39:59 +02:00
use activity_pub::{
ap_url, IntoId, PUBLIC_VISIBILTY,
actor::Actor,
object::Object
};
use models::{
posts::Post,
users::User
};
2018-05-09 22:35:02 +02:00
use schema::comments;
2018-05-10 12:52:56 +02:00
#[derive(Queryable, Identifiable, Serialize, Clone)]
2018-05-09 22:35:02 +02:00
pub struct Comment {
pub id: i32,
pub content: String,
pub in_response_to_id: Option<i32>,
pub post_id: i32,
pub author_id: i32,
pub creation_date: chrono::NaiveDateTime,
pub ap_url: Option<String>,
pub sensitive: bool,
pub spoiler_text: String
}
#[derive(Insertable)]
#[table_name = "comments"]
pub struct NewComment {
pub content: String,
pub in_response_to_id: Option<i32>,
pub post_id: i32,
pub author_id: i32,
pub ap_url: Option<String>,
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<Comment> {
comments::table.filter(comments::id.eq(id))
.limit(1)
.load::<Comment>(conn)
.expect("Error loading comment by id")
.into_iter().nth(0)
}
2018-05-10 11:44:57 +02:00
pub fn find_by_post(conn: &PgConnection, post_id: i32) -> Vec<Comment> {
2018-05-10 11:44:57 +02:00
comments::table.filter(comments::post_id.eq(post_id))
.load::<Comment>(conn)
.expect("Error loading comment by post id")
}
pub fn find_by_ap_url(conn: &PgConnection, ap_url: String) -> Option<Comment> {
2018-05-10 12:52:56 +02:00
comments::table.filter(comments::ap_url.eq(ap_url))
.limit(1)
.load::<Comment>(conn)
.expect("Error loading comment by AP URL")
.into_iter().nth(0)
}
2018-05-10 11:44:57 +02:00
pub fn get_author(&self, conn: &PgConnection) -> User {
User::get(conn, self.author_id).unwrap()
}
2018-05-10 17:36:32 +02:00
pub fn get_post(&self, conn: &PgConnection) -> Post {
Post::get(conn, self.post_id).unwrap()
}
2018-05-19 00:04:30 +02:00
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::<Vec<String>>();
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::<serde_json::Value>::new()).unwrap()),
..ObjectProperties::default()
};
comment
}
pub fn create_activity(&self, conn: &PgConnection) -> Create {
let mut act = Create::default();
2018-06-10 13:13:07 +02:00
act.create_props.set_actor_link(self.get_author(conn).into_id()).unwrap();
act.create_props.set_object_object(self.into_activity(conn)).unwrap();
2018-05-19 00:04:30 +02:00
act.object_props.set_id_string(format!("{}/activity", self.ap_url.clone().unwrap())).unwrap();
act
}
2018-05-10 17:36:32 +02:00
}
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::<Vec<String>>();
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))
}
2018-05-09 22:35:02 +02:00
}