1 use crate::{ApubObject, Crud};
2 use diesel::{dsl::*, result::Error, *};
3 use lemmy_db_schema::{naive_now, source::private_message::*, Url};
5 impl Crud<PrivateMessageForm> for PrivateMessage {
6 fn read(conn: &PgConnection, private_message_id: i32) -> Result<Self, Error> {
7 use lemmy_db_schema::schema::private_message::dsl::*;
8 private_message.find(private_message_id).first::<Self>(conn)
11 fn create(conn: &PgConnection, private_message_form: &PrivateMessageForm) -> Result<Self, Error> {
12 use lemmy_db_schema::schema::private_message::dsl::*;
13 insert_into(private_message)
14 .values(private_message_form)
15 .get_result::<Self>(conn)
20 private_message_id: i32,
21 private_message_form: &PrivateMessageForm,
22 ) -> Result<Self, Error> {
23 use lemmy_db_schema::schema::private_message::dsl::*;
24 diesel::update(private_message.find(private_message_id))
25 .set(private_message_form)
26 .get_result::<Self>(conn)
30 impl ApubObject<PrivateMessageForm> for PrivateMessage {
31 fn read_from_apub_id(conn: &PgConnection, object_id: &Url) -> Result<Self, Error>
35 use lemmy_db_schema::schema::private_message::dsl::*;
37 .filter(ap_id.eq(object_id))
41 fn upsert(conn: &PgConnection, private_message_form: &PrivateMessageForm) -> Result<Self, Error> {
42 use lemmy_db_schema::schema::private_message::dsl::*;
43 insert_into(private_message)
44 .values(private_message_form)
47 .set(private_message_form)
48 .get_result::<Self>(conn)
52 pub trait PrivateMessage_ {
55 private_message_id: i32,
57 ) -> Result<PrivateMessage, Error>;
60 private_message_id: i32,
62 ) -> Result<PrivateMessage, Error>;
65 private_message_id: i32,
67 ) -> Result<PrivateMessage, Error>;
70 private_message_id: i32,
72 ) -> Result<PrivateMessage, Error>;
75 for_recipient_id: i32,
76 ) -> Result<Vec<PrivateMessage>, Error>;
79 impl PrivateMessage_ for PrivateMessage {
82 private_message_id: i32,
84 ) -> Result<PrivateMessage, Error> {
85 use lemmy_db_schema::schema::private_message::dsl::*;
87 diesel::update(private_message.find(private_message_id))
88 .set(ap_id.eq(apub_id))
89 .get_result::<Self>(conn)
94 private_message_id: i32,
96 ) -> Result<PrivateMessage, Error> {
97 use lemmy_db_schema::schema::private_message::dsl::*;
98 diesel::update(private_message.find(private_message_id))
99 .set((content.eq(new_content), updated.eq(naive_now())))
100 .get_result::<Self>(conn)
105 private_message_id: i32,
107 ) -> Result<PrivateMessage, Error> {
108 use lemmy_db_schema::schema::private_message::dsl::*;
109 diesel::update(private_message.find(private_message_id))
110 .set(deleted.eq(new_deleted))
111 .get_result::<Self>(conn)
116 private_message_id: i32,
118 ) -> Result<PrivateMessage, Error> {
119 use lemmy_db_schema::schema::private_message::dsl::*;
120 diesel::update(private_message.find(private_message_id))
121 .set(read.eq(new_read))
122 .get_result::<Self>(conn)
127 for_recipient_id: i32,
128 ) -> Result<Vec<PrivateMessage>, Error> {
129 use lemmy_db_schema::schema::private_message::dsl::*;
132 .filter(recipient_id.eq(for_recipient_id))
133 .filter(read.eq(false)),
136 .get_results::<Self>(conn)
143 establish_unpooled_connection,
144 source::private_message::PrivateMessage_,
149 use lemmy_db_schema::source::{private_message::*, person::*};
153 let conn = establish_unpooled_connection();
155 let creator_form = PersonForm {
156 name: "creator_pm".into(),
157 preferred_username: None,
169 last_refreshed_at: None,
171 shared_inbox_url: None,
174 let inserted_creator = Person::create(&conn, &creator_form).unwrap();
176 let recipient_form = PersonForm {
177 name: "recipient_pm".into(),
178 preferred_username: None,
190 last_refreshed_at: None,
192 shared_inbox_url: None,
195 let inserted_recipient = Person::create(&conn, &recipient_form).unwrap();
197 let private_message_form = PrivateMessageForm {
198 content: "A test private message".into(),
199 creator_id: inserted_creator.id,
200 recipient_id: inserted_recipient.id,
209 let inserted_private_message = PrivateMessage::create(&conn, &private_message_form).unwrap();
211 let expected_private_message = PrivateMessage {
212 id: inserted_private_message.id,
213 content: "A test private message".into(),
214 creator_id: inserted_creator.id,
215 recipient_id: inserted_recipient.id,
219 published: inserted_private_message.published,
220 ap_id: inserted_private_message.ap_id.to_owned(),
224 let read_private_message = PrivateMessage::read(&conn, inserted_private_message.id).unwrap();
225 let updated_private_message =
226 PrivateMessage::update(&conn, inserted_private_message.id, &private_message_form).unwrap();
227 let deleted_private_message =
228 PrivateMessage::update_deleted(&conn, inserted_private_message.id, true).unwrap();
229 let marked_read_private_message =
230 PrivateMessage::update_read(&conn, inserted_private_message.id, true).unwrap();
231 Person::delete(&conn, inserted_creator.id).unwrap();
232 Person::delete(&conn, inserted_recipient.id).unwrap();
234 assert_eq!(expected_private_message, read_private_message);
235 assert_eq!(expected_private_message, updated_private_message);
236 assert_eq!(expected_private_message, inserted_private_message);
237 assert!(deleted_private_message.deleted);
238 assert!(marked_read_private_message.read);