1 use crate::structs::PrivateMessageReportView;
2 use diesel::{result::Error, *};
4 newtypes::PrivateMessageReportId,
5 schema::{person, private_message, private_message_report},
7 person::{Person, PersonSafe},
8 private_message::PrivateMessage,
9 private_message_report::PrivateMessageReport,
11 traits::{ToSafe, ViewToVec},
12 utils::limit_and_offset,
14 use typed_builder::TypedBuilder;
16 type PrivateMessageReportViewTuple = (
24 impl PrivateMessageReportView {
25 /// returns the PrivateMessageReportView for the provided report_id
27 /// * `report_id` - the report id to obtain
28 pub fn read(conn: &mut PgConnection, report_id: PrivateMessageReportId) -> Result<Self, Error> {
29 let (person_alias_1, person_alias_2) = diesel::alias!(person as person1, person as person2);
31 let (private_message_report, private_message, private_message_creator, creator, resolver) =
32 private_message_report::table
34 .inner_join(private_message::table)
35 .inner_join(person::table.on(private_message::creator_id.eq(person::id)))
38 .on(private_message_report::creator_id.eq(person_alias_1.field(person::id))),
42 private_message_report::resolver_id.eq(person_alias_2.field(person::id).nullable()),
46 private_message_report::all_columns,
47 private_message::all_columns,
48 Person::safe_columns_tuple(),
49 person_alias_1.fields(Person::safe_columns_tuple()),
51 .fields(Person::safe_columns_tuple())
54 .first::<PrivateMessageReportViewTuple>(conn)?;
57 private_message_report,
59 private_message_creator,
65 /// Returns the current unresolved post report count for the communities you mod
66 pub fn get_report_count(conn: &mut PgConnection) -> Result<i64, Error> {
69 private_message_report::table
70 .inner_join(private_message::table)
71 .filter(private_message_report::resolved.eq(false))
73 .select(count(private_message_report::id))
78 #[derive(TypedBuilder)]
79 #[builder(field_defaults(default))]
80 pub struct PrivateMessageReportQuery<'a> {
82 conn: &'a mut PgConnection,
85 unresolved_only: Option<bool>,
88 impl<'a> PrivateMessageReportQuery<'a> {
89 pub fn list(self) -> Result<Vec<PrivateMessageReportView>, Error> {
90 let (person_alias_1, person_alias_2) = diesel::alias!(person as person1, person as person2);
92 let mut query = private_message_report::table
93 .inner_join(private_message::table)
94 .inner_join(person::table.on(private_message::creator_id.eq(person::id)))
96 person_alias_1.on(private_message_report::creator_id.eq(person_alias_1.field(person::id))),
100 .on(private_message_report::resolver_id.eq(person_alias_2.field(person::id).nullable())),
103 private_message_report::all_columns,
104 private_message::all_columns,
105 Person::safe_columns_tuple(),
106 person_alias_1.fields(Person::safe_columns_tuple()),
108 .fields(Person::safe_columns_tuple())
113 if self.unresolved_only.unwrap_or(true) {
114 query = query.filter(private_message_report::resolved.eq(false));
117 let (limit, offset) = limit_and_offset(self.page, self.limit)?;
120 .order_by(private_message::published.desc())
124 let res = query.load::<PrivateMessageReportViewTuple>(self.conn)?;
126 Ok(PrivateMessageReportView::from_tuple_to_vec(res))
130 impl ViewToVec for PrivateMessageReportView {
131 type DbTuple = PrivateMessageReportViewTuple;
132 fn from_tuple_to_vec(items: Vec<Self::DbTuple>) -> Vec<Self> {
136 private_message_report: a.0,
137 private_message: a.1,
138 private_message_creator: a.2,
142 .collect::<Vec<Self>>()
148 use crate::private_message_report_view::PrivateMessageReportQuery;
149 use lemmy_db_schema::{
151 person::{Person, PersonForm},
152 private_message::{PrivateMessage, PrivateMessageForm},
153 private_message_report::{PrivateMessageReport, PrivateMessageReportForm},
155 traits::{Crud, Reportable},
156 utils::establish_unpooled_connection,
158 use serial_test::serial;
163 let conn = &mut establish_unpooled_connection();
165 let new_person_1 = PersonForm {
166 name: "timmy_mrv".into(),
167 public_key: Some("pubkey".to_string()),
168 ..PersonForm::default()
170 let inserted_timmy = Person::create(conn, &new_person_1).unwrap();
172 let new_person_2 = PersonForm {
173 name: "jessica_mrv".into(),
174 public_key: Some("pubkey".to_string()),
175 ..PersonForm::default()
177 let inserted_jessica = Person::create(conn, &new_person_2).unwrap();
179 // timmy sends private message to jessica
180 let pm_form = PrivateMessageForm {
181 creator_id: inserted_timmy.id,
182 recipient_id: inserted_jessica.id,
183 content: "something offensive".to_string(),
186 let pm = PrivateMessage::create(conn, &pm_form).unwrap();
188 // jessica reports private message
189 let pm_report_form = PrivateMessageReportForm {
190 creator_id: inserted_jessica.id,
191 original_pm_text: pm.content.clone(),
192 private_message_id: pm.id,
193 reason: "its offensive".to_string(),
195 let pm_report = PrivateMessageReport::report(conn, &pm_report_form).unwrap();
197 let reports = PrivateMessageReportQuery::builder()
202 assert_eq!(1, reports.len());
203 assert!(!reports[0].private_message_report.resolved);
204 assert_eq!(inserted_timmy.name, reports[0].private_message_creator.name);
205 assert_eq!(inserted_jessica.name, reports[0].creator.name);
206 assert_eq!(pm_report.reason, reports[0].private_message_report.reason);
207 assert_eq!(pm.content, reports[0].private_message.content);
209 let new_person_3 = PersonForm {
210 name: "admin_mrv".into(),
211 public_key: Some("pubkey".to_string()),
212 ..PersonForm::default()
214 let inserted_admin = Person::create(conn, &new_person_3).unwrap();
216 // admin resolves the report (after taking appropriate action)
217 PrivateMessageReport::resolve(conn, pm_report.id, inserted_admin.id).unwrap();
219 let reports = PrivateMessageReportQuery::builder()
221 .unresolved_only(Some(false))
225 assert_eq!(1, reports.len());
226 assert!(reports[0].private_message_report.resolved);
227 assert!(reports[0].resolver.is_some());
230 reports[0].resolver.as_ref().unwrap().name