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