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::*, Url};
   4
   5 impl Crud<PrivateMessageForm> for PrivateMessage {
   6   fn read(conn: &PgConnection, private_message_id: i32) -> 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: i32,
  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: &Url) -> 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: i32,
  56     apub_id: Url,
  57   ) -> Result<PrivateMessage, Error>;
  58   fn update_content(
  59     conn: &PgConnection,
  60     private_message_id: i32,
  61     new_content: &str,
  62   ) -> Result<PrivateMessage, Error>;
  63   fn update_deleted(
  64     conn: &PgConnection,
  65     private_message_id: i32,
  66     new_deleted: bool,
  67   ) -> Result<PrivateMessage, Error>;
  68   fn update_read(
  69     conn: &PgConnection,
  70     private_message_id: i32,
  71     new_read: bool,
  72   ) -> Result<PrivateMessage, Error>;
  73   fn mark_all_as_read(
  74     conn: &PgConnection,
  75     for_recipient_id: i32,
  76   ) -> Result<Vec<PrivateMessage>, Error>;
  77 }
  78
  79 impl PrivateMessage_ for PrivateMessage {
  80   fn update_ap_id(
  81     conn: &PgConnection,
  82     private_message_id: i32,
  83     apub_id: Url,
  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: i32,
  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: i32,
 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: i32,
 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: i32,
 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::{
 143     establish_unpooled_connection,
 144     source::private_message::PrivateMessage_,
 145     Crud,
 146     ListingType,
 147     SortType,
 148   };
 149   use lemmy_db_schema::source::{private_message::*, user::*};
 150   use serial_test::serial;
 151
 152   #[test]
 153   #[serial]
 154   fn test_crud() {
 155     let conn = establish_unpooled_connection();
 156
 157     let creator_form = UserForm {
 158       name: "creator_pm".into(),
 159       preferred_username: None,
 160       password_encrypted: "nope".into(),
 161       email: None,
 162       matrix_user_id: None,
 163       avatar: None,
 164       banner: None,
 165       admin: false,
 166       banned: Some(false),
 167       published: None,
 168       updated: None,
 169       show_nsfw: false,
 170       theme: "browser".into(),
 171       default_sort_type: SortType::Hot as i16,
 172       default_listing_type: ListingType::Subscribed as i16,
 173       lang: "browser".into(),
 174       show_avatars: true,
 175       send_notifications_to_email: false,
 176       actor_id: None,
 177       bio: None,
 178       local: true,
 179       private_key: None,
 180       public_key: None,
 181       last_refreshed_at: None,
 182       inbox_url: None,
 183       shared_inbox_url: None,
 184     };
 185
 186     let inserted_creator = User_::create(&conn, &creator_form).unwrap();
 187
 188     let recipient_form = UserForm {
 189       name: "recipient_pm".into(),
 190       preferred_username: None,
 191       password_encrypted: "nope".into(),
 192       email: None,
 193       matrix_user_id: None,
 194       avatar: None,
 195       banner: None,
 196       admin: false,
 197       banned: Some(false),
 198       published: None,
 199       updated: None,
 200       show_nsfw: false,
 201       theme: "browser".into(),
 202       default_sort_type: SortType::Hot as i16,
 203       default_listing_type: ListingType::Subscribed as i16,
 204       lang: "browser".into(),
 205       show_avatars: true,
 206       send_notifications_to_email: false,
 207       actor_id: None,
 208       bio: None,
 209       local: true,
 210       private_key: None,
 211       public_key: None,
 212       last_refreshed_at: None,
 213       inbox_url: None,
 214       shared_inbox_url: None,
 215     };
 216
 217     let inserted_recipient = User_::create(&conn, &recipient_form).unwrap();
 218
 219     let private_message_form = PrivateMessageForm {
 220       content: "A test private message".into(),
 221       creator_id: inserted_creator.id,
 222       recipient_id: inserted_recipient.id,
 223       deleted: None,
 224       read: None,
 225       published: None,
 226       updated: None,
 227       ap_id: None,
 228       local: true,
 229     };
 230
 231     let inserted_private_message = PrivateMessage::create(&conn, &private_message_form).unwrap();
 232
 233     let expected_private_message = PrivateMessage {
 234       id: inserted_private_message.id,
 235       content: "A test private message".into(),
 236       creator_id: inserted_creator.id,
 237       recipient_id: inserted_recipient.id,
 238       deleted: false,
 239       read: false,
 240       updated: None,
 241       published: inserted_private_message.published,
 242       ap_id: inserted_private_message.ap_id.to_owned(),
 243       local: true,
 244     };
 245
 246     let read_private_message = PrivateMessage::read(&conn, inserted_private_message.id).unwrap();
 247     let updated_private_message =
 248       PrivateMessage::update(&conn, inserted_private_message.id, &private_message_form).unwrap();
 249     let deleted_private_message =
 250       PrivateMessage::update_deleted(&conn, inserted_private_message.id, true).unwrap();
 251     let marked_read_private_message =
 252       PrivateMessage::update_read(&conn, inserted_private_message.id, true).unwrap();
 253     User_::delete(&conn, inserted_creator.id).unwrap();
 254     User_::delete(&conn, inserted_recipient.id).unwrap();
 255
 256     assert_eq!(expected_private_message, read_private_message);
 257     assert_eq!(expected_private_message, updated_private_message);
 258     assert_eq!(expected_private_message, inserted_private_message);
 259     assert!(deleted_private_message.deleted);
 260     assert!(marked_read_private_message.read);
 261   }
 262 }