Plume/src/models/likes.rs

156 lines
4.8 KiB
Rust
Raw Normal View History

2018-06-10 13:13:07 +02:00
use activitypub::activity;
2018-05-10 17:54:35 +02:00
use chrono;
2018-05-10 18:07:23 +02:00
use diesel::{self, PgConnection, QueryDsl, RunQueryDsl, ExpressionMethods};
2018-05-12 23:34:13 +02:00
use serde_json;
2018-05-10 17:54:35 +02:00
2018-05-19 09:39:59 +02:00
use activity_pub::{
Id,
2018-05-19 09:39:59 +02:00
IntoId,
actor::Actor,
inbox::{FromActivity, Deletable, Notify},
2018-05-19 09:39:59 +02:00
object::Object
};
use models::{
notifications::*,
2018-05-19 09:39:59 +02:00
posts::Post,
users::User
};
2018-05-10 17:54:35 +02:00
use schema::likes;
2018-05-12 22:56:57 +02:00
#[derive(Queryable, Identifiable)]
2018-05-10 17:54:35 +02:00
pub struct Like {
2018-05-10 18:07:23 +02:00
pub id: i32,
pub user_id: i32,
pub post_id: i32,
2018-05-13 12:44:05 +02:00
pub creation_date: chrono::NaiveDateTime,
pub ap_url: String
2018-05-10 17:54:35 +02:00
}
#[derive(Insertable)]
#[table_name = "likes"]
pub struct NewLike {
2018-05-10 18:07:23 +02:00
pub user_id: i32,
2018-05-13 12:44:05 +02:00
pub post_id: i32,
pub ap_url: String
2018-05-10 17:54:35 +02:00
}
impl Like {
2018-05-10 18:07:23 +02:00
pub fn insert(conn: &PgConnection, new: NewLike) -> Like {
diesel::insert_into(likes::table)
.values(new)
.get_result(conn)
.expect("Unable to insert new like")
}
2018-05-13 12:44:05 +02:00
pub fn update_ap_url(&self, conn: &PgConnection) {
if self.ap_url.len() == 0 {
diesel::update(self)
.set(likes::ap_url.eq(self.compute_id(conn)))
.get_result::<Like>(conn).expect("Couldn't update AP URL");
}
}
2018-05-10 17:54:35 +02:00
pub fn get(conn: &PgConnection, id: i32) -> Option<Like> {
likes::table.filter(likes::id.eq(id))
.limit(1)
.load::<Like>(conn)
.expect("Error loading like by ID")
.into_iter().nth(0)
}
2018-05-12 22:56:57 +02:00
2018-05-13 12:44:05 +02:00
pub fn find_by_ap_url(conn: &PgConnection, ap_url: String) -> Option<Like> {
likes::table.filter(likes::ap_url.eq(ap_url))
.limit(1)
.load::<Like>(conn)
.expect("Error loading like by AP URL")
.into_iter().nth(0)
}
pub fn find_by_user_on_post(conn: &PgConnection, user: &User, post: &Post) -> Option<Like> {
2018-05-12 22:56:57 +02:00
likes::table.filter(likes::post_id.eq(post.id))
.filter(likes::user_id.eq(user.id))
.limit(1)
.load::<Like>(conn)
.expect("Error loading like for user and post")
.into_iter().nth(0)
}
2018-05-19 00:04:30 +02:00
pub fn delete(&self, conn: &PgConnection) -> activity::Undo {
2018-05-12 22:56:57 +02:00
diesel::delete(self).execute(conn).unwrap();
2018-05-19 00:04:30 +02:00
let mut act = activity::Undo::default();
2018-06-10 13:13:07 +02:00
act.undo_props.set_actor_link(User::get(conn, self.user_id).unwrap().into_id()).unwrap();
act.undo_props.set_object_object(self.into_activity(conn)).unwrap();
2018-05-19 00:04:30 +02:00
act
}
pub fn into_activity(&self, conn: &PgConnection) -> activity::Like {
let mut act = activity::Like::default();
2018-06-10 13:13:07 +02:00
act.like_props.set_actor_link(User::get(conn, self.user_id).unwrap().into_id()).unwrap();
act.like_props.set_object_link(Post::get(conn, self.post_id).unwrap().into_id()).unwrap();
2018-05-19 00:04:30 +02:00
act.object_props.set_id_string(format!("{}/like/{}",
User::get(conn, self.user_id).unwrap().ap_url,
Post::get(conn, self.post_id).unwrap().ap_url
)).unwrap();
act
2018-05-12 22:56:57 +02:00
}
2018-05-10 17:54:35 +02:00
}
2018-05-12 23:34:13 +02:00
impl FromActivity<activity::Like> for Like {
fn from_activity(conn: &PgConnection, like: activity::Like, actor: Id) -> Like {
let liker = User::from_url(conn, like.like_props.actor.as_str().unwrap().to_string());
let post = Post::find_by_ap_url(conn, like.like_props.object.as_str().unwrap().to_string());
let res = Like::insert(conn, NewLike {
post_id: post.unwrap().id,
user_id: liker.unwrap().id,
ap_url: like.object_props.id_string().unwrap_or(String::from(""))
});
Like::notify(conn, like, actor);
res
}
}
impl Notify<activity::Like> for Like {
fn notify(conn: &PgConnection, like: activity::Like, actor: Id) {
let liker = User::from_url(conn, actor.into()).unwrap();
let post = Post::find_by_ap_url(conn, like.like_props.object_link::<Id>().unwrap().into()).unwrap();
for author in post.get_authors(conn) {
let post = post.clone();
Notification::insert(conn, NewNotification {
title: format!("{} liked your article", liker.display_name.clone()),
content: Some(post.title),
link: Some(post.ap_url),
user_id: author.id
});
}
}
}
impl Deletable for Like {
fn delete_activity(conn: &PgConnection, id: Id) -> bool {
if let Some(like) = Like::find_by_ap_url(conn, id.into()) {
like.delete(conn);
true
} else {
false
}
}
}
2018-05-12 23:34:13 +02:00
impl Object for Like {
fn serialize(&self, conn: &PgConnection) -> serde_json::Value {
json!({
"id": self.compute_id(conn)
})
}
fn compute_id(&self, conn: &PgConnection) -> String {
format!(
"{}/like/{}",
User::get(conn, self.user_id).unwrap().compute_id(conn),
Post::get(conn, self.post_id).unwrap().compute_id(conn)
)
}
}