X-Git-Url: http://these/git/?a=blobdiff_plain;f=crates%2Fdb_views%2Fsrc%2Fprivate_message_report_view.rs;h=f1dfa3f48b06d9dcb2edc0e8dff1311e23daad71;hb=c8063f3267cf2b3622f1fdc69128c6b55feefbbc;hp=c7b2f590884648fd9a66acbdd34e0944e42f2463;hpb=004efd5d94da0eee2a51f8c88a441c0c4afe3871;p=lemmy.git diff --git a/crates/db_views/src/private_message_report_view.rs b/crates/db_views/src/private_message_report_view.rs index c7b2f590..f1dfa3f4 100644 --- a/crates/db_views/src/private_message_report_view.rs +++ b/crates/db_views/src/private_message_report_view.rs @@ -1,64 +1,100 @@ use crate::structs::PrivateMessageReportView; -use diesel::{result::Error, *}; +use diesel::{ + pg::Pg, + result::Error, + ExpressionMethods, + JoinOnDsl, + NullableExpressionMethods, + QueryDsl, +}; +use diesel_async::RunQueryDsl; use lemmy_db_schema::{ + aliases, newtypes::PrivateMessageReportId, - schema::{person, person_alias_1, person_alias_2, private_message, private_message_report}, + schema::{person, private_message, private_message_report}, source::{ - person::{Person, PersonAlias1, PersonAlias2, PersonSafe, PersonSafeAlias1, PersonSafeAlias2}, + person::Person, private_message::PrivateMessage, private_message_report::PrivateMessageReport, }, - traits::{ToSafe, ViewToVec}, - utils::limit_and_offset, + traits::JoinView, + utils::{get_conn, limit_and_offset, DbConn, DbPool, ListFn, Queries, ReadFn}, }; -use typed_builder::TypedBuilder; type PrivateMessageReportViewTuple = ( PrivateMessageReport, PrivateMessage, - PersonSafe, - PersonSafeAlias1, - Option, + Person, + Person, + Option, ); -impl PrivateMessageReportView { - /// returns the PrivateMessageReportView for the provided report_id - /// - /// * `report_id` - the report id to obtain - pub fn read(conn: &PgConnection, report_id: PrivateMessageReportId) -> Result { - let (private_message_report, private_message, private_message_creator, creator, resolver) = - private_message_report::table - .find(report_id) +fn queries<'a>() -> Queries< + impl ReadFn<'a, PrivateMessageReportView, PrivateMessageReportId>, + impl ListFn<'a, PrivateMessageReportView, PrivateMessageReportQuery>, +> { + let all_joins = + |query: private_message_report::BoxedQuery<'a, Pg>| { + query .inner_join(private_message::table) .inner_join(person::table.on(private_message::creator_id.eq(person::id))) .inner_join( - person_alias_1::table.on(private_message_report::creator_id.eq(person_alias_1::id)), - ) - .left_join( - person_alias_2::table - .on(private_message_report::resolver_id.eq(person_alias_2::id.nullable())), + aliases::person1 + .on(private_message_report::creator_id.eq(aliases::person1.field(person::id))), ) + .left_join(aliases::person2.on( + private_message_report::resolver_id.eq(aliases::person2.field(person::id).nullable()), + )) .select(( private_message_report::all_columns, private_message::all_columns, - Person::safe_columns_tuple(), - PersonAlias1::safe_columns_tuple(), - PersonAlias2::safe_columns_tuple().nullable(), + person::all_columns, + aliases::person1.fields(person::all_columns), + aliases::person2.fields(person::all_columns).nullable(), )) - .first::(conn)?; - - Ok(Self { - private_message_report, - private_message, - private_message_creator, - creator, - resolver, - }) + }; + + let read = move |mut conn: DbConn<'a>, report_id: PrivateMessageReportId| async move { + all_joins(private_message_report::table.find(report_id).into_boxed()) + .first::(&mut conn) + .await + }; + + let list = move |mut conn: DbConn<'a>, options: PrivateMessageReportQuery| async move { + let mut query = all_joins(private_message_report::table.into_boxed()); + + if options.unresolved_only { + query = query.filter(private_message_report::resolved.eq(false)); + } + + let (limit, offset) = limit_and_offset(options.page, options.limit)?; + + query + .order_by(private_message::published.desc()) + .limit(limit) + .offset(offset) + .load::(&mut conn) + .await + }; + + Queries::new(read, list) +} + +impl PrivateMessageReportView { + /// returns the PrivateMessageReportView for the provided report_id + /// + /// * `report_id` - the report id to obtain + pub async fn read( + pool: &mut DbPool<'_>, + report_id: PrivateMessageReportId, + ) -> Result { + queries().read(pool, report_id).await } /// Returns the current unresolved post report count for the communities you mod - pub fn get_report_count(conn: &PgConnection) -> Result { - use diesel::dsl::*; + pub async fn get_report_count(pool: &mut DbPool<'_>) -> Result { + use diesel::dsl::count; + let conn = &mut get_conn(pool).await?; private_message_report::table .inner_join(private_message::table) @@ -66,114 +102,85 @@ impl PrivateMessageReportView { .into_boxed() .select(count(private_message_report::id)) .first::(conn) + .await } } -#[derive(TypedBuilder)] -#[builder(field_defaults(default))] -pub struct PrivateMessageReportQuery<'a> { - #[builder(!default)] - conn: &'a PgConnection, - page: Option, - limit: Option, - unresolved_only: Option, +#[derive(Default)] +pub struct PrivateMessageReportQuery { + pub page: Option, + pub limit: Option, + pub unresolved_only: bool, } -impl<'a> PrivateMessageReportQuery<'a> { - pub fn list(self) -> Result, Error> { - 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::table.on(private_message_report::creator_id.eq(person_alias_1::id)), - ) - .left_join( - person_alias_2::table - .on(private_message_report::resolver_id.eq(person_alias_2::id.nullable())), - ) - .select(( - private_message_report::all_columns, - private_message::all_columns, - Person::safe_columns_tuple(), - PersonAlias1::safe_columns_tuple(), - PersonAlias2::safe_columns_tuple().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::(self.conn)?; - - Ok(PrivateMessageReportView::from_tuple_to_vec(res)) +impl PrivateMessageReportQuery { + pub async fn list(self, pool: &mut DbPool<'_>) -> Result, Error> { + queries().list(pool, self).await } } -impl ViewToVec for PrivateMessageReportView { - type DbTuple = PrivateMessageReportViewTuple; - fn from_tuple_to_vec(items: Vec) -> Vec { - items - .into_iter() - .map(|a| Self { - private_message_report: a.0, - private_message: a.1, - private_message_creator: a.2, - creator: a.3, - resolver: a.4, - }) - .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 { + #![allow(clippy::unwrap_used)] + #![allow(clippy::indexing_slicing)] + use crate::private_message_report_view::PrivateMessageReportQuery; use lemmy_db_schema::{ source::{ - person::{Person, PersonForm}, - private_message::{PrivateMessage, PrivateMessageForm}, + instance::Instance, + person::{Person, PersonInsertForm}, + private_message::{PrivateMessage, PrivateMessageInsertForm}, private_message_report::{PrivateMessageReport, PrivateMessageReportForm}, }, traits::{Crud, Reportable}, - utils::establish_unpooled_connection, + utils::build_db_pool_for_tests, }; use serial_test::serial; - #[test] + #[tokio::test] #[serial] - fn test_crud() { - let conn = establish_unpooled_connection(); + async fn test_crud() { + let pool = &build_db_pool_for_tests().await; + let pool = &mut pool.into(); - let new_person_1 = PersonForm { - name: "timmy_mrv".into(), - public_key: Some("pubkey".to_string()), - ..PersonForm::default() - }; - let inserted_timmy = Person::create(&conn, &new_person_1).unwrap(); + let inserted_instance = Instance::read_or_create(pool, "my_domain.tld".to_string()) + .await + .unwrap(); - let new_person_2 = PersonForm { - name: "jessica_mrv".into(), - public_key: Some("pubkey".to_string()), - ..PersonForm::default() - }; - let inserted_jessica = Person::create(&conn, &new_person_2).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 = PrivateMessageForm { - creator_id: inserted_timmy.id, - recipient_id: inserted_jessica.id, - content: "something offensive".to_string(), - ..Default::default() - }; - let pm = PrivateMessage::create(&conn, &pm_form).unwrap(); + 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 { @@ -182,12 +189,13 @@ mod tests { private_message_id: pm.id, reason: "its offensive".to_string(), }; - let pm_report = PrivateMessageReport::report(&conn, &pm_report_form).unwrap(); + let pm_report = PrivateMessageReport::report(pool, &pm_report_form) + .await + .unwrap(); - let reports = PrivateMessageReportQuery::builder() - .conn(&conn) - .build() - .list() + let reports = PrivateMessageReportQuery::default() + .list(pool) + .await .unwrap(); assert_eq!(1, reports.len()); assert!(!reports[0].private_message_report.resolved); @@ -196,22 +204,25 @@ mod tests { assert_eq!(pm_report.reason, reports[0].private_message_report.reason); assert_eq!(pm.content, reports[0].private_message.content); - let new_person_3 = PersonForm { - name: "admin_mrv".into(), - public_key: Some("pubkey".to_string()), - ..PersonForm::default() - }; - let inserted_admin = Person::create(&conn, &new_person_3).unwrap(); + 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(&conn, pm_report.id, inserted_admin.id).unwrap(); - - let reports = PrivateMessageReportQuery::builder() - .conn(&conn) - .unresolved_only(Some(false)) - .build() - .list() + PrivateMessageReport::resolve(pool, pm_report.id, inserted_admin.id) + .await .unwrap(); + + let reports = PrivateMessageReportQuery { + unresolved_only: (false), + ..Default::default() + } + .list(pool) + .await + .unwrap(); assert_eq!(1, reports.len()); assert!(reports[0].private_message_report.resolved); assert!(reports[0].resolver.is_some()); @@ -219,5 +230,7 @@ mod tests { inserted_admin.name, reports[0].resolver.as_ref().unwrap().name ); + + Instance::delete(pool, inserted_instance.id).await.unwrap(); } }