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
 151   #[test]
 152   fn test_crud() {
 153     let conn = establish_unpooled_connection();
 154
 155     let creator_form = UserForm {
 156       name: "creator_pm".into(),
 157       preferred_username: None,
 158       password_encrypted: "nope".into(),
 159       email: None,
 160       matrix_user_id: None,
 161       avatar: None,
 162       banner: None,
 163       admin: false,
 164       banned: Some(false),
 165       published: None,
 166       updated: None,
 167       show_nsfw: false,
 168       theme: "browser".into(),
 169       default_sort_type: SortType::Hot as i16,
 170       default_listing_type: ListingType::Subscribed as i16,
 171       lang: "browser".into(),
 172       show_avatars: true,
 173       send_notifications_to_email: false,
 174       actor_id: None,
 175       bio: None,
 176       local: true,
 177       private_key: None,
 178       public_key: None,
 179       last_refreshed_at: None,
 180       inbox_url: None,
 181       shared_inbox_url: None,
 182     };
 183
 184     let inserted_creator = User_::create(&conn, &creator_form).unwrap();
 185
 186     let recipient_form = UserForm {
 187       name: "recipient_pm".into(),
 188       preferred_username: None,
 189       password_encrypted: "nope".into(),
 190       email: None,
 191       matrix_user_id: None,
 192       avatar: None,
 193       banner: None,
 194       admin: false,
 195       banned: Some(false),
 196       published: None,
 197       updated: None,
 198       show_nsfw: false,
 199       theme: "browser".into(),
 200       default_sort_type: SortType::Hot as i16,
 201       default_listing_type: ListingType::Subscribed as i16,
 202       lang: "browser".into(),
 203       show_avatars: true,
 204       send_notifications_to_email: false,
 205       actor_id: None,
 206       bio: None,
 207       local: true,
 208       private_key: None,
 209       public_key: None,
 210       last_refreshed_at: None,
 211       inbox_url: None,
 212       shared_inbox_url: None,
 213     };
 214
 215     let inserted_recipient = User_::create(&conn, &recipient_form).unwrap();
 216
 217     let private_message_form = PrivateMessageForm {
 218       content: "A test private message".into(),
 219       creator_id: inserted_creator.id,
 220       recipient_id: inserted_recipient.id,
 221       deleted: None,
 222       read: None,
 223       published: None,
 224       updated: None,
 225       ap_id: None,
 226       local: true,
 227     };
 228
 229     let inserted_private_message = PrivateMessage::create(&conn, &private_message_form).unwrap();
 230
 231     let expected_private_message = PrivateMessage {
 232       id: inserted_private_message.id,
 233       content: "A test private message".into(),
 234       creator_id: inserted_creator.id,
 235       recipient_id: inserted_recipient.id,
 236       deleted: false,
 237       read: false,
 238       updated: None,
 239       published: inserted_private_message.published,
 240       ap_id: inserted_private_message.ap_id.to_owned(),
 241       local: true,
 242     };
 243
 244     let read_private_message = PrivateMessage::read(&conn, inserted_private_message.id).unwrap();
 245     let updated_private_message =
 246       PrivateMessage::update(&conn, inserted_private_message.id, &private_message_form).unwrap();
 247     let deleted_private_message =
 248       PrivateMessage::update_deleted(&conn, inserted_private_message.id, true).unwrap();
 249     let marked_read_private_message =
 250       PrivateMessage::update_read(&conn, inserted_private_message.id, true).unwrap();
 251     User_::delete(&conn, inserted_creator.id).unwrap();
 252     User_::delete(&conn, inserted_recipient.id).unwrap();
 253
 254     assert_eq!(expected_private_message, read_private_message);
 255     assert_eq!(expected_private_message, updated_private_message);
 256     assert_eq!(expected_private_message, inserted_private_message);
 257     assert!(deleted_private_message.deleted);
 258     assert!(marked_read_private_message.read);
 259   }
 260 }