2 newtypes::{DbUrl, PersonId, PrivateMessageId},
3 source::private_message::*,
4 traits::{Crud, DeleteableOrRemoveable},
7 use diesel::{dsl::*, result::Error, *};
8 use lemmy_utils::error::LemmyError;
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)
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)
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)
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)
45 private_message_id: PrivateMessageId,
47 ) -> Result<PrivateMessage, Error> {
48 use crate::schema::private_message::dsl::*;
50 diesel::update(private_message.find(private_message_id))
51 .set(ap_id.eq(apub_id))
52 .get_result::<Self>(conn)
55 pub fn update_content(
57 private_message_id: PrivateMessageId,
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)
66 pub fn update_deleted(
68 private_message_id: PrivateMessageId,
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)
79 private_message_id: PrivateMessageId,
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)
88 pub fn mark_all_as_read(
90 for_recipient_id: PersonId,
91 ) -> Result<Vec<PrivateMessage>, Error> {
92 use crate::schema::private_message::dsl::*;
95 .filter(recipient_id.eq(for_recipient_id))
96 .filter(read.eq(false)),
99 .get_results::<Self>(conn)
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)
111 .set(private_message_form)
112 .get_result::<Self>(conn)
115 pub fn read_from_apub_id(
118 ) -> Result<Option<Self>, LemmyError> {
119 use crate::schema::private_message::dsl::*;
120 let object_id: DbUrl = object_id.into();
123 .filter(ap_id.eq(object_id))
124 .first::<PrivateMessage>(conn)
131 impl DeleteableOrRemoveable for PrivateMessage {
132 fn blank_out_deleted_or_removed_info(mut self) -> Self {
133 self.content = "".into();
141 source::{person::*, private_message::*},
143 utils::establish_unpooled_connection,
145 use serial_test::serial;
150 let conn = establish_unpooled_connection();
152 let creator_form = PersonForm {
153 name: "creator_pm".into(),
154 public_key: Some("pubkey".to_string()),
155 ..PersonForm::default()
158 let inserted_creator = Person::create(&conn, &creator_form).unwrap();
160 let recipient_form = PersonForm {
161 name: "recipient_pm".into(),
162 public_key: Some("pubkey".to_string()),
163 ..PersonForm::default()
166 let inserted_recipient = Person::create(&conn, &recipient_form).unwrap();
168 let private_message_form = PrivateMessageForm {
169 content: "A test private message".into(),
170 creator_id: inserted_creator.id,
171 recipient_id: inserted_recipient.id,
172 ..PrivateMessageForm::default()
175 let inserted_private_message = PrivateMessage::create(&conn, &private_message_form).unwrap();
177 let expected_private_message = PrivateMessage {
178 id: inserted_private_message.id,
179 content: "A test private message".into(),
180 creator_id: inserted_creator.id,
181 recipient_id: inserted_recipient.id,
185 published: inserted_private_message.published,
186 ap_id: inserted_private_message.ap_id.to_owned(),
190 let read_private_message = PrivateMessage::read(&conn, inserted_private_message.id).unwrap();
191 let updated_private_message =
192 PrivateMessage::update(&conn, inserted_private_message.id, &private_message_form).unwrap();
193 let deleted_private_message =
194 PrivateMessage::update_deleted(&conn, inserted_private_message.id, true).unwrap();
195 let marked_read_private_message =
196 PrivateMessage::update_read(&conn, inserted_private_message.id, true).unwrap();
197 Person::delete(&conn, inserted_creator.id).unwrap();
198 Person::delete(&conn, inserted_recipient.id).unwrap();
200 assert_eq!(expected_private_message, read_private_message);
201 assert_eq!(expected_private_message, updated_private_message);
202 assert_eq!(expected_private_message, inserted_private_message);
203 assert!(deleted_private_message.deleted);
204 assert!(marked_read_private_message.read);