lemmy/crates/api/src/comment.rs

818 lines
22 KiB
Rust
Raw Normal View History

2020-05-16 14:04:08 +00:00
use crate::{
check_community_ban,
check_downvotes_enabled,
collect_moderated_communities,
get_post,
get_user_from_jwt,
get_user_from_jwt_opt,
is_mod_or_admin,
Perform,
};
use actix_web::web::Data;
use lemmy_apub::{generate_apub_endpoint, ApubLikeableType, ApubObjectType, EndpointType};
use lemmy_db_queries::{
source::comment::Comment_,
Crud,
Likeable,
ListingType,
Reportable,
Saveable,
SortType,
};
use lemmy_db_schema::source::{comment::*, comment_report::*, moderator::*};
use lemmy_db_views::{
comment_report_view::{CommentReportQueryBuilder, CommentReportView},
comment_view::{CommentQueryBuilder, CommentView},
};
use lemmy_structs::{blocking, comment::*, send_local_notifs};
use lemmy_utils::{
utils::{remove_slurs, scrape_text_for_mentions},
2021-02-22 18:04:32 +00:00
ApiError,
ConnectionId,
LemmyError,
2020-05-16 14:04:08 +00:00
};
use lemmy_websocket::{
messages::{SendComment, SendModRoomMessage, SendUserRoomMessage},
LemmyContext,
UserOperation,
};
2020-05-16 14:04:08 +00:00
use std::str::FromStr;
2019-05-05 05:20:38 +00:00
#[async_trait::async_trait(?Send)]
impl Perform for CreateComment {
type Response = CommentResponse;
async fn perform(
&self,
context: &Data<LemmyContext>,
websocket_id: Option<ConnectionId>,
) -> Result<CommentResponse, LemmyError> {
let data: &CreateComment = &self;
let user = get_user_from_jwt(&data.auth, context.pool()).await?;
2019-05-05 05:20:38 +00:00
let content_slurs_removed = remove_slurs(&data.content.to_owned());
2021-01-06 21:02:08 +00:00
// Check for a community ban
let post_id = data.post_id;
let post = get_post(post_id, context.pool()).await?;
check_community_ban(user.id, post.community_id, context.pool()).await?;
// Check if post is locked, no new comments
if post.locked {
2021-02-22 18:04:32 +00:00
return Err(ApiError::err("locked").into());
2021-01-06 21:02:08 +00:00
}
// If there's a parent_id, check to make sure that comment is in that post
if let Some(parent_id) = data.parent_id {
// Make sure the parent comment exists
let parent =
match blocking(context.pool(), move |conn| Comment::read(&conn, parent_id)).await? {
Ok(comment) => comment,
2021-02-22 18:04:32 +00:00
Err(_e) => return Err(ApiError::err("couldnt_create_comment").into()),
};
if parent.post_id != post_id {
2021-02-22 18:04:32 +00:00
return Err(ApiError::err("couldnt_create_comment").into());
}
}
2019-05-05 05:20:38 +00:00
let comment_form = CommentForm {
content: content_slurs_removed,
parent_id: data.parent_id.to_owned(),
post_id: data.post_id,
creator_id: user.id,
2019-05-05 05:20:38 +00:00
removed: None,
deleted: None,
read: None,
published: None,
updated: None,
ap_id: None,
2020-04-04 00:04:57 +00:00
local: true,
2019-05-05 05:20:38 +00:00
};
2020-07-21 01:37:44 +00:00
// Create the comment
let comment_form2 = comment_form.clone();
let inserted_comment = match blocking(context.pool(), move |conn| {
Comment::create(&conn, &comment_form2)
})
.await?
{
Ok(comment) => comment,
2021-02-22 18:04:32 +00:00
Err(_e) => return Err(ApiError::err("couldnt_create_comment").into()),
};
2020-07-21 01:37:44 +00:00
// Necessary to update the ap_id
let inserted_comment_id = inserted_comment.id;
let updated_comment: Comment =
match blocking(context.pool(), move |conn| -> Result<Comment, LemmyError> {
let apub_id =
generate_apub_endpoint(EndpointType::Comment, &inserted_comment_id.to_string())?;
Ok(Comment::update_ap_id(&conn, inserted_comment_id, apub_id)?)
})
.await?
{
Ok(comment) => comment,
2021-02-22 18:04:32 +00:00
Err(_e) => return Err(ApiError::err("couldnt_create_comment").into()),
};
2020-04-04 00:04:57 +00:00
updated_comment.send_create(&user, context).await?;
// Scan the comment for user mentions, add those rows
let post_id = post.id;
let mentions = scrape_text_for_mentions(&comment_form.content);
let recipient_ids = send_local_notifs(
mentions,
updated_comment.clone(),
&user,
post,
context.pool(),
true,
)
.await?;
2019-05-05 05:20:38 +00:00
// You like your own comment by default
let like_form = CommentLikeForm {
comment_id: inserted_comment.id,
post_id,
2021-02-26 13:49:58 +00:00
person_id: user.id,
score: 1,
2019-05-05 05:20:38 +00:00
};
let like = move |conn: &'_ _| CommentLike::like(&conn, &like_form);
if blocking(context.pool(), like).await?.is_err() {
2021-02-22 18:04:32 +00:00
return Err(ApiError::err("couldnt_like_comment").into());
}
2019-05-05 05:20:38 +00:00
updated_comment.send_like(&user, context).await?;
let user_id = user.id;
2021-01-06 21:02:08 +00:00
let mut comment_view = blocking(context.pool(), move |conn| {
CommentView::read(&conn, inserted_comment.id, Some(user_id))
})
.await??;
2019-05-05 05:20:38 +00:00
2021-01-06 21:02:08 +00:00
// If its a comment to yourself, mark it as read
let comment_id = comment_view.comment.id;
if user.id == comment_view.get_recipient_id() {
match blocking(context.pool(), move |conn| {
Comment::update_read(conn, comment_id, true)
})
.await?
{
Ok(comment) => comment,
2021-02-22 18:04:32 +00:00
Err(_e) => return Err(ApiError::err("couldnt_update_comment").into()),
2021-01-06 21:02:08 +00:00
};
comment_view.comment.read = true;
}
2021-01-13 17:01:42 +00:00
let mut res = CommentResponse {
2020-12-15 19:39:18 +00:00
comment_view,
recipient_ids,
form_id: data.form_id.to_owned(),
};
context.chat_server().do_send(SendComment {
op: UserOperation::CreateComment,
comment: res.clone(),
websocket_id,
});
2021-01-13 17:01:42 +00:00
res.recipient_ids = Vec::new(); // Necessary to avoid doubles
Ok(res)
2019-05-05 05:20:38 +00:00
}
}
#[async_trait::async_trait(?Send)]
impl Perform for EditComment {
type Response = CommentResponse;
async fn perform(
&self,
context: &Data<LemmyContext>,
websocket_id: Option<ConnectionId>,
) -> Result<CommentResponse, LemmyError> {
let data: &EditComment = &self;
let user = get_user_from_jwt(&data.auth, context.pool()).await?;
2019-05-05 05:20:38 +00:00
let comment_id = data.comment_id;
let orig_comment = blocking(context.pool(), move |conn| {
CommentView::read(&conn, comment_id, None)
})
.await??;
2019-05-05 05:20:38 +00:00
2020-12-15 19:39:18 +00:00
check_community_ban(user.id, orig_comment.community.id, context.pool()).await?;
2019-05-05 05:20:38 +00:00
2020-07-21 01:37:44 +00:00
// Verify that only the creator can edit
2020-12-15 19:39:18 +00:00
if user.id != orig_comment.creator.id {
2021-02-22 18:04:32 +00:00
return Err(ApiError::err("no_comment_edit_allowed").into());
2019-05-05 05:20:38 +00:00
}
2020-07-21 01:37:44 +00:00
// Do the update
2019-05-05 05:20:38 +00:00
let content_slurs_removed = remove_slurs(&data.content.to_owned());
let comment_id = data.comment_id;
let updated_comment = match blocking(context.pool(), move |conn| {
Comment::update_content(conn, comment_id, &content_slurs_removed)
2020-07-21 01:37:44 +00:00
})
.await?
{
Ok(comment) => comment,
2021-02-22 18:04:32 +00:00
Err(_e) => return Err(ApiError::err("couldnt_update_comment").into()),
2020-07-21 01:37:44 +00:00
};
// Send the apub update
updated_comment.send_update(&user, context).await?;
2020-07-21 01:37:44 +00:00
// Do the mentions / recipients
let updated_comment_content = updated_comment.content.to_owned();
let mentions = scrape_text_for_mentions(&updated_comment_content);
let recipient_ids = send_local_notifs(
mentions,
updated_comment,
&user,
orig_comment.post,
context.pool(),
false,
)
.await?;
2019-05-05 05:20:38 +00:00
let comment_id = data.comment_id;
let user_id = user.id;
let comment_view = blocking(context.pool(), move |conn| {
CommentView::read(conn, comment_id, Some(user_id))
2020-07-21 01:37:44 +00:00
})
.await??;
2021-01-07 06:17:42 +00:00
let res = CommentResponse {
2020-12-15 19:39:18 +00:00
comment_view,
2020-07-21 01:37:44 +00:00
recipient_ids,
form_id: data.form_id.to_owned(),
2019-05-05 05:20:38 +00:00
};
context.chat_server().do_send(SendComment {
op: UserOperation::EditComment,
comment: res.clone(),
websocket_id,
});
2020-07-21 01:37:44 +00:00
Ok(res)
}
}
#[async_trait::async_trait(?Send)]
impl Perform for DeleteComment {
2020-07-21 01:37:44 +00:00
type Response = CommentResponse;
async fn perform(
&self,
context: &Data<LemmyContext>,
websocket_id: Option<ConnectionId>,
2020-07-21 01:37:44 +00:00
) -> Result<CommentResponse, LemmyError> {
let data: &DeleteComment = &self;
let user = get_user_from_jwt(&data.auth, context.pool()).await?;
2020-07-21 01:37:44 +00:00
let comment_id = data.comment_id;
let orig_comment = blocking(context.pool(), move |conn| {
CommentView::read(&conn, comment_id, None)
})
.await??;
2020-07-21 01:37:44 +00:00
2020-12-15 19:39:18 +00:00
check_community_ban(user.id, orig_comment.community.id, context.pool()).await?;
2020-07-21 01:37:44 +00:00
// Verify that only the creator can delete
2020-12-15 19:39:18 +00:00
if user.id != orig_comment.creator.id {
2021-02-22 18:04:32 +00:00
return Err(ApiError::err("no_comment_edit_allowed").into());
2020-07-21 01:37:44 +00:00
}
// Do the delete
let deleted = data.deleted;
let updated_comment = match blocking(context.pool(), move |conn| {
Comment::update_deleted(conn, comment_id, deleted)
})
.await?
{
2019-05-05 05:20:38 +00:00
Ok(comment) => comment,
2021-02-22 18:04:32 +00:00
Err(_e) => return Err(ApiError::err("couldnt_update_comment").into()),
2019-05-05 05:20:38 +00:00
};
2020-07-21 01:37:44 +00:00
// Send the apub message
if deleted {
updated_comment.send_delete(&user, context).await?;
2020-07-21 01:37:44 +00:00
} else {
updated_comment.send_undo_delete(&user, context).await?;
}
2020-07-21 01:37:44 +00:00
// Refetch it
let comment_id = data.comment_id;
let user_id = user.id;
let comment_view = blocking(context.pool(), move |conn| {
CommentView::read(conn, comment_id, Some(user_id))
2020-07-21 01:37:44 +00:00
})
.await??;
// Build the recipients
let comment_view_2 = comment_view.clone();
2020-07-21 01:37:44 +00:00
let mentions = vec![];
let recipient_ids = send_local_notifs(
mentions,
updated_comment,
&user,
comment_view_2.post,
context.pool(),
false,
)
.await?;
2021-01-07 06:17:42 +00:00
let res = CommentResponse {
2020-12-15 19:39:18 +00:00
comment_view,
2020-07-21 01:37:44 +00:00
recipient_ids,
form_id: None, // TODO a comment delete might clear forms?
2020-07-21 01:37:44 +00:00
};
context.chat_server().do_send(SendComment {
op: UserOperation::DeleteComment,
comment: res.clone(),
websocket_id,
});
2020-07-21 01:37:44 +00:00
Ok(res)
}
}
#[async_trait::async_trait(?Send)]
impl Perform for RemoveComment {
2020-07-21 01:37:44 +00:00
type Response = CommentResponse;
async fn perform(
&self,
context: &Data<LemmyContext>,
websocket_id: Option<ConnectionId>,
2020-07-21 01:37:44 +00:00
) -> Result<CommentResponse, LemmyError> {
let data: &RemoveComment = &self;
let user = get_user_from_jwt(&data.auth, context.pool()).await?;
2020-07-21 01:37:44 +00:00
let comment_id = data.comment_id;
let orig_comment = blocking(context.pool(), move |conn| {
CommentView::read(&conn, comment_id, None)
})
.await??;
2020-07-21 01:37:44 +00:00
2020-12-15 19:39:18 +00:00
check_community_ban(user.id, orig_comment.community.id, context.pool()).await?;
2020-07-21 01:37:44 +00:00
// Verify that only a mod or admin can remove
2020-12-15 19:39:18 +00:00
is_mod_or_admin(context.pool(), user.id, orig_comment.community.id).await?;
2020-07-21 01:37:44 +00:00
// Do the remove
let removed = data.removed;
let updated_comment = match blocking(context.pool(), move |conn| {
Comment::update_removed(conn, comment_id, removed)
2020-07-21 01:37:44 +00:00
})
.await?
{
Ok(comment) => comment,
2021-02-22 18:04:32 +00:00
Err(_e) => return Err(ApiError::err("couldnt_update_comment").into()),
2020-07-21 01:37:44 +00:00
};
// Mod tables
let form = ModRemoveCommentForm {
2021-02-26 13:49:58 +00:00
mod_person_id: user.id,
comment_id: data.comment_id,
2020-07-21 01:37:44 +00:00
removed: Some(removed),
reason: data.reason.to_owned(),
};
blocking(context.pool(), move |conn| {
ModRemoveComment::create(conn, &form)
})
.await??;
2020-07-21 01:37:44 +00:00
// Send the apub message
if removed {
updated_comment.send_remove(&user, context).await?;
2020-07-21 01:37:44 +00:00
} else {
updated_comment.send_undo_remove(&user, context).await?;
2020-07-21 01:37:44 +00:00
}
2020-07-21 01:37:44 +00:00
// Refetch it
let comment_id = data.comment_id;
let user_id = user.id;
let comment_view = blocking(context.pool(), move |conn| {
CommentView::read(conn, comment_id, Some(user_id))
})
.await??;
2019-05-05 05:20:38 +00:00
2020-07-21 01:37:44 +00:00
// Build the recipients
let comment_view_2 = comment_view.clone();
2020-07-21 01:37:44 +00:00
let mentions = vec![];
let recipient_ids = send_local_notifs(
mentions,
updated_comment,
&user,
comment_view_2.post,
context.pool(),
false,
)
.await?;
2020-07-21 01:37:44 +00:00
2021-01-07 06:17:42 +00:00
let res = CommentResponse {
2020-12-15 19:39:18 +00:00
comment_view,
recipient_ids,
form_id: None, // TODO maybe this might clear other forms
};
context.chat_server().do_send(SendComment {
op: UserOperation::RemoveComment,
comment: res.clone(),
websocket_id,
});
Ok(res)
2019-05-05 05:20:38 +00:00
}
}
2020-07-21 01:37:44 +00:00
#[async_trait::async_trait(?Send)]
impl Perform for MarkCommentAsRead {
2020-07-21 01:37:44 +00:00
type Response = CommentResponse;
async fn perform(
&self,
context: &Data<LemmyContext>,
_websocket_id: Option<ConnectionId>,
2020-07-21 01:37:44 +00:00
) -> Result<CommentResponse, LemmyError> {
let data: &MarkCommentAsRead = &self;
let user = get_user_from_jwt(&data.auth, context.pool()).await?;
2020-07-21 01:37:44 +00:00
let comment_id = data.comment_id;
let orig_comment = blocking(context.pool(), move |conn| {
CommentView::read(&conn, comment_id, None)
})
.await??;
2020-07-21 01:37:44 +00:00
2020-12-15 19:39:18 +00:00
check_community_ban(user.id, orig_comment.community.id, context.pool()).await?;
2020-07-21 01:37:44 +00:00
// Verify that only the recipient can mark as read
if user.id != orig_comment.get_recipient_id() {
2021-02-22 18:04:32 +00:00
return Err(ApiError::err("no_comment_edit_allowed").into());
2020-07-21 01:37:44 +00:00
}
// Do the mark as read
let read = data.read;
match blocking(context.pool(), move |conn| {
Comment::update_read(conn, comment_id, read)
})
.await?
{
2020-07-21 01:37:44 +00:00
Ok(comment) => comment,
2021-02-22 18:04:32 +00:00
Err(_e) => return Err(ApiError::err("couldnt_update_comment").into()),
2020-07-21 01:37:44 +00:00
};
// Refetch it
let comment_id = data.comment_id;
let user_id = user.id;
let comment_view = blocking(context.pool(), move |conn| {
CommentView::read(conn, comment_id, Some(user_id))
2020-07-21 01:37:44 +00:00
})
.await??;
let res = CommentResponse {
2020-12-15 19:39:18 +00:00
comment_view,
2020-07-21 01:37:44 +00:00
recipient_ids: Vec::new(),
form_id: None,
2020-07-21 01:37:44 +00:00
};
Ok(res)
}
}
#[async_trait::async_trait(?Send)]
impl Perform for SaveComment {
type Response = CommentResponse;
async fn perform(
&self,
context: &Data<LemmyContext>,
_websocket_id: Option<ConnectionId>,
) -> Result<CommentResponse, LemmyError> {
let data: &SaveComment = &self;
let user = get_user_from_jwt(&data.auth, context.pool()).await?;
2019-05-05 05:20:38 +00:00
let comment_saved_form = CommentSavedForm {
comment_id: data.comment_id,
2021-02-26 13:49:58 +00:00
person_id: user.id,
2019-05-05 05:20:38 +00:00
};
if data.save {
let save_comment = move |conn: &'_ _| CommentSaved::save(conn, &comment_saved_form);
if blocking(context.pool(), save_comment).await?.is_err() {
2021-02-22 18:04:32 +00:00
return Err(ApiError::err("couldnt_save_comment").into());
}
2019-05-05 05:20:38 +00:00
} else {
let unsave_comment = move |conn: &'_ _| CommentSaved::unsave(conn, &comment_saved_form);
if blocking(context.pool(), unsave_comment).await?.is_err() {
2021-02-22 18:04:32 +00:00
return Err(ApiError::err("couldnt_save_comment").into());
}
2019-05-05 05:20:38 +00:00
}
let comment_id = data.comment_id;
let user_id = user.id;
let comment_view = blocking(context.pool(), move |conn| {
CommentView::read(conn, comment_id, Some(user_id))
})
.await??;
2019-05-05 05:20:38 +00:00
Ok(CommentResponse {
2020-12-15 19:39:18 +00:00
comment_view,
recipient_ids: Vec::new(),
form_id: None,
})
2019-05-05 05:20:38 +00:00
}
}
#[async_trait::async_trait(?Send)]
impl Perform for CreateCommentLike {
type Response = CommentResponse;
async fn perform(
&self,
context: &Data<LemmyContext>,
websocket_id: Option<ConnectionId>,
) -> Result<CommentResponse, LemmyError> {
let data: &CreateCommentLike = &self;
let user = get_user_from_jwt(&data.auth, context.pool()).await?;
2019-05-05 05:20:38 +00:00
let mut recipient_ids = Vec::new();
// Don't do a downvote if site has downvotes disabled
check_downvotes_enabled(data.score, context.pool()).await?;
2020-07-21 01:37:44 +00:00
let comment_id = data.comment_id;
let orig_comment = blocking(context.pool(), move |conn| {
CommentView::read(&conn, comment_id, None)
})
.await??;
2020-07-21 01:37:44 +00:00
check_community_ban(user.id, orig_comment.community.id, context.pool()).await?;
2019-05-05 05:20:38 +00:00
// Add parent user to recipients
recipient_ids.push(orig_comment.get_recipient_id());
2019-05-05 05:20:38 +00:00
let like_form = CommentLikeForm {
comment_id: data.comment_id,
post_id: orig_comment.post.id,
2021-02-26 13:49:58 +00:00
person_id: user.id,
score: data.score,
2019-05-05 05:20:38 +00:00
};
// Remove any likes first
let user_id = user.id;
blocking(context.pool(), move |conn| {
CommentLike::remove(conn, user_id, comment_id)
})
.await??;
2019-05-05 05:20:38 +00:00
// Only add the like if the score isnt 0
let comment = orig_comment.comment;
let do_add = like_form.score != 0 && (like_form.score == 1 || like_form.score == -1);
2019-05-15 16:46:39 +00:00
if do_add {
let like_form2 = like_form.clone();
let like = move |conn: &'_ _| CommentLike::like(conn, &like_form2);
if blocking(context.pool(), like).await?.is_err() {
2021-02-22 18:04:32 +00:00
return Err(ApiError::err("couldnt_like_comment").into());
}
if like_form.score == 1 {
comment.send_like(&user, context).await?;
} else if like_form.score == -1 {
comment.send_dislike(&user, context).await?;
}
} else {
comment.send_undo_like(&user, context).await?;
2019-05-05 05:20:38 +00:00
}
// Have to refetch the comment to get the current state
let comment_id = data.comment_id;
let user_id = user.id;
let liked_comment = blocking(context.pool(), move |conn| {
CommentView::read(conn, comment_id, Some(user_id))
})
.await??;
2019-05-05 05:20:38 +00:00
2021-01-07 06:17:42 +00:00
let res = CommentResponse {
2020-12-15 19:39:18 +00:00
comment_view: liked_comment,
recipient_ids,
form_id: None,
};
context.chat_server().do_send(SendComment {
op: UserOperation::CreateCommentLike,
comment: res.clone(),
websocket_id,
});
Ok(res)
2019-05-05 05:20:38 +00:00
}
}
#[async_trait::async_trait(?Send)]
impl Perform for GetComments {
type Response = GetCommentsResponse;
async fn perform(
&self,
context: &Data<LemmyContext>,
_websocket_id: Option<ConnectionId>,
) -> Result<GetCommentsResponse, LemmyError> {
let data: &GetComments = &self;
let user = get_user_from_jwt_opt(&data.auth, context.pool()).await?;
let user_id = user.map(|u| u.id);
let type_ = ListingType::from_str(&data.type_)?;
let sort = SortType::from_str(&data.sort)?;
let community_id = data.community_id;
let community_name = data.community_name.to_owned();
let page = data.page;
let limit = data.limit;
let comments = blocking(context.pool(), move |conn| {
CommentQueryBuilder::create(conn)
.listing_type(type_)
.sort(&sort)
.community_id(community_id)
.community_name(community_name)
.my_user_id(user_id)
.page(page)
.limit(limit)
.list()
})
.await?;
let comments = match comments {
Ok(comments) => comments,
2021-02-22 18:04:32 +00:00
Err(_) => return Err(ApiError::err("couldnt_get_comments").into()),
};
Ok(GetCommentsResponse { comments })
}
}
/// Creates a comment report and notifies the moderators of the community
#[async_trait::async_trait(?Send)]
impl Perform for CreateCommentReport {
type Response = CreateCommentReportResponse;
async fn perform(
&self,
context: &Data<LemmyContext>,
2020-10-27 00:25:18 +00:00
websocket_id: Option<ConnectionId>,
) -> Result<CreateCommentReportResponse, LemmyError> {
let data: &CreateCommentReport = &self;
let user = get_user_from_jwt(&data.auth, context.pool()).await?;
// check size of report and check for whitespace
let reason = data.reason.trim();
if reason.is_empty() {
2021-02-22 18:04:32 +00:00
return Err(ApiError::err("report_reason_required").into());
}
2021-02-10 15:36:22 +00:00
if reason.chars().count() > 1000 {
2021-02-22 18:04:32 +00:00
return Err(ApiError::err("report_too_long").into());
}
let user_id = user.id;
let comment_id = data.comment_id;
2020-12-15 19:39:18 +00:00
let comment_view = blocking(context.pool(), move |conn| {
CommentView::read(&conn, comment_id, None)
})
.await??;
2020-12-15 19:39:18 +00:00
check_community_ban(user_id, comment_view.community.id, context.pool()).await?;
let report_form = CommentReportForm {
creator_id: user_id,
comment_id,
2020-12-15 19:39:18 +00:00
original_comment_text: comment_view.comment.content,
reason: data.reason.to_owned(),
};
2020-10-27 00:25:18 +00:00
let report = match blocking(context.pool(), move |conn| {
CommentReport::report(conn, &report_form)
})
.await?
{
Ok(report) => report,
2021-02-22 18:04:32 +00:00
Err(_e) => return Err(ApiError::err("couldnt_create_report").into()),
};
let res = CreateCommentReportResponse { success: true };
2020-10-27 00:25:18 +00:00
context.chat_server().do_send(SendUserRoomMessage {
op: UserOperation::CreateCommentReport,
response: res.clone(),
recipient_id: user.id,
websocket_id,
});
context.chat_server().do_send(SendModRoomMessage {
op: UserOperation::CreateCommentReport,
response: report,
2020-12-15 19:39:18 +00:00
community_id: comment_view.community.id,
2020-10-27 00:25:18 +00:00
websocket_id,
});
Ok(res)
}
}
/// Resolves or unresolves a comment report and notifies the moderators of the community
#[async_trait::async_trait(?Send)]
impl Perform for ResolveCommentReport {
type Response = ResolveCommentReportResponse;
async fn perform(
&self,
context: &Data<LemmyContext>,
2020-10-27 00:25:18 +00:00
websocket_id: Option<ConnectionId>,
) -> Result<ResolveCommentReportResponse, LemmyError> {
let data: &ResolveCommentReport = &self;
let user = get_user_from_jwt(&data.auth, context.pool()).await?;
let report_id = data.report_id;
let report = blocking(context.pool(), move |conn| {
CommentReportView::read(&conn, report_id)
})
.await??;
let user_id = user.id;
2020-12-17 03:03:03 +00:00
is_mod_or_admin(context.pool(), user_id, report.community.id).await?;
let resolved = data.resolved;
let resolve_fun = move |conn: &'_ _| {
if resolved {
CommentReport::resolve(conn, report_id, user_id)
} else {
CommentReport::unresolve(conn, report_id, user_id)
}
};
if blocking(context.pool(), resolve_fun).await?.is_err() {
2021-02-22 18:04:32 +00:00
return Err(ApiError::err("couldnt_resolve_report").into());
};
let report_id = data.report_id;
let res = ResolveCommentReportResponse {
report_id,
resolved,
};
2020-10-27 00:25:18 +00:00
context.chat_server().do_send(SendModRoomMessage {
op: UserOperation::ResolveCommentReport,
response: res.clone(),
2020-12-17 03:03:03 +00:00
community_id: report.community.id,
2020-10-27 00:25:18 +00:00
websocket_id,
});
Ok(res)
}
}
/// Lists comment reports for a community if an id is supplied
/// or returns all comment reports for communities a user moderates
#[async_trait::async_trait(?Send)]
impl Perform for ListCommentReports {
type Response = ListCommentReportsResponse;
async fn perform(
&self,
context: &Data<LemmyContext>,
websocket_id: Option<ConnectionId>,
) -> Result<ListCommentReportsResponse, LemmyError> {
let data: &ListCommentReports = &self;
let user = get_user_from_jwt(&data.auth, context.pool()).await?;
let user_id = user.id;
let community_id = data.community;
let community_ids =
collect_moderated_communities(user_id, community_id, context.pool()).await?;
let page = data.page;
let limit = data.limit;
let comments = blocking(context.pool(), move |conn| {
CommentReportQueryBuilder::create(conn)
.community_ids(community_ids)
.page(page)
.limit(limit)
.list()
})
.await??;
let res = ListCommentReportsResponse { comments };
context.chat_server().do_send(SendUserRoomMessage {
op: UserOperation::ListCommentReports,
response: res.clone(),
recipient_id: user.id,
websocket_id,
});
Ok(res)
}
}