server/lemmy_db/src/private_message.rs

   1 use crate::{naive_now, schema::private_message, Crud};
   2 use diesel::{dsl::*, result::Error, *};
   3 use serde::{Deserialize, Serialize};
   4
   5 #[derive(Queryable, Identifiable, PartialEq, Debug, Serialize, Deserialize)]
   6 #[table_name = "private_message"]
   7 pub struct PrivateMessage {
   8   pub id: i32,
   9   pub creator_id: i32,
  10   pub recipient_id: i32,
  11   pub content: String,
  12   pub deleted: bool,
  13   pub read: bool,
  14   pub published: chrono::NaiveDateTime,
  15   pub updated: Option<chrono::NaiveDateTime>,
  16   pub ap_id: String,
  17   pub local: bool,
  18 }
  19
  20 #[derive(Insertable, AsChangeset, Clone)]
  21 #[table_name = "private_message"]
  22 pub struct PrivateMessageForm {
  23   pub creator_id: i32,
  24   pub recipient_id: i32,
  25   pub content: String,
  26   pub deleted: Option<bool>,
  27   pub read: Option<bool>,
  28   pub published: Option<chrono::NaiveDateTime>,
  29   pub updated: Option<chrono::NaiveDateTime>,
  30   pub ap_id: String,
  31   pub local: bool,
  32 }
  33
  34 impl Crud<PrivateMessageForm> for PrivateMessage {
  35   fn read(conn: &PgConnection, private_message_id: i32) -> Result<Self, Error> {
  36     use crate::schema::private_message::dsl::*;
  37     private_message.find(private_message_id).first::<Self>(conn)
  38   }
  39
  40   fn delete(conn: &PgConnection, private_message_id: i32) -> Result<usize, Error> {
  41     use crate::schema::private_message::dsl::*;
  42     diesel::delete(private_message.find(private_message_id)).execute(conn)
  43   }
  44
  45   fn create(conn: &PgConnection, private_message_form: &PrivateMessageForm) -> Result<Self, Error> {
  46     use crate::schema::private_message::dsl::*;
  47     insert_into(private_message)
  48       .values(private_message_form)
  49       .get_result::<Self>(conn)
  50   }
  51
  52   fn update(
  53     conn: &PgConnection,
  54     private_message_id: i32,
  55     private_message_form: &PrivateMessageForm,
  56   ) -> Result<Self, Error> {
  57     use crate::schema::private_message::dsl::*;
  58     diesel::update(private_message.find(private_message_id))
  59       .set(private_message_form)
  60       .get_result::<Self>(conn)
  61   }
  62 }
  63
  64 impl PrivateMessage {
  65   pub fn update_ap_id(
  66     conn: &PgConnection,
  67     private_message_id: i32,
  68     apub_id: String,
  69   ) -> Result<Self, Error> {
  70     use crate::schema::private_message::dsl::*;
  71
  72     diesel::update(private_message.find(private_message_id))
  73       .set(ap_id.eq(apub_id))
  74       .get_result::<Self>(conn)
  75   }
  76
  77   pub fn read_from_apub_id(conn: &PgConnection, object_id: &str) -> Result<Self, Error> {
  78     use crate::schema::private_message::dsl::*;
  79     private_message
  80       .filter(ap_id.eq(object_id))
  81       .first::<Self>(conn)
  82   }
  83
  84   pub fn update_content(
  85     conn: &PgConnection,
  86     private_message_id: i32,
  87     new_content: &str,
  88   ) -> Result<Self, Error> {
  89     use crate::schema::private_message::dsl::*;
  90     diesel::update(private_message.find(private_message_id))
  91       .set((content.eq(new_content), updated.eq(naive_now())))
  92       .get_result::<Self>(conn)
  93   }
  94
  95   pub fn update_deleted(
  96     conn: &PgConnection,
  97     private_message_id: i32,
  98     new_deleted: bool,
  99   ) -> Result<Self, Error> {
 100     use crate::schema::private_message::dsl::*;
 101     diesel::update(private_message.find(private_message_id))
 102       .set(deleted.eq(new_deleted))
 103       .get_result::<Self>(conn)
 104   }
 105
 106   pub fn update_read(
 107     conn: &PgConnection,
 108     private_message_id: i32,
 109     new_read: bool,
 110   ) -> Result<Self, Error> {
 111     use crate::schema::private_message::dsl::*;
 112     diesel::update(private_message.find(private_message_id))
 113       .set(read.eq(new_read))
 114       .get_result::<Self>(conn)
 115   }
 116
 117   pub fn mark_all_as_read(conn: &PgConnection, for_recipient_id: i32) -> Result<Vec<Self>, Error> {
 118     use crate::schema::private_message::dsl::*;
 119     diesel::update(
 120       private_message
 121         .filter(recipient_id.eq(for_recipient_id))
 122         .filter(read.eq(false)),
 123     )
 124     .set(read.eq(true))
 125     .get_results::<Self>(conn)
 126   }
 127 }
 128
 129 #[cfg(test)]
 130 mod tests {
 131   use crate::{
 132     private_message::*,
 133     tests::establish_unpooled_connection,
 134     user::*,
 135     ListingType,
 136     SortType,
 137   };
 138
 139   #[test]
 140   fn test_crud() {
 141     let conn = establish_unpooled_connection();
 142
 143     let creator_form = UserForm {
 144       name: "creator_pm".into(),
 145       preferred_username: None,
 146       password_encrypted: "nope".into(),
 147       email: None,
 148       matrix_user_id: None,
 149       avatar: None,
 150       admin: false,
 151       banned: false,
 152       updated: None,
 153       show_nsfw: false,
 154       theme: "darkly".into(),
 155       default_sort_type: SortType::Hot as i16,
 156       default_listing_type: ListingType::Subscribed as i16,
 157       lang: "browser".into(),
 158       show_avatars: true,
 159       send_notifications_to_email: false,
 160       actor_id: "changeme_6723878".into(),
 161       bio: None,
 162       local: true,
 163       private_key: None,
 164       public_key: None,
 165       last_refreshed_at: None,
 166     };
 167
 168     let inserted_creator = User_::create(&conn, &creator_form).unwrap();
 169
 170     let recipient_form = UserForm {
 171       name: "recipient_pm".into(),
 172       preferred_username: None,
 173       password_encrypted: "nope".into(),
 174       email: None,
 175       matrix_user_id: None,
 176       avatar: None,
 177       admin: false,
 178       banned: false,
 179       updated: None,
 180       show_nsfw: false,
 181       theme: "darkly".into(),
 182       default_sort_type: SortType::Hot as i16,
 183       default_listing_type: ListingType::Subscribed as i16,
 184       lang: "browser".into(),
 185       show_avatars: true,
 186       send_notifications_to_email: false,
 187       actor_id: "changeme_287263876".into(),
 188       bio: None,
 189       local: true,
 190       private_key: None,
 191       public_key: None,
 192       last_refreshed_at: None,
 193     };
 194
 195     let inserted_recipient = User_::create(&conn, &recipient_form).unwrap();
 196
 197     let private_message_form = PrivateMessageForm {
 198       content: "A test private message".into(),
 199       creator_id: inserted_creator.id,
 200       recipient_id: inserted_recipient.id,
 201       deleted: None,
 202       read: None,
 203       published: None,
 204       updated: None,
 205       ap_id: "http://fake.com".into(),
 206       local: true,
 207     };
 208
 209     let inserted_private_message = PrivateMessage::create(&conn, &private_message_form).unwrap();
 210
 211     let expected_private_message = PrivateMessage {
 212       id: inserted_private_message.id,
 213       content: "A test private message".into(),
 214       creator_id: inserted_creator.id,
 215       recipient_id: inserted_recipient.id,
 216       deleted: false,
 217       read: false,
 218       updated: None,
 219       published: inserted_private_message.published,
 220       ap_id: "http://fake.com".into(),
 221       local: true,
 222     };
 223
 224     let read_private_message = PrivateMessage::read(&conn, inserted_private_message.id).unwrap();
 225     let updated_private_message =
 226       PrivateMessage::update(&conn, inserted_private_message.id, &private_message_form).unwrap();
 227     let deleted_private_message =
 228       PrivateMessage::update_deleted(&conn, inserted_private_message.id, true).unwrap();
 229     let marked_read_private_message =
 230       PrivateMessage::update_read(&conn, inserted_private_message.id, true).unwrap();
 231     let num_deleted = PrivateMessage::delete(&conn, inserted_private_message.id).unwrap();
 232     User_::delete(&conn, inserted_creator.id).unwrap();
 233     User_::delete(&conn, inserted_recipient.id).unwrap();
 234
 235     assert_eq!(expected_private_message, read_private_message);
 236     assert_eq!(expected_private_message, updated_private_message);
 237     assert_eq!(expected_private_message, inserted_private_message);
 238     assert!(deleted_private_message.deleted);
 239     assert!(marked_read_private_message.read);
 240     assert_eq!(1, num_deleted);
 241   }
 242 }