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, UserOperationCrud};
  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       ..PrivateMessageForm::default()
  35     };
  36
  37     let inserted_private_message = match blocking(context.pool(), move |conn| {
  38       PrivateMessage::create(conn, &private_message_form)
  39     })
  40     .await?
  41     {
  42       Ok(private_message) => private_message,
  43       Err(_e) => {
  44         return Err(ApiError::err("couldnt_create_private_message").into());
  45       }
  46     };
  47
  48     let inserted_private_message_id = inserted_private_message.id;
  49     let updated_private_message = match blocking(
  50       context.pool(),
  51       move |conn| -> Result<PrivateMessage, LemmyError> {
  52         let apub_id = generate_apub_endpoint(
  53           EndpointType::PrivateMessage,
  54           &inserted_private_message_id.to_string(),
  55         )?;
  56         Ok(PrivateMessage::update_ap_id(
  57           &conn,
  58           inserted_private_message_id,
  59           apub_id,
  60         )?)
  61       },
  62     )
  63     .await?
  64     {
  65       Ok(private_message) => private_message,
  66       Err(_e) => return Err(ApiError::err("couldnt_create_private_message").into()),
  67     };
  68
  69     updated_private_message
  70       .send_create(&local_user_view.person, context)
  71       .await?;
  72
  73     let private_message_view = blocking(context.pool(), move |conn| {
  74       PrivateMessageView::read(conn, inserted_private_message.id)
  75     })
  76     .await??;
  77
  78     let res = PrivateMessageResponse {
  79       private_message_view,
  80     };
  81
  82     // Send notifications to the local recipient, if one exists
  83     let recipient_id = data.recipient_id;
  84     if let Ok(local_recipient) = blocking(context.pool(), move |conn| {
  85       LocalUserView::read_person(conn, recipient_id)
  86     })
  87     .await?
  88     {
  89       send_email_to_user(
  90         &local_recipient,
  91         "Private Message from",
  92         "Private Message",
  93         &content_slurs_removed,
  94       );
  95
  96       let local_recipient_id = local_recipient.local_user.id;
  97       context.chat_server().do_send(SendUserRoomMessage {
  98         op: UserOperationCrud::CreatePrivateMessage,
  99         response: res.clone(),
 100         local_recipient_id,
 101         websocket_id,
 102       });
 103     }
 104
 105     Ok(res)
 106   }
 107 }