crates/db_queries/src/source/private_message.rs

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