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