crates/db_schema/src/impls/private_message.rs

   1 use crate::{
   2   naive_now,
   3   newtypes::{DbUrl, PersonId, PrivateMessageId},
   4   source::private_message::*,
   5   traits::{Crud, DeleteableOrRemoveable},
   6 };
   7 use diesel::{dsl::*, result::Error, *};
   8 use lemmy_utils::LemmyError;
   9 use url::Url;
  10
  11 impl Crud for PrivateMessage {
  12   type Form = PrivateMessageForm;
  13   type IdType = PrivateMessageId;
  14   fn read(conn: &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: &PgConnection, private_message_form: &PrivateMessageForm) -> Result<Self, Error> {
  20     use crate::schema::private_message::dsl::*;
  21     insert_into(private_message)
  22       .values(private_message_form)
  23       .get_result::<Self>(conn)
  24   }
  25
  26   fn update(
  27     conn: &PgConnection,
  28     private_message_id: PrivateMessageId,
  29     private_message_form: &PrivateMessageForm,
  30   ) -> Result<Self, Error> {
  31     use crate::schema::private_message::dsl::*;
  32     diesel::update(private_message.find(private_message_id))
  33       .set(private_message_form)
  34       .get_result::<Self>(conn)
  35   }
  36 }
  37
  38 impl PrivateMessage {
  39   pub fn update_ap_id(
  40     conn: &PgConnection,
  41     private_message_id: PrivateMessageId,
  42     apub_id: DbUrl,
  43   ) -> Result<PrivateMessage, Error> {
  44     use crate::schema::private_message::dsl::*;
  45
  46     diesel::update(private_message.find(private_message_id))
  47       .set(ap_id.eq(apub_id))
  48       .get_result::<Self>(conn)
  49   }
  50
  51   pub fn update_content(
  52     conn: &PgConnection,
  53     private_message_id: PrivateMessageId,
  54     new_content: &str,
  55   ) -> Result<PrivateMessage, Error> {
  56     use crate::schema::private_message::dsl::*;
  57     diesel::update(private_message.find(private_message_id))
  58       .set((content.eq(new_content), updated.eq(naive_now())))
  59       .get_result::<Self>(conn)
  60   }
  61
  62   pub fn update_deleted(
  63     conn: &PgConnection,
  64     private_message_id: PrivateMessageId,
  65     new_deleted: bool,
  66   ) -> Result<PrivateMessage, Error> {
  67     use crate::schema::private_message::dsl::*;
  68     diesel::update(private_message.find(private_message_id))
  69       .set(deleted.eq(new_deleted))
  70       .get_result::<Self>(conn)
  71   }
  72
  73   pub fn update_read(
  74     conn: &PgConnection,
  75     private_message_id: PrivateMessageId,
  76     new_read: bool,
  77   ) -> Result<PrivateMessage, Error> {
  78     use crate::schema::private_message::dsl::*;
  79     diesel::update(private_message.find(private_message_id))
  80       .set(read.eq(new_read))
  81       .get_result::<Self>(conn)
  82   }
  83
  84   pub fn mark_all_as_read(
  85     conn: &PgConnection,
  86     for_recipient_id: PersonId,
  87   ) -> Result<Vec<PrivateMessage>, Error> {
  88     use crate::schema::private_message::dsl::*;
  89     diesel::update(
  90       private_message
  91         .filter(recipient_id.eq(for_recipient_id))
  92         .filter(read.eq(false)),
  93     )
  94     .set(read.eq(true))
  95     .get_results::<Self>(conn)
  96   }
  97
  98   pub fn upsert(
  99     conn: &PgConnection,
 100     private_message_form: &PrivateMessageForm,
 101   ) -> Result<PrivateMessage, Error> {
 102     use crate::schema::private_message::dsl::*;
 103     insert_into(private_message)
 104       .values(private_message_form)
 105       .on_conflict(ap_id)
 106       .do_update()
 107       .set(private_message_form)
 108       .get_result::<Self>(conn)
 109   }
 110
 111   pub fn read_from_apub_id(
 112     conn: &PgConnection,
 113     object_id: Url,
 114   ) -> Result<Option<Self>, LemmyError> {
 115     use crate::schema::private_message::dsl::*;
 116     let object_id: DbUrl = object_id.into();
 117     Ok(
 118       private_message
 119         .filter(ap_id.eq(object_id))
 120         .first::<PrivateMessage>(conn)
 121         .ok()
 122         .map(Into::into),
 123     )
 124   }
 125 }
 126
 127 impl DeleteableOrRemoveable for PrivateMessage {
 128   fn blank_out_deleted_or_removed_info(mut self) -> Self {
 129     self.content = "".into();
 130     self
 131   }
 132 }
 133
 134 #[cfg(test)]
 135 mod tests {
 136   use crate::{
 137     establish_unpooled_connection,
 138     source::{person::*, private_message::*},
 139     traits::Crud,
 140   };
 141   use serial_test::serial;
 142
 143   #[test]
 144   #[serial]
 145   fn test_crud() {
 146     let conn = establish_unpooled_connection();
 147
 148     let creator_form = PersonForm {
 149       name: "creator_pm".into(),
 150       ..PersonForm::default()
 151     };
 152
 153     let inserted_creator = Person::create(&conn, &creator_form).unwrap();
 154
 155     let recipient_form = PersonForm {
 156       name: "recipient_pm".into(),
 157       ..PersonForm::default()
 158     };
 159
 160     let inserted_recipient = Person::create(&conn, &recipient_form).unwrap();
 161
 162     let private_message_form = PrivateMessageForm {
 163       content: "A test private message".into(),
 164       creator_id: inserted_creator.id,
 165       recipient_id: inserted_recipient.id,
 166       ..PrivateMessageForm::default()
 167     };
 168
 169     let inserted_private_message = PrivateMessage::create(&conn, &private_message_form).unwrap();
 170
 171     let expected_private_message = PrivateMessage {
 172       id: inserted_private_message.id,
 173       content: "A test private message".into(),
 174       creator_id: inserted_creator.id,
 175       recipient_id: inserted_recipient.id,
 176       deleted: false,
 177       read: false,
 178       updated: None,
 179       published: inserted_private_message.published,
 180       ap_id: inserted_private_message.ap_id.to_owned(),
 181       local: true,
 182     };
 183
 184     let read_private_message = PrivateMessage::read(&conn, inserted_private_message.id).unwrap();
 185     let updated_private_message =
 186       PrivateMessage::update(&conn, inserted_private_message.id, &private_message_form).unwrap();
 187     let deleted_private_message =
 188       PrivateMessage::update_deleted(&conn, inserted_private_message.id, true).unwrap();
 189     let marked_read_private_message =
 190       PrivateMessage::update_read(&conn, inserted_private_message.id, true).unwrap();
 191     Person::delete(&conn, inserted_creator.id).unwrap();
 192     Person::delete(&conn, inserted_recipient.id).unwrap();
 193
 194     assert_eq!(expected_private_message, read_private_message);
 195     assert_eq!(expected_private_message, updated_private_message);
 196     assert_eq!(expected_private_message, inserted_private_message);
 197     assert!(deleted_private_message.deleted);
 198     assert!(marked_read_private_message.read);
 199   }
 200 }