use crate::structs::PrivateMessageReportView; use diesel::{result::Error, ExpressionMethods, JoinOnDsl, NullableExpressionMethods, QueryDsl}; use diesel_async::RunQueryDsl; use lemmy_db_schema::{ newtypes::PrivateMessageReportId, schema::{person, private_message, private_message_report}, source::{ person::Person, private_message::PrivateMessage, private_message_report::PrivateMessageReport, }, traits::JoinView, utils::{get_conn, limit_and_offset, DbPool}, }; use typed_builder::TypedBuilder; type PrivateMessageReportViewTuple = ( PrivateMessageReport, PrivateMessage, Person, Person, Option, ); impl PrivateMessageReportView { /// returns the PrivateMessageReportView for the provided report_id /// /// * `report_id` - the report id to obtain pub async fn read(pool: &DbPool, report_id: PrivateMessageReportId) -> Result { let conn = &mut get_conn(pool).await?; let (person_alias_1, person_alias_2) = diesel::alias!(person as person1, person as person2); let (private_message_report, private_message, private_message_creator, creator, resolver) = private_message_report::table .find(report_id) .inner_join(private_message::table) .inner_join(person::table.on(private_message::creator_id.eq(person::id))) .inner_join( person_alias_1 .on(private_message_report::creator_id.eq(person_alias_1.field(person::id))), ) .left_join( person_alias_2.on( private_message_report::resolver_id.eq(person_alias_2.field(person::id).nullable()), ), ) .select(( private_message_report::all_columns, private_message::all_columns, person::all_columns, person_alias_1.fields(person::all_columns), person_alias_2.fields(person::all_columns).nullable(), )) .first::(conn) .await?; Ok(Self { private_message_report, private_message, private_message_creator, creator, resolver, }) } /// Returns the current unresolved post report count for the communities you mod pub async fn get_report_count(pool: &DbPool) -> Result { use diesel::dsl::count; let conn = &mut get_conn(pool).await?; private_message_report::table .inner_join(private_message::table) .filter(private_message_report::resolved.eq(false)) .into_boxed() .select(count(private_message_report::id)) .first::(conn) .await } } #[derive(TypedBuilder)] #[builder(field_defaults(default))] pub struct PrivateMessageReportQuery<'a> { #[builder(!default)] pool: &'a DbPool, page: Option, limit: Option, unresolved_only: Option, } impl<'a> PrivateMessageReportQuery<'a> { pub async fn list(self) -> Result, Error> { let conn = &mut get_conn(self.pool).await?; let (person_alias_1, person_alias_2) = diesel::alias!(person as person1, person as person2); let mut query = private_message_report::table .inner_join(private_message::table) .inner_join(person::table.on(private_message::creator_id.eq(person::id))) .inner_join( person_alias_1.on(private_message_report::creator_id.eq(person_alias_1.field(person::id))), ) .left_join( person_alias_2 .on(private_message_report::resolver_id.eq(person_alias_2.field(person::id).nullable())), ) .select(( private_message_report::all_columns, private_message::all_columns, person::all_columns, person_alias_1.fields(person::all_columns), person_alias_2.fields(person::all_columns).nullable(), )) .into_boxed(); if self.unresolved_only.unwrap_or(true) { query = query.filter(private_message_report::resolved.eq(false)); } let (limit, offset) = limit_and_offset(self.page, self.limit)?; query = query .order_by(private_message::published.desc()) .limit(limit) .offset(offset); let res = query.load::(conn).await?; Ok( res .into_iter() .map(PrivateMessageReportView::from_tuple) .collect(), ) } } impl JoinView for PrivateMessageReportView { type JoinTuple = PrivateMessageReportViewTuple; fn from_tuple(a: Self::JoinTuple) -> Self { Self { private_message_report: a.0, private_message: a.1, private_message_creator: a.2, creator: a.3, resolver: a.4, } } } #[cfg(test)] mod tests { use crate::private_message_report_view::PrivateMessageReportQuery; use lemmy_db_schema::{ source::{ instance::Instance, person::{Person, PersonInsertForm}, private_message::{PrivateMessage, PrivateMessageInsertForm}, private_message_report::{PrivateMessageReport, PrivateMessageReportForm}, }, traits::{Crud, Reportable}, utils::build_db_pool_for_tests, }; use serial_test::serial; #[tokio::test] #[serial] async fn test_crud() { let pool = &build_db_pool_for_tests().await; let inserted_instance = Instance::read_or_create(pool, "my_domain.tld".to_string()) .await .unwrap(); let new_person_1 = PersonInsertForm::builder() .name("timmy_mrv".into()) .public_key("pubkey".to_string()) .instance_id(inserted_instance.id) .build(); let inserted_timmy = Person::create(pool, &new_person_1).await.unwrap(); let new_person_2 = PersonInsertForm::builder() .name("jessica_mrv".into()) .public_key("pubkey".to_string()) .instance_id(inserted_instance.id) .build(); let inserted_jessica = Person::create(pool, &new_person_2).await.unwrap(); // timmy sends private message to jessica let pm_form = PrivateMessageInsertForm::builder() .creator_id(inserted_timmy.id) .recipient_id(inserted_jessica.id) .content("something offensive".to_string()) .build(); let pm = PrivateMessage::create(pool, &pm_form).await.unwrap(); // jessica reports private message let pm_report_form = PrivateMessageReportForm { creator_id: inserted_jessica.id, original_pm_text: pm.content.clone(), private_message_id: pm.id, reason: "its offensive".to_string(), }; let pm_report = PrivateMessageReport::report(pool, &pm_report_form) .await .unwrap(); let reports = PrivateMessageReportQuery::builder() .pool(pool) .build() .list() .await .unwrap(); assert_eq!(1, reports.len()); assert!(!reports[0].private_message_report.resolved); assert_eq!(inserted_timmy.name, reports[0].private_message_creator.name); assert_eq!(inserted_jessica.name, reports[0].creator.name); assert_eq!(pm_report.reason, reports[0].private_message_report.reason); assert_eq!(pm.content, reports[0].private_message.content); let new_person_3 = PersonInsertForm::builder() .name("admin_mrv".into()) .public_key("pubkey".to_string()) .instance_id(inserted_instance.id) .build(); let inserted_admin = Person::create(pool, &new_person_3).await.unwrap(); // admin resolves the report (after taking appropriate action) PrivateMessageReport::resolve(pool, pm_report.id, inserted_admin.id) .await .unwrap(); let reports = PrivateMessageReportQuery::builder() .pool(pool) .unresolved_only(Some(false)) .build() .list() .await .unwrap(); assert_eq!(1, reports.len()); assert!(reports[0].private_message_report.resolved); assert!(reports[0].resolver.is_some()); assert_eq!( inserted_admin.name, reports[0].resolver.as_ref().unwrap().name ); Instance::delete(pool, inserted_instance.id).await.unwrap(); } }