OperationType,
};
use lemmy_api_common::{
- blocking,
comment::CommentResponse,
community::CommunityResponse,
person::PrivateMessageResponse,
post::PostResponse,
+ utils::{blocking, check_person_block, get_user_lang, send_email_to_user},
};
use lemmy_db_schema::{
newtypes::{CommentId, CommunityId, LocalUserId, PersonId, PostId, PrivateMessageId},
- traits::DeleteableOrRemoveable,
+ source::{
+ comment::Comment,
+ comment_reply::{CommentReply, CommentReplyForm},
+ person::Person,
+ person_mention::{PersonMention, PersonMentionForm},
+ post::Post,
+ },
+ traits::{Crud, DeleteableOrRemoveable},
+ SubscribedType,
};
-use lemmy_db_views::{
- comment_view::CommentView,
- local_user_view::LocalUserView,
- post_view::PostView,
- private_message_view::PrivateMessageView,
-};
-use lemmy_db_views_actor::community_view::CommunityView;
-use lemmy_utils::{ConnectionId, LemmyError};
+use lemmy_db_views::structs::{CommentView, LocalUserView, PostView, PrivateMessageView};
+use lemmy_db_views_actor::structs::CommunityView;
+use lemmy_utils::{error::LemmyError, utils::MentionData, ConnectionId};
+#[tracing::instrument(skip_all)]
pub async fn send_post_ws_message<OP: ToString + Send + OperationType + 'static>(
post_id: PostId,
op: OP,
person_id: Option<PersonId>,
context: &LemmyContext,
) -> Result<PostResponse, LemmyError> {
- let mut post_view = blocking(context.pool(), move |conn| {
+ let post_view = blocking(context.pool(), move |conn| {
PostView::read(conn, post_id, person_id)
})
.await??;
- if post_view.post.deleted || post_view.post.removed {
- post_view.post = post_view.post.blank_out_deleted_or_removed_info();
- }
-
let res = PostResponse { post_view };
context.chat_server().do_send(SendPost {
// TODO: in many call sites in apub crate, we are setting an empty vec for recipient_ids,
// we should get the actual recipient actors from somewhere
+#[tracing::instrument(skip_all)]
pub async fn send_comment_ws_message_simple<OP: ToString + Send + OperationType + 'static>(
comment_id: CommentId,
op: OP,
send_comment_ws_message(comment_id, op, None, None, None, vec![], context).await
}
+#[tracing::instrument(skip_all)]
pub async fn send_comment_ws_message<OP: ToString + Send + OperationType + 'static>(
comment_id: CommentId,
op: OP,
Ok(res)
}
+#[tracing::instrument(skip_all)]
pub async fn send_community_ws_message<OP: ToString + Send + OperationType + 'static>(
community_id: CommunityId,
op: OP,
person_id: Option<PersonId>,
context: &LemmyContext,
) -> Result<CommunityResponse, LemmyError> {
- let mut community_view = blocking(context.pool(), move |conn| {
+ let community_view = blocking(context.pool(), move |conn| {
CommunityView::read(conn, community_id, person_id)
})
.await??;
- // Blank out deleted or removed info
- if community_view.community.deleted || community_view.community.removed {
- community_view.community = community_view.community.blank_out_deleted_or_removed_info();
- }
let res = CommunityResponse { community_view };
// Strip out the person id and subscribed when sending to others
let mut res_mut = res.clone();
- res_mut.community_view.subscribed = false;
+ res_mut.community_view.subscribed = SubscribedType::NotSubscribed;
context.chat_server().do_send(SendCommunityRoomMessage {
op,
Ok(res)
}
+#[tracing::instrument(skip_all)]
pub async fn send_pm_ws_message<OP: ToString + Send + OperationType + 'static>(
private_message_id: PrivateMessageId,
op: OP,
Ok(res)
}
+
+#[tracing::instrument(skip_all)]
+pub async fn send_local_notifs(
+ mentions: Vec<MentionData>,
+ comment: &Comment,
+ person: &Person,
+ post: &Post,
+ do_send_email: bool,
+ context: &LemmyContext,
+) -> Result<Vec<LocalUserId>, LemmyError> {
+ let mut recipient_ids = Vec::new();
+ let inbox_link = format!("{}/inbox", context.settings().get_protocol_and_hostname());
+
+ // Send the local mentions
+ for mention in mentions
+ .iter()
+ .filter(|m| m.is_local(&context.settings().hostname) && m.name.ne(&person.name))
+ .collect::<Vec<&MentionData>>()
+ {
+ let mention_name = mention.name.clone();
+ let user_view = blocking(context.pool(), move |conn| {
+ LocalUserView::read_from_name(conn, &mention_name)
+ })
+ .await?;
+ if let Ok(mention_user_view) = user_view {
+ // TODO
+ // At some point, make it so you can't tag the parent creator either
+ // This can cause two notifications, one for reply and the other for mention
+ recipient_ids.push(mention_user_view.local_user.id);
+
+ let user_mention_form = PersonMentionForm {
+ recipient_id: mention_user_view.person.id,
+ comment_id: comment.id,
+ read: None,
+ };
+
+ // Allow this to fail softly, since comment edits might re-update or replace it
+ // Let the uniqueness handle this fail
+ blocking(context.pool(), move |conn| {
+ PersonMention::create(conn, &user_mention_form)
+ })
+ .await?
+ .ok();
+
+ // Send an email to those local users that have notifications on
+ if do_send_email {
+ let lang = get_user_lang(&mention_user_view);
+ send_email_to_user(
+ &mention_user_view,
+ &lang.notification_mentioned_by_subject(&person.name),
+ &lang.notification_mentioned_by_body(&comment.content, &inbox_link, &person.name),
+ context.settings(),
+ )
+ }
+ }
+ }
+
+ // Send comment_reply to the parent commenter / poster
+ if let Some(parent_comment_id) = comment.parent_comment_id() {
+ let parent_comment = blocking(context.pool(), move |conn| {
+ Comment::read(conn, parent_comment_id)
+ })
+ .await??;
+
+ // Get the parent commenter local_user
+ let parent_creator_id = parent_comment.creator_id;
+
+ // Only add to recipients if that person isn't blocked
+ let creator_blocked = check_person_block(person.id, parent_creator_id, context.pool())
+ .await
+ .is_err();
+
+ // Don't send a notif to yourself
+ if parent_comment.creator_id != person.id && !creator_blocked {
+ let user_view = blocking(context.pool(), move |conn| {
+ LocalUserView::read_person(conn, parent_creator_id)
+ })
+ .await?;
+ if let Ok(parent_user_view) = user_view {
+ recipient_ids.push(parent_user_view.local_user.id);
+
+ let comment_reply_form = CommentReplyForm {
+ recipient_id: parent_user_view.person.id,
+ comment_id: comment.id,
+ read: None,
+ };
+
+ // Allow this to fail softly, since comment edits might re-update or replace it
+ // Let the uniqueness handle this fail
+ blocking(context.pool(), move |conn| {
+ CommentReply::create(conn, &comment_reply_form)
+ })
+ .await?
+ .ok();
+
+ if do_send_email {
+ let lang = get_user_lang(&parent_user_view);
+ send_email_to_user(
+ &parent_user_view,
+ &lang.notification_comment_reply_subject(&person.name),
+ &lang.notification_comment_reply_body(&comment.content, &inbox_link, &person.name),
+ context.settings(),
+ )
+ }
+ }
+ }
+ } else {
+ // If there's no parent, its the post creator
+ // Only add to recipients if that person isn't blocked
+ let creator_blocked = check_person_block(person.id, post.creator_id, context.pool())
+ .await
+ .is_err();
+
+ if post.creator_id != person.id && !creator_blocked {
+ let creator_id = post.creator_id;
+ let parent_user = blocking(context.pool(), move |conn| {
+ LocalUserView::read_person(conn, creator_id)
+ })
+ .await?;
+ if let Ok(parent_user_view) = parent_user {
+ recipient_ids.push(parent_user_view.local_user.id);
+
+ let comment_reply_form = CommentReplyForm {
+ recipient_id: parent_user_view.person.id,
+ comment_id: comment.id,
+ read: None,
+ };
+
+ // Allow this to fail softly, since comment edits might re-update or replace it
+ // Let the uniqueness handle this fail
+ blocking(context.pool(), move |conn| {
+ CommentReply::create(conn, &comment_reply_form)
+ })
+ .await?
+ .ok();
+
+ if do_send_email {
+ let lang = get_user_lang(&parent_user_view);
+ send_email_to_user(
+ &parent_user_view,
+ &lang.notification_post_reply_subject(&person.name),
+ &lang.notification_post_reply_body(&comment.content, &inbox_link, &person.name),
+ context.settings(),
+ )
+ }
+ }
+ }
+ }
+
+ Ok(recipient_ids)
+}
projects / lemmy.git / blobdiff