3 newtypes::{DbUrl, PersonId, PrivateMessageId},
4 source::private_message::*,
5 traits::{Crud, DeleteableOrRemoveable},
7 use diesel::{dsl::*, result::Error, *};
8 use lemmy_utils::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)
41 private_message_id: PrivateMessageId,
43 ) -> Result<PrivateMessage, Error> {
44 use crate::schema::private_message::dsl::*;
46 diesel::update(private_message.find(private_message_id))
47 .set(ap_id.eq(apub_id))
48 .get_result::<Self>(conn)
51 pub fn update_content(
53 private_message_id: PrivateMessageId,
55 ) -> Result<PrivateMessage, Error> {
56 use crate::schema::private_message::dsl::*;
57 diesel::update(private_message.find(private_message_id))
58 .set((content.eq(new_content), updated.eq(naive_now())))
59 .get_result::<Self>(conn)
62 pub fn update_deleted(
64 private_message_id: PrivateMessageId,
66 ) -> Result<PrivateMessage, Error> {
67 use crate::schema::private_message::dsl::*;
68 diesel::update(private_message.find(private_message_id))
69 .set(deleted.eq(new_deleted))
70 .get_result::<Self>(conn)
75 private_message_id: PrivateMessageId,
77 ) -> Result<PrivateMessage, Error> {
78 use crate::schema::private_message::dsl::*;
79 diesel::update(private_message.find(private_message_id))
80 .set(read.eq(new_read))
81 .get_result::<Self>(conn)
84 pub fn mark_all_as_read(
86 for_recipient_id: PersonId,
87 ) -> Result<Vec<PrivateMessage>, Error> {
88 use crate::schema::private_message::dsl::*;
91 .filter(recipient_id.eq(for_recipient_id))
92 .filter(read.eq(false)),
95 .get_results::<Self>(conn)
100 private_message_form: &PrivateMessageForm,
101 ) -> Result<PrivateMessage, Error> {
102 use crate::schema::private_message::dsl::*;
103 insert_into(private_message)
104 .values(private_message_form)
107 .set(private_message_form)
108 .get_result::<Self>(conn)
111 pub fn read_from_apub_id(
114 ) -> Result<Option<Self>, LemmyError> {
115 use crate::schema::private_message::dsl::*;
116 let object_id: DbUrl = object_id.into();
119 .filter(ap_id.eq(object_id))
120 .first::<PrivateMessage>(conn)
127 impl DeleteableOrRemoveable for PrivateMessage {
128 fn blank_out_deleted_or_removed_info(mut self) -> Self {
129 self.content = "".into();
137 establish_unpooled_connection,
138 source::{person::*, private_message::*},
141 use serial_test::serial;
146 let conn = establish_unpooled_connection();
148 let creator_form = PersonForm {
149 name: "creator_pm".into(),
150 ..PersonForm::default()
153 let inserted_creator = Person::create(&conn, &creator_form).unwrap();
155 let recipient_form = PersonForm {
156 name: "recipient_pm".into(),
157 ..PersonForm::default()
160 let inserted_recipient = Person::create(&conn, &recipient_form).unwrap();
162 let private_message_form = PrivateMessageForm {
163 content: "A test private message".into(),
164 creator_id: inserted_creator.id,
165 recipient_id: inserted_recipient.id,
166 ..PrivateMessageForm::default()
169 let inserted_private_message = PrivateMessage::create(&conn, &private_message_form).unwrap();
171 let expected_private_message = PrivateMessage {
172 id: inserted_private_message.id,
173 content: "A test private message".into(),
174 creator_id: inserted_creator.id,
175 recipient_id: inserted_recipient.id,
179 published: inserted_private_message.published,
180 ap_id: inserted_private_message.ap_id.to_owned(),
184 let read_private_message = PrivateMessage::read(&conn, inserted_private_message.id).unwrap();
185 let updated_private_message =
186 PrivateMessage::update(&conn, inserted_private_message.id, &private_message_form).unwrap();
187 let deleted_private_message =
188 PrivateMessage::update_deleted(&conn, inserted_private_message.id, true).unwrap();
189 let marked_read_private_message =
190 PrivateMessage::update_read(&conn, inserted_private_message.id, true).unwrap();
191 Person::delete(&conn, inserted_creator.id).unwrap();
192 Person::delete(&conn, inserted_recipient.id).unwrap();
194 assert_eq!(expected_private_message, read_private_message);
195 assert_eq!(expected_private_message, updated_private_message);
196 assert_eq!(expected_private_message, inserted_private_message);
197 assert!(deleted_private_message.deleted);
198 assert!(marked_read_private_message.read);