crates/api_common/src/build_response.rs

   1 use crate::{
   2   comment::CommentResponse,
   3   community::CommunityResponse,
   4   context::LemmyContext,
   5   post::PostResponse,
   6   utils::{check_person_block, get_interface_language, is_mod_or_admin, send_email_to_user},
   7 };
   8 use actix_web::web::Data;
   9 use lemmy_db_schema::{
  10   newtypes::{CommentId, CommunityId, LocalUserId, PersonId, PostId},
  11   source::{
  12     actor_language::CommunityLanguage,
  13     comment::Comment,
  14     comment_reply::{CommentReply, CommentReplyInsertForm},
  15     person::Person,
  16     person_mention::{PersonMention, PersonMentionInsertForm},
  17     post::Post,
  18   },
  19   traits::Crud,
  20 };
  21 use lemmy_db_views::structs::{CommentView, LocalUserView, PostView};
  22 use lemmy_db_views_actor::structs::CommunityView;
  23 use lemmy_utils::{error::LemmyError, utils::mention::MentionData};
  24
  25 pub async fn build_comment_response(
  26   context: &Data<LemmyContext>,
  27   comment_id: CommentId,
  28   local_user_view: Option<LocalUserView>,
  29   form_id: Option<String>,
  30   recipient_ids: Vec<LocalUserId>,
  31 ) -> Result<CommentResponse, LemmyError> {
  32   let person_id = local_user_view.map(|l| l.person.id);
  33   let comment_view = CommentView::read(&mut context.pool(), comment_id, person_id).await?;
  34   Ok(CommentResponse {
  35     comment_view,
  36     recipient_ids,
  37     form_id,
  38   })
  39 }
  40
  41 pub async fn build_community_response(
  42   context: &Data<LemmyContext>,
  43   local_user_view: LocalUserView,
  44   community_id: CommunityId,
  45 ) -> Result<CommunityResponse, LemmyError> {
  46   let is_mod_or_admin =
  47     is_mod_or_admin(&mut context.pool(), local_user_view.person.id, community_id)
  48       .await
  49       .is_ok();
  50   let person_id = local_user_view.person.id;
  51   let community_view = CommunityView::read(
  52     &mut context.pool(),
  53     community_id,
  54     Some(person_id),
  55     Some(is_mod_or_admin),
  56   )
  57   .await?;
  58   let discussion_languages = CommunityLanguage::read(&mut context.pool(), community_id).await?;
  59
  60   Ok(CommunityResponse {
  61     community_view,
  62     discussion_languages,
  63   })
  64 }
  65
  66 pub async fn build_post_response(
  67   context: &LemmyContext,
  68   community_id: CommunityId,
  69   person_id: PersonId,
  70   post_id: PostId,
  71 ) -> Result<PostResponse, LemmyError> {
  72   let is_mod_or_admin = is_mod_or_admin(&mut context.pool(), person_id, community_id)
  73     .await
  74     .is_ok();
  75   let post_view = PostView::read(
  76     &mut context.pool(),
  77     post_id,
  78     Some(person_id),
  79     Some(is_mod_or_admin),
  80   )
  81   .await?;
  82   Ok(PostResponse { post_view })
  83 }
  84
  85 // TODO: this function is a mess and should be split up to handle email seperately
  86 #[tracing::instrument(skip_all)]
  87 pub async fn send_local_notifs(
  88   mentions: Vec<MentionData>,
  89   comment: &Comment,
  90   person: &Person,
  91   post: &Post,
  92   do_send_email: bool,
  93   context: &LemmyContext,
  94 ) -> Result<Vec<LocalUserId>, LemmyError> {
  95   let mut recipient_ids = Vec::new();
  96   let inbox_link = format!("{}/inbox", context.settings().get_protocol_and_hostname());
  97
  98   // Send the local mentions
  99   for mention in mentions
 100     .iter()
 101     .filter(|m| m.is_local(&context.settings().hostname) && m.name.ne(&person.name))
 102   {
 103     let mention_name = mention.name.clone();
 104     let user_view = LocalUserView::read_from_name(&mut context.pool(), &mention_name).await;
 105     if let Ok(mention_user_view) = user_view {
 106       // TODO
 107       // At some point, make it so you can't tag the parent creator either
 108       // This can cause two notifications, one for reply and the other for mention
 109       recipient_ids.push(mention_user_view.local_user.id);
 110
 111       let user_mention_form = PersonMentionInsertForm {
 112         recipient_id: mention_user_view.person.id,
 113         comment_id: comment.id,
 114         read: None,
 115       };
 116
 117       // Allow this to fail softly, since comment edits might re-update or replace it
 118       // Let the uniqueness handle this fail
 119       PersonMention::create(&mut context.pool(), &user_mention_form)
 120         .await
 121         .ok();
 122
 123       // Send an email to those local users that have notifications on
 124       if do_send_email {
 125         let lang = get_interface_language(&mention_user_view);
 126         send_email_to_user(
 127           &mention_user_view,
 128           &lang.notification_mentioned_by_subject(&person.name),
 129           &lang.notification_mentioned_by_body(&comment.content, &inbox_link, &person.name),
 130           context.settings(),
 131         )
 132         .await
 133       }
 134     }
 135   }
 136
 137   // Send comment_reply to the parent commenter / poster
 138   if let Some(parent_comment_id) = comment.parent_comment_id() {
 139     let parent_comment = Comment::read(&mut context.pool(), parent_comment_id).await?;
 140
 141     // Get the parent commenter local_user
 142     let parent_creator_id = parent_comment.creator_id;
 143
 144     // Only add to recipients if that person isn't blocked
 145     let creator_blocked = check_person_block(person.id, parent_creator_id, &mut context.pool())
 146       .await
 147       .is_err();
 148
 149     // Don't send a notif to yourself
 150     if parent_comment.creator_id != person.id && !creator_blocked {
 151       let user_view = LocalUserView::read_person(&mut context.pool(), parent_creator_id).await;
 152       if let Ok(parent_user_view) = user_view {
 153         recipient_ids.push(parent_user_view.local_user.id);
 154
 155         let comment_reply_form = CommentReplyInsertForm {
 156           recipient_id: parent_user_view.person.id,
 157           comment_id: comment.id,
 158           read: None,
 159         };
 160
 161         // Allow this to fail softly, since comment edits might re-update or replace it
 162         // Let the uniqueness handle this fail
 163         CommentReply::create(&mut context.pool(), &comment_reply_form)
 164           .await
 165           .ok();
 166
 167         if do_send_email {
 168           let lang = get_interface_language(&parent_user_view);
 169           send_email_to_user(
 170             &parent_user_view,
 171             &lang.notification_comment_reply_subject(&person.name),
 172             &lang.notification_comment_reply_body(&comment.content, &inbox_link, &person.name),
 173             context.settings(),
 174           )
 175           .await
 176         }
 177       }
 178     }
 179   } else {
 180     // If there's no parent, its the post creator
 181     // Only add to recipients if that person isn't blocked
 182     let creator_blocked = check_person_block(person.id, post.creator_id, &mut context.pool())
 183       .await
 184       .is_err();
 185
 186     if post.creator_id != person.id && !creator_blocked {
 187       let creator_id = post.creator_id;
 188       let parent_user = LocalUserView::read_person(&mut context.pool(), creator_id).await;
 189       if let Ok(parent_user_view) = parent_user {
 190         recipient_ids.push(parent_user_view.local_user.id);
 191
 192         let comment_reply_form = CommentReplyInsertForm {
 193           recipient_id: parent_user_view.person.id,
 194           comment_id: comment.id,
 195           read: None,
 196         };
 197
 198         // Allow this to fail softly, since comment edits might re-update or replace it
 199         // Let the uniqueness handle this fail
 200         CommentReply::create(&mut context.pool(), &comment_reply_form)
 201           .await
 202           .ok();
 203
 204         if do_send_email {
 205           let lang = get_interface_language(&parent_user_view);
 206           send_email_to_user(
 207             &parent_user_view,
 208             &lang.notification_post_reply_subject(&person.name),
 209             &lang.notification_post_reply_body(&comment.content, &inbox_link, &person.name),
 210             context.settings(),
 211           )
 212           .await
 213         }
 214       }
 215     }
 216   }
 217
 218   Ok(recipient_ids)
 219 }