crates/db_schema/src/impls/private_message.rs

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