X-Git-Url: http://these/git/?a=blobdiff_plain;f=crates%2Fapi_crud%2Fsrc%2Fprivate_message%2Fcreate.rs;h=3b1a625f63b4284a9d0b3223b77c997f664014d5;hb=3471f3533cb724b2cf6953d563aadfcc9f66c1d2;hp=0256126304a3ef5bf45383f645699f1cf3bbdc15;hpb=01fc1228d510470d5fd1bc90414d5250fc356658;p=lemmy.git

diff --git a/crates/api_crud/src/private_message/create.rs b/crates/api_crud/src/private_message/create.rs
index 02561263..3b1a625f 100644
--- a/crates/api_crud/src/private_message/create.rs
+++ b/crates/api_crud/src/private_message/create.rs
@@ -1,112 +1,104 @@
 use crate::PerformCrud;
 use actix_web::web::Data;
 use lemmy_api_common::{
-  blocking,
-  get_local_user_view_from_jwt,
-  person::{CreatePrivateMessage, PrivateMessageResponse},
-  send_email_to_user,
+  context::LemmyContext,
+  private_message::{CreatePrivateMessage, PrivateMessageResponse},
+  utils::{
+    check_person_block,
+    generate_local_apub_endpoint,
+    get_interface_language,
+    local_site_to_slur_regex,
+    local_user_view_from_jwt,
+    sanitize_html,
+    send_email_to_user,
+    EndpointType,
+  },
+};
+use lemmy_db_schema::{
+  source::{
+    local_site::LocalSite,
+    private_message::{PrivateMessage, PrivateMessageInsertForm, PrivateMessageUpdateForm},
+  },
+  traits::Crud,
+};
+use lemmy_db_views::structs::{LocalUserView, PrivateMessageView};
+use lemmy_utils::{
+  error::{LemmyError, LemmyErrorExt, LemmyErrorType},
+  utils::{slurs::remove_slurs, validation::is_valid_body_field},
 };
-use lemmy_apub::{generate_apub_endpoint, ApubObjectType, EndpointType};
-use lemmy_db_queries::{source::private_message::PrivateMessage_, Crud};
-use lemmy_db_schema::source::private_message::{PrivateMessage, PrivateMessageForm};
-use lemmy_db_views::{local_user_view::LocalUserView, private_message_view::PrivateMessageView};
-use lemmy_utils::{utils::remove_slurs, ApiError, ConnectionId, LemmyError};
-use lemmy_websocket::{messages::SendUserRoomMessage, LemmyContext, UserOperationCrud};
 
 #[async_trait::async_trait(?Send)]
 impl PerformCrud for CreatePrivateMessage {
   type Response = PrivateMessageResponse;
 
+  #[tracing::instrument(skip(self, context))]
   async fn perform(
     &self,
     context: &Data<LemmyContext>,
-    websocket_id: Option<ConnectionId>,
   ) -> Result<PrivateMessageResponse, LemmyError> {
-    let data: &CreatePrivateMessage = &self;
-    let local_user_view = get_local_user_view_from_jwt(&data.auth, context.pool()).await?;
+    let data: &CreatePrivateMessage = self;
+    let local_user_view = local_user_view_from_jwt(&data.auth, context).await?;
+    let local_site = LocalSite::read(&mut context.pool()).await?;
+
+    let content = sanitize_html(&data.content);
+    let content = remove_slurs(&content, &local_site_to_slur_regex(&local_site));
+    is_valid_body_field(&Some(content.clone()), false)?;
 
-    let content_slurs_removed = remove_slurs(&data.content.to_owned());
+    check_person_block(
+      local_user_view.person.id,
+      data.recipient_id,
+      &mut context.pool(),
+    )
+    .await?;
 
-    let private_message_form = PrivateMessageForm {
-      content: content_slurs_removed.to_owned(),
-      creator_id: local_user_view.person.id,
-      recipient_id: data.recipient_id,
-      deleted: None,
-      read: None,
-      updated: None,
-      ap_id: None,
-      local: true,
-      published: None,
-    };
+    let private_message_form = PrivateMessageInsertForm::builder()
+      .content(content.clone())
+      .creator_id(local_user_view.person.id)
+      .recipient_id(data.recipient_id)
+      .build();
 
-    let inserted_private_message = match blocking(context.pool(), move |conn| {
-      PrivateMessage::create(conn, &private_message_form)
-    })
-    .await?
-    {
-      Ok(private_message) => private_message,
-      Err(_e) => {
-        return Err(ApiError::err("couldnt_create_private_message").into());
-      }
-    };
+    let inserted_private_message =
+      PrivateMessage::create(&mut context.pool(), &private_message_form)
+        .await
+        .with_lemmy_type(LemmyErrorType::CouldntCreatePrivateMessage)?;
 
     let inserted_private_message_id = inserted_private_message.id;
-    let updated_private_message = match blocking(
-      context.pool(),
-      move |conn| -> Result<PrivateMessage, LemmyError> {
-        let apub_id = generate_apub_endpoint(
-          EndpointType::PrivateMessage,
-          &inserted_private_message_id.to_string(),
-        )?;
-        Ok(PrivateMessage::update_ap_id(
-          &conn,
-          inserted_private_message_id,
-          apub_id,
-        )?)
-      },
+    let protocol_and_hostname = context.settings().get_protocol_and_hostname();
+    let apub_id = generate_local_apub_endpoint(
+      EndpointType::PrivateMessage,
+      &inserted_private_message_id.to_string(),
+      &protocol_and_hostname,
+    )?;
+    PrivateMessage::update(
+      &mut context.pool(),
+      inserted_private_message.id,
+      &PrivateMessageUpdateForm::builder()
+        .ap_id(Some(apub_id))
+        .build(),
     )
-    .await?
-    {
-      Ok(private_message) => private_message,
-      Err(_e) => return Err(ApiError::err("couldnt_create_private_message").into()),
-    };
+    .await
+    .with_lemmy_type(LemmyErrorType::CouldntCreatePrivateMessage)?;
 
-    updated_private_message
-      .send_create(&local_user_view.person, context)
-      .await?;
+    let view = PrivateMessageView::read(&mut context.pool(), inserted_private_message.id).await?;
 
-    let private_message_view = blocking(context.pool(), move |conn| {
-      PrivateMessageView::read(conn, inserted_private_message.id)
-    })
-    .await??;
-
-    let res = PrivateMessageResponse {
-      private_message_view,
-    };
-
-    // Send notifications to the local recipient, if one exists
-    let recipient_id = data.recipient_id;
-    if let Ok(local_recipient) = blocking(context.pool(), move |conn| {
-      LocalUserView::read_person(conn, recipient_id)
-    })
-    .await?
-    {
+    // Send email to the local recipient, if one exists
+    if view.recipient.local {
+      let recipient_id = data.recipient_id;
+      let local_recipient = LocalUserView::read_person(&mut context.pool(), recipient_id).await?;
+      let lang = get_interface_language(&local_recipient);
+      let inbox_link = format!("{}/inbox", context.settings().get_protocol_and_hostname());
+      let sender_name = &local_user_view.person.name;
       send_email_to_user(
         &local_recipient,
-        "Private Message from",
-        "Private Message",
-        &content_slurs_removed,
-      );
-
-      let local_recipient_id = local_recipient.local_user.id;
-      context.chat_server().do_send(SendUserRoomMessage {
-        op: UserOperationCrud::CreatePrivateMessage,
-        response: res.clone(),
-        local_recipient_id,
-        websocket_id,
-      });
+        &lang.notification_private_message_subject(sender_name),
+        &lang.notification_private_message_body(inbox_link, &content, sender_name),
+        context.settings(),
+      )
+      .await;
     }
 
-    Ok(res)
+    Ok(PrivateMessageResponse {
+      private_message_view: view,
+    })
   }
 }