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