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