2 newtypes::{DbUrl, PersonId, PrivateMessageId},
3 schema::private_message::dsl::*,
4 source::private_message::*,
5 traits::{Crud, DeleteableOrRemoveable},
6 utils::{get_conn, DbPool},
8 use diesel::{dsl::*, result::Error, *};
9 use diesel_async::RunQueryDsl;
10 use lemmy_utils::error::LemmyError;
14 impl Crud for PrivateMessage {
15 type InsertForm = PrivateMessageInsertForm;
16 type UpdateForm = PrivateMessageUpdateForm;
17 type IdType = PrivateMessageId;
18 async fn read(pool: &DbPool, private_message_id: PrivateMessageId) -> Result<Self, Error> {
19 let conn = &mut get_conn(pool).await?;
21 .find(private_message_id)
26 async fn create(pool: &DbPool, form: &Self::InsertForm) -> Result<Self, Error> {
27 let conn = &mut get_conn(pool).await?;
28 insert_into(private_message)
33 .get_result::<Self>(conn)
39 private_message_id: PrivateMessageId,
40 form: &Self::UpdateForm,
41 ) -> Result<Self, Error> {
42 let conn = &mut get_conn(pool).await?;
43 diesel::update(private_message.find(private_message_id))
45 .get_result::<Self>(conn)
48 async fn delete(pool: &DbPool, pm_id: Self::IdType) -> Result<usize, Error> {
49 let conn = &mut get_conn(pool).await?;
50 diesel::delete(private_message.find(pm_id))
57 pub async fn mark_all_as_read(
59 for_recipient_id: PersonId,
60 ) -> Result<Vec<PrivateMessage>, Error> {
61 let conn = &mut get_conn(pool).await?;
64 .filter(recipient_id.eq(for_recipient_id))
65 .filter(read.eq(false)),
68 .get_results::<Self>(conn)
72 pub async fn read_from_apub_id(
75 ) -> Result<Option<Self>, LemmyError> {
76 let conn = &mut get_conn(pool).await?;
77 let object_id: DbUrl = object_id.into();
80 .filter(ap_id.eq(object_id))
81 .first::<PrivateMessage>(conn)
89 impl DeleteableOrRemoveable for PrivateMessage {
90 fn blank_out_deleted_or_removed_info(mut self) -> Self {
91 self.content = "".into();
99 source::{instance::Instance, person::*, private_message::*},
101 utils::build_db_pool_for_tests,
103 use serial_test::serial;
107 async fn test_crud() {
108 let pool = &build_db_pool_for_tests().await;
110 let inserted_instance = Instance::create(pool, "my_domain.tld").await.unwrap();
112 let creator_form = PersonInsertForm::builder()
113 .name("creator_pm".into())
114 .public_key("pubkey".to_string())
115 .instance_id(inserted_instance.id)
118 let inserted_creator = Person::create(pool, &creator_form).await.unwrap();
120 let recipient_form = PersonInsertForm::builder()
121 .name("recipient_pm".into())
122 .public_key("pubkey".to_string())
123 .instance_id(inserted_instance.id)
126 let inserted_recipient = Person::create(pool, &recipient_form).await.unwrap();
128 let private_message_form = PrivateMessageInsertForm::builder()
129 .content("A test private message".into())
130 .creator_id(inserted_creator.id)
131 .recipient_id(inserted_recipient.id)
134 let inserted_private_message = PrivateMessage::create(pool, &private_message_form)
138 let expected_private_message = PrivateMessage {
139 id: inserted_private_message.id,
140 content: "A test private message".into(),
141 creator_id: inserted_creator.id,
142 recipient_id: inserted_recipient.id,
146 published: inserted_private_message.published,
147 ap_id: inserted_private_message.ap_id.to_owned(),
151 let read_private_message = PrivateMessage::read(pool, inserted_private_message.id)
155 let private_message_update_form = PrivateMessageUpdateForm::builder()
156 .content(Some("A test private message".into()))
158 let updated_private_message = PrivateMessage::update(
160 inserted_private_message.id,
161 &private_message_update_form,
166 let deleted_private_message = PrivateMessage::update(
168 inserted_private_message.id,
169 &PrivateMessageUpdateForm::builder()
175 let marked_read_private_message = PrivateMessage::update(
177 inserted_private_message.id,
178 &PrivateMessageUpdateForm::builder().read(Some(true)).build(),
182 Person::delete(pool, inserted_creator.id).await.unwrap();
183 Person::delete(pool, inserted_recipient.id).await.unwrap();
184 Instance::delete(pool, inserted_instance.id).await.unwrap();
186 assert_eq!(expected_private_message, read_private_message);
187 assert_eq!(expected_private_message, updated_private_message);
188 assert_eq!(expected_private_message, inserted_private_message);
189 assert!(deleted_private_message.deleted);
190 assert!(marked_read_private_message.read);