crates/db_schema/src/impls/private_message.rs

   1 use crate::{
   2   newtypes::{DbUrl, PersonId, PrivateMessageId},
   3   schema::private_message::dsl::{ap_id, private_message, read, recipient_id},
   4   source::private_message::{PrivateMessage, PrivateMessageInsertForm, PrivateMessageUpdateForm},
   5   traits::Crud,
   6   utils::{get_conn, DbPool},
   7 };
   8 use diesel::{dsl::insert_into, result::Error, ExpressionMethods, QueryDsl};
   9 use diesel_async::RunQueryDsl;
  10 use lemmy_utils::error::LemmyError;
  11 use url::Url;
  12
  13 #[async_trait]
  14 impl Crud for PrivateMessage {
  15   type InsertForm = PrivateMessageInsertForm;
  16   type UpdateForm = PrivateMessageUpdateForm;
  17   type IdType = PrivateMessageId;
  18
  19   async fn create(pool: &mut DbPool<'_>, form: &Self::InsertForm) -> Result<Self, Error> {
  20     let conn = &mut get_conn(pool).await?;
  21     insert_into(private_message)
  22       .values(form)
  23       .on_conflict(ap_id)
  24       .do_update()
  25       .set(form)
  26       .get_result::<Self>(conn)
  27       .await
  28   }
  29
  30   async fn update(
  31     pool: &mut DbPool<'_>,
  32     private_message_id: PrivateMessageId,
  33     form: &Self::UpdateForm,
  34   ) -> Result<Self, Error> {
  35     let conn = &mut get_conn(pool).await?;
  36     diesel::update(private_message.find(private_message_id))
  37       .set(form)
  38       .get_result::<Self>(conn)
  39       .await
  40   }
  41 }
  42
  43 impl PrivateMessage {
  44   pub async fn mark_all_as_read(
  45     pool: &mut DbPool<'_>,
  46     for_recipient_id: PersonId,
  47   ) -> Result<Vec<PrivateMessage>, Error> {
  48     let conn = &mut get_conn(pool).await?;
  49     diesel::update(
  50       private_message
  51         .filter(recipient_id.eq(for_recipient_id))
  52         .filter(read.eq(false)),
  53     )
  54     .set(read.eq(true))
  55     .get_results::<Self>(conn)
  56     .await
  57   }
  58
  59   pub async fn read_from_apub_id(
  60     pool: &mut DbPool<'_>,
  61     object_id: Url,
  62   ) -> Result<Option<Self>, LemmyError> {
  63     let conn = &mut get_conn(pool).await?;
  64     let object_id: DbUrl = object_id.into();
  65     Ok(
  66       private_message
  67         .filter(ap_id.eq(object_id))
  68         .first::<PrivateMessage>(conn)
  69         .await
  70         .ok()
  71         .map(Into::into),
  72     )
  73   }
  74 }
  75
  76 #[cfg(test)]
  77 mod tests {
  78   #![allow(clippy::unwrap_used)]
  79   #![allow(clippy::indexing_slicing)]
  80
  81   use crate::{
  82     source::{
  83       instance::Instance,
  84       person::{Person, PersonInsertForm},
  85       private_message::{PrivateMessage, PrivateMessageInsertForm, PrivateMessageUpdateForm},
  86     },
  87     traits::Crud,
  88     utils::build_db_pool_for_tests,
  89   };
  90   use serial_test::serial;
  91
  92   #[tokio::test]
  93   #[serial]
  94   async fn test_crud() {
  95     let pool = &build_db_pool_for_tests().await;
  96     let pool = &mut pool.into();
  97
  98     let inserted_instance = Instance::read_or_create(pool, "my_domain.tld".to_string())
  99       .await
 100       .unwrap();
 101
 102     let creator_form = PersonInsertForm::builder()
 103       .name("creator_pm".into())
 104       .public_key("pubkey".to_string())
 105       .instance_id(inserted_instance.id)
 106       .build();
 107
 108     let inserted_creator = Person::create(pool, &creator_form).await.unwrap();
 109
 110     let recipient_form = PersonInsertForm::builder()
 111       .name("recipient_pm".into())
 112       .public_key("pubkey".to_string())
 113       .instance_id(inserted_instance.id)
 114       .build();
 115
 116     let inserted_recipient = Person::create(pool, &recipient_form).await.unwrap();
 117
 118     let private_message_form = PrivateMessageInsertForm::builder()
 119       .content("A test private message".into())
 120       .creator_id(inserted_creator.id)
 121       .recipient_id(inserted_recipient.id)
 122       .build();
 123
 124     let inserted_private_message = PrivateMessage::create(pool, &private_message_form)
 125       .await
 126       .unwrap();
 127
 128     let expected_private_message = PrivateMessage {
 129       id: inserted_private_message.id,
 130       content: "A test private message".into(),
 131       creator_id: inserted_creator.id,
 132       recipient_id: inserted_recipient.id,
 133       deleted: false,
 134       read: false,
 135       updated: None,
 136       published: inserted_private_message.published,
 137       ap_id: inserted_private_message.ap_id.clone(),
 138       local: true,
 139     };
 140
 141     let read_private_message = PrivateMessage::read(pool, inserted_private_message.id)
 142       .await
 143       .unwrap();
 144
 145     let private_message_update_form = PrivateMessageUpdateForm {
 146       content: Some("A test private message".into()),
 147       ..Default::default()
 148     };
 149     let updated_private_message = PrivateMessage::update(
 150       pool,
 151       inserted_private_message.id,
 152       &private_message_update_form,
 153     )
 154     .await
 155     .unwrap();
 156
 157     let deleted_private_message = PrivateMessage::update(
 158       pool,
 159       inserted_private_message.id,
 160       &PrivateMessageUpdateForm {
 161         deleted: Some(true),
 162         ..Default::default()
 163       },
 164     )
 165     .await
 166     .unwrap();
 167     let marked_read_private_message = PrivateMessage::update(
 168       pool,
 169       inserted_private_message.id,
 170       &PrivateMessageUpdateForm {
 171         read: Some(true),
 172         ..Default::default()
 173       },
 174     )
 175     .await
 176     .unwrap();
 177     Person::delete(pool, inserted_creator.id).await.unwrap();
 178     Person::delete(pool, inserted_recipient.id).await.unwrap();
 179     Instance::delete(pool, inserted_instance.id).await.unwrap();
 180
 181     assert_eq!(expected_private_message, read_private_message);
 182     assert_eq!(expected_private_message, updated_private_message);
 183     assert_eq!(expected_private_message, inserted_private_message);
 184     assert!(deleted_private_message.deleted);
 185     assert!(marked_read_private_message.read);
 186   }
 187 }