server/lemmy_db/src/private_message.rs

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