Plume/plume-models/src/likes.rs

171 lines
5.1 KiB
Rust
Raw Normal View History

2018-06-10 13:13:07 +02:00
use activitypub::activity;
use chrono::NaiveDateTime;
use diesel::{self, ExpressionMethods, QueryDsl, RunQueryDsl};
2018-05-10 17:54:35 +02:00
use notifications::*;
use plume_common::activity_pub::{
inbox::{Deletable, FromActivity, Notify},
Id, IntoId, PUBLIC_VISIBILTY,
2018-05-19 09:39:59 +02:00
};
use posts::Post;
2018-05-10 17:54:35 +02:00
use schema::likes;
use users::User;
use Connection;
2018-05-10 17:54:35 +02:00
2018-09-27 23:06:40 +02:00
#[derive(Clone, 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,
pub creation_date: NaiveDateTime,
pub ap_url: String,
2018-05-10 17:54:35 +02:00
}
#[derive(Default, Insertable)]
2018-05-10 17:54:35 +02:00
#[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 {
insert!(likes, NewLike);
get!(likes);
find_by!(likes, find_by_ap_url, ap_url as &str);
find_by!(likes, find_by_user_on_post, user_id as i32, post_id as i32);
2018-05-10 18:07:23 +02:00
pub fn to_activity(&self, conn: &Connection) -> activity::Like {
2018-05-19 00:04:30 +02:00
let mut act = activity::Like::default();
act.like_props
.set_actor_link(
User::get(conn, self.user_id)
.expect("Like::to_activity: user error")
.into_id(),
)
.expect("Like::to_activity: actor error");
act.like_props
.set_object_link(
Post::get(conn, self.post_id)
.expect("Like::to_activity: post error")
.into_id(),
)
.expect("Like::to_activity: object error");
act.object_props
.set_to_link(Id::new(PUBLIC_VISIBILTY.to_string()))
.expect("Like::to_activity: to error");
act.object_props
.set_cc_link_vec::<Id>(vec![])
.expect("Like::to_activity: cc error");
act.object_props
.set_id_string(self.ap_url.clone())
.expect("Like::to_activity: id error");
2018-05-19 00:04:30 +02:00
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, Connection> for Like {
fn from_activity(conn: &Connection, like: activity::Like, _actor: Id) -> Like {
let liker = User::from_url(
conn,
like.like_props
.actor
.as_str()
.expect("Like::from_activity: actor error"),
);
let post = Post::find_by_ap_url(
conn,
like.like_props
.object
.as_str()
.expect("Like::from_activity: object error"),
);
let res = Like::insert(
conn,
NewLike {
post_id: post.expect("Like::from_activity: post error").id,
user_id: liker.expect("Like::from_activity: user error").id,
ap_url: like.object_props.id_string().unwrap_or_default(),
},
);
res.notify(conn);
res
}
}
impl Notify<Connection> for Like {
fn notify(&self, conn: &Connection) {
let post = Post::get(conn, self.post_id).expect("Like::notify: post error");
for author in post.get_authors(conn) {
Notification::insert(
conn,
NewNotification {
kind: notification_kind::LIKE.to_string(),
object_id: self.id,
user_id: author.id,
},
);
}
}
}
impl Deletable<Connection, activity::Undo> for Like {
fn delete(&self, conn: &Connection) -> activity::Undo {
diesel::delete(self)
.execute(conn)
.expect("Like::delete: delete error");
// delete associated notification if any
if let Some(notif) = Notification::find(conn, notification_kind::LIKE, self.id) {
diesel::delete(&notif)
.execute(conn)
.expect("Like::delete: notification error");
}
let mut act = activity::Undo::default();
act.undo_props
.set_actor_link(
User::get(conn, self.user_id)
.expect("Like::delete: user error")
.into_id(),
)
.expect("Like::delete: actor error");
act.undo_props
.set_object_object(self.to_activity(conn))
.expect("Like::delete: object error");
act.object_props
.set_id_string(format!("{}#delete", self.ap_url))
.expect("Like::delete: id error");
act.object_props
.set_to_link(Id::new(PUBLIC_VISIBILTY.to_string()))
.expect("Like::delete: to error");
act.object_props
.set_cc_link_vec::<Id>(vec![])
.expect("Like::delete: cc error");
act
}
fn delete_id(id: &str, actor_id: &str, conn: &Connection) {
if let Some(like) = Like::find_by_ap_url(conn, id) {
if let Some(user) = User::find_by_ap_url(conn, actor_id) {
if user.id == like.user_id {
like.delete(conn);
}
}
}
}
}
impl NewLike {
pub fn new(p: &Post, u: &User) -> Self {
let ap_url = format!("{}/like/{}", u.ap_url, p.ap_url);
NewLike {
post_id: p.id,
user_id: u.id,
ap_url
}
}
}