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 = 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     .map_err(|_| ApiError::err("couldnt_create_private_message"))?;
  65
  66     updated_private_message
  67       .send_create(&local_user_view.person, context)
  68       .await?;
  69
  70     let private_message_view = blocking(context.pool(), move |conn| {
  71       PrivateMessageView::read(conn, inserted_private_message.id)
  72     })
  73     .await??;
  74
  75     let res = PrivateMessageResponse {
  76       private_message_view,
  77     };
  78
  79     // Send notifications to the local recipient, if one exists
  80     let recipient_id = data.recipient_id;
  81     if let Ok(local_recipient) = blocking(context.pool(), move |conn| {
  82       LocalUserView::read_person(conn, recipient_id)
  83     })
  84     .await?
  85     {
  86       send_email_to_user(
  87         &local_recipient,
  88         "Private Message from",
  89         "Private Message",
  90         &content_slurs_removed,
  91       );
  92
  93       let local_recipient_id = local_recipient.local_user.id;
  94       context.chat_server().do_send(SendUserRoomMessage {
  95         op: UserOperationCrud::CreatePrivateMessage,
  96         response: res.clone(),
  97         local_recipient_id,
  98         websocket_id,
  99       });
 100     }
 101
 102     Ok(res)
 103   }
 104 }