crates/db_queries/src/source/private_message.rs

   1 use crate::{ApubObject, Crud};
   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 #[cfg(test)]
 141 mod tests {
 142   use crate::{establish_unpooled_connection, source::private_message::PrivateMessage_, Crud};
 143   use lemmy_db_schema::source::{person::*, private_message::*};
 144   use serial_test::serial;
 145
 146   #[test]
 147   #[serial]
 148   fn test_crud() {
 149     let conn = establish_unpooled_connection();
 150
 151     let creator_form = PersonForm {
 152       name: "creator_pm".into(),
 153       preferred_username: None,
 154       avatar: None,
 155       banner: None,
 156       banned: None,
 157       deleted: None,
 158       published: None,
 159       updated: None,
 160       actor_id: None,
 161       bio: None,
 162       local: None,
 163       private_key: None,
 164       public_key: None,
 165       last_refreshed_at: None,
 166       inbox_url: None,
 167       shared_inbox_url: None,
 168       matrix_user_id: None,
 169     };
 170
 171     let inserted_creator = Person::create(&conn, &creator_form).unwrap();
 172
 173     let recipient_form = PersonForm {
 174       name: "recipient_pm".into(),
 175       preferred_username: None,
 176       avatar: None,
 177       banner: None,
 178       banned: None,
 179       deleted: None,
 180       published: None,
 181       updated: None,
 182       actor_id: None,
 183       bio: None,
 184       local: None,
 185       private_key: None,
 186       public_key: None,
 187       last_refreshed_at: None,
 188       inbox_url: None,
 189       shared_inbox_url: None,
 190       matrix_user_id: None,
 191     };
 192
 193     let inserted_recipient = Person::create(&conn, &recipient_form).unwrap();
 194
 195     let private_message_form = PrivateMessageForm {
 196       content: "A test private message".into(),
 197       creator_id: inserted_creator.id,
 198       recipient_id: inserted_recipient.id,
 199       deleted: None,
 200       read: None,
 201       published: None,
 202       updated: None,
 203       ap_id: None,
 204       local: true,
 205     };
 206
 207     let inserted_private_message = PrivateMessage::create(&conn, &private_message_form).unwrap();
 208
 209     let expected_private_message = PrivateMessage {
 210       id: inserted_private_message.id,
 211       content: "A test private message".into(),
 212       creator_id: inserted_creator.id,
 213       recipient_id: inserted_recipient.id,
 214       deleted: false,
 215       read: false,
 216       updated: None,
 217       published: inserted_private_message.published,
 218       ap_id: inserted_private_message.ap_id.to_owned(),
 219       local: true,
 220     };
 221
 222     let read_private_message = PrivateMessage::read(&conn, inserted_private_message.id).unwrap();
 223     let updated_private_message =
 224       PrivateMessage::update(&conn, inserted_private_message.id, &private_message_form).unwrap();
 225     let deleted_private_message =
 226       PrivateMessage::update_deleted(&conn, inserted_private_message.id, true).unwrap();
 227     let marked_read_private_message =
 228       PrivateMessage::update_read(&conn, inserted_private_message.id, true).unwrap();
 229     Person::delete(&conn, inserted_creator.id).unwrap();
 230     Person::delete(&conn, inserted_recipient.id).unwrap();
 231
 232     assert_eq!(expected_private_message, read_private_message);
 233     assert_eq!(expected_private_message, updated_private_message);
 234     assert_eq!(expected_private_message, inserted_private_message);
 235     assert!(deleted_private_message.deleted);
 236     assert!(marked_read_private_message.read);
 237   }
 238 }