LemmyNet/lemmy
2
0
Fork 0
mirror of https://github.com/LemmyNet/lemmy.git synced 2024-11-26 06:11:26 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Rewrite vote sending code

Browse source
This commit is contained in:
Felix Ableitner 2021-08-01 14:45:54 +02:00
parent 869b1b6f8f
commit 8149d5460d
10 changed files with 226 additions and 238 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

37
crates/api/src/comment.rs
View file

@ -7,12 +7,19 @@ use lemmy_api_common::{
comment::*,
get_local_user_view_from_jwt,
};
use lemmy_apub::ApubLikeableType;
use lemmy_apub::{
activities::voting::{
undo_vote::UndoVote,
vote::{Vote, VoteType},
},
PostOrComment,
};
use lemmy_db_queries::{source::comment::Comment_, Likeable, Saveable};
use lemmy_db_schema::{source::comment::*, LocalUserId};
use lemmy_db_views::{comment_view::CommentView, local_user_view::LocalUserView};
use lemmy_utils::{ApiError, ConnectionId, LemmyError};
use lemmy_websocket::{messages::SendComment, LemmyContext, UserOperation};
use std::convert::TryInto;
#[async_trait::async_trait(?Send)]
impl Perform for MarkCommentAsRead {
@ -170,6 +177,7 @@ impl Perform for CreateCommentLike {
// Only add the like if the score isnt 0
let comment = orig_comment.comment;
let object = PostOrComment::Comment(Box::new(comment));
let do_add = like_form.score != 0 && (like_form.score == 1 || like_form.score == -1);
if do_add {
let like_form2 = like_form.clone();
@ -178,17 +186,24 @@ impl Perform for CreateCommentLike {
return Err(ApiError::err("couldnt_like_comment").into());
}
if like_form.score == 1 {
comment.send_like(&local_user_view.person, context).await?;
} else if like_form.score == -1 {
comment
.send_dislike(&local_user_view.person, context)
.await?;
}
Vote::send(
&object,
&local_user_view.person,
orig_comment.community.id,
like_form.score.try_into()?,
context,
)
.await?;
} else {
comment
.send_undo_like(&local_user_view.person, context)
.await?;
// API doesn't distinguish between Undo/Like and Undo/Dislike
UndoVote::send(
&object,
&local_user_view.person,
orig_comment.community.id,
VoteType::Like,
context,
)
.await?;
}
// Have to refetch the comment to get the current state

40
crates/api/src/post.rs
View file

@ -10,14 +10,22 @@ use lemmy_api_common::{
post::*,
};
use lemmy_apub::{
activities::{post::create_or_update::CreateOrUpdatePost, CreateOrUpdateType},
ApubLikeableType,
activities::{
post::create_or_update::CreateOrUpdatePost,
voting::{
undo_vote::UndoVote,
vote::{Vote, VoteType},
},
CreateOrUpdateType,
},
PostOrComment,
};
use lemmy_db_queries::{source::post::Post_, Crud, Likeable, Saveable};
use lemmy_db_schema::source::{moderator::*, post::*};
use lemmy_db_views::post_view::PostView;
use lemmy_utils::{ApiError, ConnectionId, LemmyError};
use lemmy_websocket::{messages::SendPost, LemmyContext, UserOperation};
use std::convert::TryInto;
#[async_trait::async_trait(?Send)]
impl Perform for CreatePostLike {
@ -53,6 +61,9 @@ impl Perform for CreatePostLike {
})
.await??;
let community_id = post.community_id;
let object = PostOrComment::Post(Box::new(post));
// Only add the like if the score isnt 0
let do_add = like_form.score != 0 && (like_form.score == 1 || like_form.score == -1);
if do_add {
@ -62,15 +73,24 @@ impl Perform for CreatePostLike {
return Err(ApiError::err("couldnt_like_post").into());
}
if like_form.score == 1 {
post.send_like(&local_user_view.person, context).await?;
} else if like_form.score == -1 {
post.send_dislike(&local_user_view.person, context).await?;
}
Vote::send(
&object,
&local_user_view.person,
community_id,
like_form.score.try_into()?,
context,
)
.await?;
} else {
post
.send_undo_like(&local_user_view.person, context)
.await?;
// API doesn't distinguish between Undo/Like and Undo/Dislike
UndoVote::send(
&object,
&local_user_view.person,
community_id,
VoteType::Like,
context,
)
.await?;
}
// Mark the post as read

23
crates/api_crud/src/comment/create.rs
View file

@ -9,10 +9,14 @@ use lemmy_api_common::{
send_local_notifs,
};
use lemmy_apub::{
activities::{comment::create_or_update::CreateOrUpdateComment, CreateOrUpdateType},
activities::{
comment::create_or_update::CreateOrUpdateComment,
voting::vote::{Vote, VoteType},
CreateOrUpdateType,
},
generate_apub_endpoint,
ApubLikeableType,
EndpointType,
PostOrComment,
};
use lemmy_db_queries::{source::comment::Comment_, Crud, Likeable};
use lemmy_db_schema::source::comment::*;
@ -42,8 +46,9 @@ impl PerformCrud for CreateComment {
// Check for a community ban
let post_id = data.post_id;
let post = get_post(post_id, context.pool()).await?;
let community_id = post.community_id;
check_community_ban(local_user_view.person.id, post.community_id, context.pool()).await?;
check_community_ban(local_user_view.person.id, community_id, context.pool()).await?;
// Check if post is locked, no new comments
if post.locked {
@ -122,9 +127,15 @@ impl PerformCrud for CreateComment {
return Err(ApiError::err("couldnt_like_comment").into());
}
updated_comment
.send_like(&local_user_view.person, context)
.await?;
let object = PostOrComment::Comment(Box::new(updated_comment));
Vote::send(
&object,
&local_user_view.person,
community_id,
VoteType::Like,
context,
)
.await?;
let person_id = local_user_view.person.id;
let mut comment_view = blocking(context.pool(), move |conn| {

20
crates/api_crud/src/post/create.rs
View file

@ -8,10 +8,14 @@ use lemmy_api_common::{
post::*,
};
use lemmy_apub::{
activities::{post::create_or_update::CreateOrUpdatePost, CreateOrUpdateType},
activities::{
post::create_or_update::CreateOrUpdatePost,
voting::vote::{Vote, VoteType},
CreateOrUpdateType,
},
generate_apub_endpoint,
ApubLikeableType,
EndpointType,
PostOrComment,
};
use lemmy_db_queries::{source::post::Post_, Crud, Likeable};
use lemmy_db_schema::source::post::*;
@ -112,9 +116,15 @@ impl PerformCrud for CreatePost {
// Mark the post as read
mark_post_as_read(person_id, post_id, context.pool()).await?;
updated_post
.send_like(&local_user_view.person, context)
.await?;
let object = PostOrComment::Post(Box::new(updated_post));
Vote::send(
&object,
&local_user_view.person,
inserted_post.community_id,
VoteType::Like,
context,
)
.await?;
// Refetch the view
let inserted_post_id = inserted_post.id;

95
crates/apub/src/activities/send/comment.rs
View file

@ -3,15 +3,12 @@ use crate::{
activity_queue::send_to_community,
extensions::context::lemmy_context,
ActorType,
ApubLikeableType,
ApubObjectType,
};
use activitystreams::{
activity::{
kind::{DeleteType, DislikeType, LikeType, RemoveType, UndoType},
kind::{DeleteType, RemoveType, UndoType},
Delete,
Dislike,
Like,
Remove,
Undo,
},
@ -170,93 +167,3 @@ impl ApubObjectType for Comment {
Ok(())
}
}
#[async_trait::async_trait(?Send)]
impl ApubLikeableType for Comment {
async fn send_like(&self, creator: &Person, context: &LemmyContext) -> Result<(), LemmyError> {
let post_id = self.post_id;
let post = blocking(context.pool(), move |conn| Post::read(conn, post_id)).await??;
let community_id = post.community_id;
let community = blocking(context.pool(), move |conn| {
Community::read(conn, community_id)
})
.await??;
let mut like = Like::new(
creator.actor_id.to_owned().into_inner(),
self.ap_id.to_owned().into_inner(),
);
like
.set_many_contexts(lemmy_context())
.set_id(generate_activity_id(LikeType::Like)?)
.set_to(public())
.set_many_ccs(vec![community.actor_id()]);
send_to_community(like, creator, &community, None, context).await?;
Ok(())
}
async fn send_dislike(&self, creator: &Person, context: &LemmyContext) -> Result<(), LemmyError> {
let post_id = self.post_id;
let post = blocking(context.pool(), move |conn| Post::read(conn, post_id)).await??;
let community_id = post.community_id;
let community = blocking(context.pool(), move |conn| {
Community::read(conn, community_id)
})
.await??;
let mut dislike = Dislike::new(
creator.actor_id.to_owned().into_inner(),
self.ap_id.to_owned().into_inner(),
);
dislike
.set_many_contexts(lemmy_context())
.set_id(generate_activity_id(DislikeType::Dislike)?)
.set_to(public())
.set_many_ccs(vec![community.actor_id()]);
send_to_community(dislike, creator, &community, None, context).await?;
Ok(())
}
async fn send_undo_like(
&self,
creator: &Person,
context: &LemmyContext,
) -> Result<(), LemmyError> {
let post_id = self.post_id;
let post = blocking(context.pool(), move |conn| Post::read(conn, post_id)).await??;
let community_id = post.community_id;
let community = blocking(context.pool(), move |conn| {
Community::read(conn, community_id)
})
.await??;
let mut like = Like::new(
creator.actor_id.to_owned().into_inner(),
self.ap_id.to_owned().into_inner(),
);
like
.set_many_contexts(lemmy_context())
.set_id(generate_activity_id(DislikeType::Dislike)?)
.set_to(public())
.set_many_ccs(vec![community.actor_id()]);
// Undo that fake activity
let mut undo = Undo::new(
creator.actor_id.to_owned().into_inner(),
like.into_any_base()?,
);
undo
.set_many_contexts(lemmy_context())
.set_id(generate_activity_id(UndoType::Undo)?)
.set_to(public())
.set_many_ccs(vec![community.actor_id()]);
send_to_community(undo, creator, &community, None, context).await?;
Ok(())
}
}

86
crates/apub/src/activities/send/post.rs
View file

@ -3,15 +3,12 @@ use crate::{
activity_queue::send_to_community,
extensions::context::lemmy_context,
ActorType,
ApubLikeableType,
ApubObjectType,
};
use activitystreams::{
activity::{
kind::{DeleteType, DislikeType, LikeType, RemoveType, UndoType},
kind::{DeleteType, RemoveType, UndoType},
Delete,
Dislike,
Like,
Remove,
Undo,
},
@ -156,84 +153,3 @@ impl ApubObjectType for Post {
Ok(())
}
}
#[async_trait::async_trait(?Send)]
impl ApubLikeableType for Post {
async fn send_like(&self, creator: &Person, context: &LemmyContext) -> Result<(), LemmyError> {
let community_id = self.community_id;
let community = blocking(context.pool(), move |conn| {
Community::read(conn, community_id)
})
.await??;
let mut like = Like::new(
creator.actor_id.to_owned().into_inner(),
self.ap_id.to_owned().into_inner(),
);
like
.set_many_contexts(lemmy_context())
.set_id(generate_activity_id(LikeType::Like)?)
.set_to(public())
.set_many_ccs(vec![community.actor_id()]);
send_to_community(like, creator, &community, None, context).await?;
Ok(())
}
async fn send_dislike(&self, creator: &Person, context: &LemmyContext) -> Result<(), LemmyError> {
let community_id = self.community_id;
let community = blocking(context.pool(), move |conn| {
Community::read(conn, community_id)
})
.await??;
let mut dislike = Dislike::new(
creator.actor_id.to_owned().into_inner(),
self.ap_id.to_owned().into_inner(),
);
dislike
.set_many_contexts(lemmy_context())
.set_id(generate_activity_id(DislikeType::Dislike)?)
.set_to(public())
.set_many_ccs(vec![community.actor_id()]);
send_to_community(dislike, creator, &community, None, context).await?;
Ok(())
}
async fn send_undo_like(
&self,
creator: &Person,
context: &LemmyContext,
) -> Result<(), LemmyError> {
let community_id = self.community_id;
let community = blocking(context.pool(), move |conn| {
Community::read(conn, community_id)
})
.await??;
let mut like = Like::new(
creator.actor_id.to_owned().into_inner(),
self.ap_id.to_owned().into_inner(),
);
like
.set_many_contexts(lemmy_context())
.set_id(generate_activity_id(LikeType::Like)?)
.set_to(public())
.set_many_ccs(vec![community.actor_id()]);
// Undo that fake activity
let mut undo = Undo::new(
creator.actor_id.to_owned().into_inner(),
like.into_any_base()?,
);
undo
.set_many_contexts(lemmy_context())
.set_id(generate_activity_id(UndoType::Undo)?)
.set_to(public())
.set_many_ccs(vec![community.actor_id()]);
send_to_community(undo, creator, &community, None, context).await?;
Ok(())
}
}

4
crates/apub/src/activities/voting/mod.rs
View file

@ -27,7 +27,7 @@ async fn vote_comment(
comment_id,
post_id: comment.post_id,
person_id: actor.id,
score: vote_type.score(),
score: vote_type.into(),
};
let person_id = actor.id;
blocking(context.pool(), move |conn| {
@ -55,7 +55,7 @@ async fn vote_post(
let like_form = PostLikeForm {
post_id: post.id,
person_id: actor.id,
score: vote_type.score(),
score: vote_type.into(),
};
let person_id = actor.id;
blocking(context.pool(), move |conn| {

59
crates/apub/src/activities/voting/undo_vote.rs
View file

@ -1,17 +1,32 @@
use crate::{
activities::{
community::announce::AnnouncableActivities,
generate_activity_id,
verify_activity,
verify_person_in_community,
voting::{undo_vote_comment, undo_vote_post, vote::Vote},
voting::{
undo_vote_comment,
undo_vote_post,
vote::{Vote, VoteType},
},
},
activity_queue::send_to_community_new,
extensions::context::lemmy_context,
fetcher::{
objects::get_or_fetch_and_insert_post_or_comment,
person::get_or_fetch_and_upsert_person,
},
ActorType,
PostOrComment,
};
use activitystreams::activity::kind::UndoType;
use lemmy_api_common::blocking;
use lemmy_apub_lib::{values::PublicUrl, verify_urls_match, ActivityCommonFields, ActivityHandler};
use lemmy_db_queries::Crud;
use lemmy_db_schema::{
source::{community::Community, person::Person},
CommunityId,
};
use lemmy_utils::LemmyError;
use lemmy_websocket::LemmyContext;
use std::ops::Deref;
@ -29,6 +44,48 @@ pub struct UndoVote {
common: ActivityCommonFields,
}
impl UndoVote {
pub async fn send(
object: &PostOrComment,
actor: &Person,
community_id: CommunityId,
kind: VoteType,
context: &LemmyContext,
) -> Result<(), LemmyError> {
let community = blocking(context.pool(), move |conn| {
Community::read(conn, community_id)
})
.await??;
let id = generate_activity_id(UndoType::Undo)?;
let undo_vote = UndoVote {
to: PublicUrl::Public,
object: Vote {
to: PublicUrl::Public,
object: object.ap_id(),
cc: [community.actor_id()],
kind: kind.clone(),
common: ActivityCommonFields {
context: lemmy_context(),
id: generate_activity_id(kind)?,
actor: actor.actor_id(),
unparsed: Default::default(),
},
},
cc: [community.actor_id()],
kind: UndoType::Undo,
common: ActivityCommonFields {
context: lemmy_context(),
id: id.clone(),
actor: actor.actor_id(),
unparsed: Default::default(),
},
};
let activity = AnnouncableActivities::UndoVote(undo_vote);
send_to_community_new(activity, &id, actor, &community, vec![], context).await
}
}
#[async_trait::async_trait(?Send)]
impl ActivityHandler for UndoVote {
async fn verify(

75
crates/apub/src/activities/voting/vote.rs
View file

@ -1,46 +1,103 @@
use crate::{
activities::{
community::announce::AnnouncableActivities,
generate_activity_id,
verify_activity,
verify_person_in_community,
voting::{vote_comment, vote_post},
},
activity_queue::send_to_community_new,
extensions::context::lemmy_context,
fetcher::{
objects::get_or_fetch_and_insert_post_or_comment,
person::get_or_fetch_and_upsert_person,
},
ActorType,
PostOrComment,
};
use anyhow::anyhow;
use lemmy_api_common::blocking;
use lemmy_apub_lib::{values::PublicUrl, ActivityCommonFields, ActivityHandler};
use lemmy_db_queries::Crud;
use lemmy_db_schema::{
source::{community::Community, person::Person},
CommunityId,
};
use lemmy_utils::LemmyError;
use lemmy_websocket::LemmyContext;
use serde::{Deserialize, Serialize};
use std::ops::Deref;
use std::{convert::TryFrom, ops::Deref};
use strum_macros::ToString;
use url::Url;
#[derive(Clone, Debug, Deserialize, Serialize)]
#[derive(Clone, Debug, ToString, Deserialize, Serialize)]
pub enum VoteType {
Like,
Dislike,
}
impl VoteType {
pub(crate) fn score(&self) -> i16 {
match self {
impl TryFrom<i16> for VoteType {
type Error = LemmyError;
fn try_from(value: i16) -> Result<Self, Self::Error> {
match value {
1 => Ok(VoteType::Like),
-1 => Ok(VoteType::Dislike),
_ => Err(anyhow!("invalid vote value").into()),
}
}
}
impl From<&VoteType> for i16 {
fn from(value: &VoteType) -> i16 {
match value {
VoteType::Like => 1,
VoteType::Dislike => -1,
}
}
}
#[derive(Clone, Debug, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct Vote {
to: PublicUrl,
pub(in crate::activities::voting) to: PublicUrl,
pub(in crate::activities::voting) object: Url,
cc: [Url; 1],
pub(in crate::activities::voting) cc: [Url; 1],
#[serde(rename = "type")]
kind: VoteType,
pub(in crate::activities::voting) kind: VoteType,
#[serde(flatten)]
common: ActivityCommonFields,
pub(in crate::activities::voting) common: ActivityCommonFields,
}
impl Vote {
pub async fn send(
object: &PostOrComment,
actor: &Person,
community_id: CommunityId,
kind: VoteType,
context: &LemmyContext,
) -> Result<(), LemmyError> {
let community = blocking(context.pool(), move |conn| {
Community::read(conn, community_id)
})
.await??;
let id = generate_activity_id(kind.clone())?;
let vote = Vote {
to: PublicUrl::Public,
object: object.ap_id(),
cc: [community.actor_id()],
kind,
common: ActivityCommonFields {
context: lemmy_context(),
id: id.clone(),
actor: actor.actor_id(),
unparsed: Default::default(),
},
};
let activity = AnnouncableActivities::Vote(vote);
send_to_community_new(activity, &id, actor, &community, vec![], context).await
}
}
#[async_trait::async_trait(?Send)]

25
crates/apub/src/lib.rs
View file

@ -151,21 +151,6 @@ pub trait ApubObjectType {
) -> Result<(), LemmyError>;
}
#[async_trait::async_trait(?Send)]
pub trait ApubLikeableType {
async fn send_like(&self, creator: &DbPerson, context: &LemmyContext) -> Result<(), LemmyError>;
async fn send_dislike(
&self,
creator: &DbPerson,
context: &LemmyContext,
) -> Result<(), LemmyError>;
async fn send_undo_like(
&self,
creator: &DbPerson,
context: &LemmyContext,
) -> Result<(), LemmyError>;
}
/// Common methods provided by ActivityPub actors (community and person). Not all methods are
/// implemented by all actors.
pub trait ActorType {
@ -376,6 +361,16 @@ pub enum PostOrComment {
Post(Box<Post>),
}
impl PostOrComment {
pub(crate) fn ap_id(&self) -> Url {
match self {
PostOrComment::Post(p) => p.ap_id.clone(),
PostOrComment::Comment(c) => c.ap_id.clone(),
}
.into()
}
}
/// Tries to find a post or comment in the local database, without any network requests.
/// This is used to handle deletions and removals, because in case we dont have the object, we can
/// simply ignore the activity.