crates/db_queries/src/source/private_message.rs

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