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: &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)
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)
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)
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)
47 conn: &mut PgConnection,
48 private_message_id: PrivateMessageId,
50 ) -> Result<PrivateMessage, Error> {
51 use crate::schema::private_message::dsl::*;
53 diesel::update(private_message.find(private_message_id))
54 .set(ap_id.eq(apub_id))
55 .get_result::<Self>(conn)
58 pub fn update_content(
59 conn: &mut PgConnection,
60 private_message_id: PrivateMessageId,
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)
69 pub fn update_deleted(
70 conn: &mut PgConnection,
71 private_message_id: PrivateMessageId,
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)
81 conn: &mut PgConnection,
82 private_message_id: PrivateMessageId,
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)
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::*;
98 .filter(recipient_id.eq(for_recipient_id))
99 .filter(read.eq(false)),
102 .get_results::<Self>(conn)
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)
114 .set(private_message_form)
115 .get_result::<Self>(conn)
118 pub fn read_from_apub_id(
119 conn: &mut PgConnection,
121 ) -> Result<Option<Self>, LemmyError> {
122 use crate::schema::private_message::dsl::*;
123 let object_id: DbUrl = object_id.into();
126 .filter(ap_id.eq(object_id))
127 .first::<PrivateMessage>(conn)
134 impl DeleteableOrRemoveable for PrivateMessage {
135 fn blank_out_deleted_or_removed_info(mut self) -> Self {
136 self.content = "".into();
144 source::{person::*, private_message::*},
146 utils::establish_unpooled_connection,
148 use serial_test::serial;
153 let conn = &mut establish_unpooled_connection();
155 let creator_form = PersonForm {
156 name: "creator_pm".into(),
157 public_key: Some("pubkey".to_string()),
158 ..PersonForm::default()
161 let inserted_creator = Person::create(conn, &creator_form).unwrap();
163 let recipient_form = PersonForm {
164 name: "recipient_pm".into(),
165 public_key: Some("pubkey".to_string()),
166 ..PersonForm::default()
169 let inserted_recipient = Person::create(conn, &recipient_form).unwrap();
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()
178 let inserted_private_message = PrivateMessage::create(conn, &private_message_form).unwrap();
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,
188 published: inserted_private_message.published,
189 ap_id: inserted_private_message.ap_id.to_owned(),
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();
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);