crates/api_crud/src/private_message/create.rs

   1 use crate::PerformCrud;
   2 use actix_web::web::Data;
   3 use lemmy_api_common::{
   4   blocking,
   5   get_local_user_view_from_jwt,
   6   person::{CreatePrivateMessage, PrivateMessageResponse},
   7   send_email_to_user,
   8 };
   9 use lemmy_apub::{generate_apub_endpoint, ApubObjectType, EndpointType};
  10 use lemmy_db_queries::{source::private_message::PrivateMessage_, Crud};
  11 use lemmy_db_schema::source::private_message::{PrivateMessage, PrivateMessageForm};
  12 use lemmy_db_views::{local_user_view::LocalUserView, private_message_view::PrivateMessageView};
  13 use lemmy_utils::{utils::remove_slurs, ApiError, ConnectionId, LemmyError};
  14 use lemmy_websocket::{messages::SendUserRoomMessage, LemmyContext, UserOperation};
  15
  16 #[async_trait::async_trait(?Send)]
  17 impl PerformCrud for CreatePrivateMessage {
  18   type Response = PrivateMessageResponse;
  19
  20   async fn perform(
  21     &self,
  22     context: &Data<LemmyContext>,
  23     websocket_id: Option<ConnectionId>,
  24   ) -> Result<PrivateMessageResponse, LemmyError> {
  25     let data: &CreatePrivateMessage = &self;
  26     let local_user_view = get_local_user_view_from_jwt(&data.auth, context.pool()).await?;
  27
  28     let content_slurs_removed = remove_slurs(&data.content.to_owned());
  29
  30     let private_message_form = PrivateMessageForm {
  31       content: content_slurs_removed.to_owned(),
  32       creator_id: local_user_view.person.id,
  33       recipient_id: data.recipient_id,
  34       deleted: None,
  35       read: None,
  36       updated: None,
  37       ap_id: None,
  38       local: true,
  39       published: None,
  40     };
  41
  42     let inserted_private_message = match blocking(context.pool(), move |conn| {
  43       PrivateMessage::create(conn, &private_message_form)
  44     })
  45     .await?
  46     {
  47       Ok(private_message) => private_message,
  48       Err(_e) => {
  49         return Err(ApiError::err("couldnt_create_private_message").into());
  50       }
  51     };
  52
  53     let inserted_private_message_id = inserted_private_message.id;
  54     let updated_private_message = match blocking(
  55       context.pool(),
  56       move |conn| -> Result<PrivateMessage, LemmyError> {
  57         let apub_id = generate_apub_endpoint(
  58           EndpointType::PrivateMessage,
  59           &inserted_private_message_id.to_string(),
  60         )?;
  61         Ok(PrivateMessage::update_ap_id(
  62           &conn,
  63           inserted_private_message_id,
  64           apub_id,
  65         )?)
  66       },
  67     )
  68     .await?
  69     {
  70       Ok(private_message) => private_message,
  71       Err(_e) => return Err(ApiError::err("couldnt_create_private_message").into()),
  72     };
  73
  74     updated_private_message
  75       .send_create(&local_user_view.person, context)
  76       .await?;
  77
  78     let private_message_view = blocking(context.pool(), move |conn| {
  79       PrivateMessageView::read(conn, inserted_private_message.id)
  80     })
  81     .await??;
  82
  83     let res = PrivateMessageResponse {
  84       private_message_view,
  85     };
  86
  87     // Send notifications to the local recipient, if one exists
  88     let recipient_id = data.recipient_id;
  89     if let Ok(local_recipient) = blocking(context.pool(), move |conn| {
  90       LocalUserView::read_person(conn, recipient_id)
  91     })
  92     .await?
  93     {
  94       send_email_to_user(
  95         &local_recipient,
  96         "Private Message from",
  97         "Private Message",
  98         &content_slurs_removed,
  99       );
 100
 101       let local_recipient_id = local_recipient.local_user.id;
 102       context.chat_server().do_send(SendUserRoomMessage {
 103         op: UserOperation::CreatePrivateMessage,
 104         response: res.clone(),
 105         local_recipient_id,
 106         websocket_id,
 107       });
 108     }
 109
 110     Ok(res)
 111   }
 112 }