crates/db_schema/src/impls/private_message.rs

   1 use crate::{
   2   newtypes::{DbUrl, PersonId, PrivateMessageId},
   3   source::private_message::*,
   4   traits::{Crud, DeleteableOrRemoveable},
   5   utils::naive_now,
   6 };
   7 use diesel::{dsl::*, result::Error, *};
   8 use lemmy_utils::error::LemmyError;
   9 use url::Url;
  10
  11 impl Crud for PrivateMessage {
  12   type Form = PrivateMessageForm;
  13   type IdType = PrivateMessageId;
  14   fn read(conn: &PgConnection, private_message_id: PrivateMessageId) -> Result<Self, Error> {
  15     use crate::schema::private_message::dsl::*;
  16     private_message.find(private_message_id).first::<Self>(conn)
  17   }
  18
  19   fn create(conn: &PgConnection, private_message_form: &PrivateMessageForm) -> Result<Self, Error> {
  20     use crate::schema::private_message::dsl::*;
  21     insert_into(private_message)
  22       .values(private_message_form)
  23       .get_result::<Self>(conn)
  24   }
  25
  26   fn update(
  27     conn: &PgConnection,
  28     private_message_id: PrivateMessageId,
  29     private_message_form: &PrivateMessageForm,
  30   ) -> Result<Self, Error> {
  31     use crate::schema::private_message::dsl::*;
  32     diesel::update(private_message.find(private_message_id))
  33       .set(private_message_form)
  34       .get_result::<Self>(conn)
  35   }
  36   fn delete(conn: &PgConnection, pm_id: Self::IdType) -> Result<usize, Error> {
  37     use crate::schema::private_message::dsl::*;
  38     diesel::delete(private_message.find(pm_id)).execute(conn)
  39   }
  40 }
  41
  42 impl PrivateMessage {
  43   pub fn update_ap_id(
  44     conn: &PgConnection,
  45     private_message_id: PrivateMessageId,
  46     apub_id: DbUrl,
  47   ) -> Result<PrivateMessage, Error> {
  48     use crate::schema::private_message::dsl::*;
  49
  50     diesel::update(private_message.find(private_message_id))
  51       .set(ap_id.eq(apub_id))
  52       .get_result::<Self>(conn)
  53   }
  54
  55   pub fn update_content(
  56     conn: &PgConnection,
  57     private_message_id: PrivateMessageId,
  58     new_content: &str,
  59   ) -> Result<PrivateMessage, Error> {
  60     use crate::schema::private_message::dsl::*;
  61     diesel::update(private_message.find(private_message_id))
  62       .set((content.eq(new_content), updated.eq(naive_now())))
  63       .get_result::<Self>(conn)
  64   }
  65
  66   pub fn update_deleted(
  67     conn: &PgConnection,
  68     private_message_id: PrivateMessageId,
  69     new_deleted: bool,
  70   ) -> Result<PrivateMessage, Error> {
  71     use crate::schema::private_message::dsl::*;
  72     diesel::update(private_message.find(private_message_id))
  73       .set(deleted.eq(new_deleted))
  74       .get_result::<Self>(conn)
  75   }
  76
  77   pub fn update_read(
  78     conn: &PgConnection,
  79     private_message_id: PrivateMessageId,
  80     new_read: bool,
  81   ) -> Result<PrivateMessage, Error> {
  82     use crate::schema::private_message::dsl::*;
  83     diesel::update(private_message.find(private_message_id))
  84       .set(read.eq(new_read))
  85       .get_result::<Self>(conn)
  86   }
  87
  88   pub fn mark_all_as_read(
  89     conn: &PgConnection,
  90     for_recipient_id: PersonId,
  91   ) -> Result<Vec<PrivateMessage>, Error> {
  92     use crate::schema::private_message::dsl::*;
  93     diesel::update(
  94       private_message
  95         .filter(recipient_id.eq(for_recipient_id))
  96         .filter(read.eq(false)),
  97     )
  98     .set(read.eq(true))
  99     .get_results::<Self>(conn)
 100   }
 101
 102   pub fn upsert(
 103     conn: &PgConnection,
 104     private_message_form: &PrivateMessageForm,
 105   ) -> Result<PrivateMessage, Error> {
 106     use crate::schema::private_message::dsl::*;
 107     insert_into(private_message)
 108       .values(private_message_form)
 109       .on_conflict(ap_id)
 110       .do_update()
 111       .set(private_message_form)
 112       .get_result::<Self>(conn)
 113   }
 114
 115   pub fn read_from_apub_id(
 116     conn: &PgConnection,
 117     object_id: Url,
 118   ) -> Result<Option<Self>, LemmyError> {
 119     use crate::schema::private_message::dsl::*;
 120     let object_id: DbUrl = object_id.into();
 121     Ok(
 122       private_message
 123         .filter(ap_id.eq(object_id))
 124         .first::<PrivateMessage>(conn)
 125         .ok()
 126         .map(Into::into),
 127     )
 128   }
 129 }
 130
 131 impl DeleteableOrRemoveable for PrivateMessage {
 132   fn blank_out_deleted_or_removed_info(mut self) -> Self {
 133     self.content = "".into();
 134     self
 135   }
 136 }
 137
 138 #[cfg(test)]
 139 mod tests {
 140   use crate::{
 141     source::{person::*, private_message::*},
 142     traits::Crud,
 143     utils::establish_unpooled_connection,
 144   };
 145   use serial_test::serial;
 146
 147   #[test]
 148   #[serial]
 149   fn test_crud() {
 150     let conn = establish_unpooled_connection();
 151
 152     let creator_form = PersonForm {
 153       name: "creator_pm".into(),
 154       ..PersonForm::default()
 155     };
 156
 157     let inserted_creator = Person::create(&conn, &creator_form).unwrap();
 158
 159     let recipient_form = PersonForm {
 160       name: "recipient_pm".into(),
 161       ..PersonForm::default()
 162     };
 163
 164     let inserted_recipient = Person::create(&conn, &recipient_form).unwrap();
 165
 166     let private_message_form = PrivateMessageForm {
 167       content: "A test private message".into(),
 168       creator_id: inserted_creator.id,
 169       recipient_id: inserted_recipient.id,
 170       ..PrivateMessageForm::default()
 171     };
 172
 173     let inserted_private_message = PrivateMessage::create(&conn, &private_message_form).unwrap();
 174
 175     let expected_private_message = PrivateMessage {
 176       id: inserted_private_message.id,
 177       content: "A test private message".into(),
 178       creator_id: inserted_creator.id,
 179       recipient_id: inserted_recipient.id,
 180       deleted: false,
 181       read: false,
 182       updated: None,
 183       published: inserted_private_message.published,
 184       ap_id: inserted_private_message.ap_id.to_owned(),
 185       local: true,
 186     };
 187
 188     let read_private_message = PrivateMessage::read(&conn, inserted_private_message.id).unwrap();
 189     let updated_private_message =
 190       PrivateMessage::update(&conn, inserted_private_message.id, &private_message_form).unwrap();
 191     let deleted_private_message =
 192       PrivateMessage::update_deleted(&conn, inserted_private_message.id, true).unwrap();
 193     let marked_read_private_message =
 194       PrivateMessage::update_read(&conn, inserted_private_message.id, true).unwrap();
 195     Person::delete(&conn, inserted_creator.id).unwrap();
 196     Person::delete(&conn, inserted_recipient.id).unwrap();
 197
 198     assert_eq!(expected_private_message, read_private_message);
 199     assert_eq!(expected_private_message, updated_private_message);
 200     assert_eq!(expected_private_message, inserted_private_message);
 201     assert!(deleted_private_message.deleted);
 202     assert!(marked_read_private_message.read);
 203   }
 204 }