1 use crate::{naive_now, schema::private_message, Crud};
2 use diesel::{dsl::*, result::Error, *};
4 #[derive(Queryable, Identifiable, PartialEq, Debug)]
5 #[table_name = "private_message"]
6 pub struct PrivateMessage {
13 pub published: chrono::NaiveDateTime,
14 pub updated: Option<chrono::NaiveDateTime>,
19 #[derive(Insertable, AsChangeset)]
20 #[table_name = "private_message"]
21 pub struct PrivateMessageForm {
23 pub recipient_id: i32,
25 pub deleted: Option<bool>,
26 pub read: Option<bool>,
27 pub published: Option<chrono::NaiveDateTime>,
28 pub updated: Option<chrono::NaiveDateTime>,
29 pub ap_id: Option<String>,
33 impl Crud<PrivateMessageForm> for PrivateMessage {
34 fn read(conn: &PgConnection, private_message_id: i32) -> Result<Self, Error> {
35 use crate::schema::private_message::dsl::*;
36 private_message.find(private_message_id).first::<Self>(conn)
39 fn create(conn: &PgConnection, private_message_form: &PrivateMessageForm) -> Result<Self, Error> {
40 use crate::schema::private_message::dsl::*;
41 insert_into(private_message)
42 .values(private_message_form)
43 .get_result::<Self>(conn)
48 private_message_id: i32,
49 private_message_form: &PrivateMessageForm,
50 ) -> Result<Self, Error> {
51 use crate::schema::private_message::dsl::*;
52 diesel::update(private_message.find(private_message_id))
53 .set(private_message_form)
54 .get_result::<Self>(conn)
61 private_message_id: i32,
63 ) -> Result<Self, Error> {
64 use crate::schema::private_message::dsl::*;
66 diesel::update(private_message.find(private_message_id))
67 .set(ap_id.eq(apub_id))
68 .get_result::<Self>(conn)
71 pub fn read_from_apub_id(conn: &PgConnection, object_id: &str) -> Result<Self, Error> {
72 use crate::schema::private_message::dsl::*;
74 .filter(ap_id.eq(object_id))
78 pub fn update_content(
80 private_message_id: i32,
82 ) -> Result<Self, Error> {
83 use crate::schema::private_message::dsl::*;
84 diesel::update(private_message.find(private_message_id))
85 .set((content.eq(new_content), updated.eq(naive_now())))
86 .get_result::<Self>(conn)
89 pub fn update_deleted(
91 private_message_id: i32,
93 ) -> Result<Self, Error> {
94 use crate::schema::private_message::dsl::*;
95 diesel::update(private_message.find(private_message_id))
96 .set(deleted.eq(new_deleted))
97 .get_result::<Self>(conn)
102 private_message_id: i32,
104 ) -> Result<Self, Error> {
105 use crate::schema::private_message::dsl::*;
106 diesel::update(private_message.find(private_message_id))
107 .set(read.eq(new_read))
108 .get_result::<Self>(conn)
111 pub fn mark_all_as_read(conn: &PgConnection, for_recipient_id: i32) -> Result<Vec<Self>, Error> {
112 use crate::schema::private_message::dsl::*;
115 .filter(recipient_id.eq(for_recipient_id))
116 .filter(read.eq(false)),
119 .get_results::<Self>(conn)
125 private_message_form: &PrivateMessageForm,
126 ) -> Result<Self, Error> {
127 use crate::schema::private_message::dsl::*;
128 insert_into(private_message)
129 .values(private_message_form)
132 .set(private_message_form)
133 .get_result::<Self>(conn)
141 tests::establish_unpooled_connection,
149 let conn = establish_unpooled_connection();
151 let creator_form = UserForm {
152 name: "creator_pm".into(),
153 preferred_username: None,
154 password_encrypted: "nope".into(),
156 matrix_user_id: None,
163 theme: "darkly".into(),
164 default_sort_type: SortType::Hot as i16,
165 default_listing_type: ListingType::Subscribed as i16,
166 lang: "browser".into(),
168 send_notifications_to_email: false,
174 last_refreshed_at: None,
177 let inserted_creator = User_::create(&conn, &creator_form).unwrap();
179 let recipient_form = UserForm {
180 name: "recipient_pm".into(),
181 preferred_username: None,
182 password_encrypted: "nope".into(),
184 matrix_user_id: None,
191 theme: "darkly".into(),
192 default_sort_type: SortType::Hot as i16,
193 default_listing_type: ListingType::Subscribed as i16,
194 lang: "browser".into(),
196 send_notifications_to_email: false,
202 last_refreshed_at: None,
205 let inserted_recipient = User_::create(&conn, &recipient_form).unwrap();
207 let private_message_form = PrivateMessageForm {
208 content: "A test private message".into(),
209 creator_id: inserted_creator.id,
210 recipient_id: inserted_recipient.id,
219 let inserted_private_message = PrivateMessage::create(&conn, &private_message_form).unwrap();
221 let expected_private_message = PrivateMessage {
222 id: inserted_private_message.id,
223 content: "A test private message".into(),
224 creator_id: inserted_creator.id,
225 recipient_id: inserted_recipient.id,
229 published: inserted_private_message.published,
230 ap_id: inserted_private_message.ap_id.to_owned(),
234 let read_private_message = PrivateMessage::read(&conn, inserted_private_message.id).unwrap();
235 let updated_private_message =
236 PrivateMessage::update(&conn, inserted_private_message.id, &private_message_form).unwrap();
237 let deleted_private_message =
238 PrivateMessage::update_deleted(&conn, inserted_private_message.id, true).unwrap();
239 let marked_read_private_message =
240 PrivateMessage::update_read(&conn, inserted_private_message.id, true).unwrap();
241 User_::delete(&conn, inserted_creator.id).unwrap();
242 User_::delete(&conn, inserted_recipient.id).unwrap();
244 assert_eq!(expected_private_message, read_private_message);
245 assert_eq!(expected_private_message, updated_private_message);
246 assert_eq!(expected_private_message, inserted_private_message);
247 assert!(deleted_private_message.deleted);
248 assert!(marked_read_private_message.read);