use crate::structs::PrivateMessageReportView;
-use diesel::{result::Error, ExpressionMethods, JoinOnDsl, NullableExpressionMethods, QueryDsl};
+use diesel::{
+ pg::Pg,
+ result::Error,
+ ExpressionMethods,
+ JoinOnDsl,
+ NullableExpressionMethods,
+ QueryDsl,
+};
use diesel_async::RunQueryDsl;
use lemmy_db_schema::{
+ aliases,
newtypes::PrivateMessageReportId,
schema::{person, private_message, private_message_report},
source::{
- person::{Person, PersonSafe},
+ person::Person,
private_message::PrivateMessage,
private_message_report::PrivateMessageReport,
},
- traits::{ToSafe, ViewToVec},
- utils::{get_conn, limit_and_offset, DbPool},
+ traits::JoinView,
+ utils::{get_conn, limit_and_offset, DbConn, DbPool, ListFn, Queries, ReadFn},
};
-use typed_builder::TypedBuilder;
type PrivateMessageReportViewTuple = (
PrivateMessageReport,
PrivateMessage,
- PersonSafe,
- PersonSafe,
- Option<PersonSafe>,
+ Person,
+ Person,
+ Option<Person>,
);
-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<Self, Error> {
- 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)
+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
- .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()),
- ),
+ 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(),
- person_alias_1.fields(Person::safe_columns_tuple()),
- person_alias_2
- .fields(Person::safe_columns_tuple())
- .nullable(),
+ person::all_columns,
+ aliases::person1.fields(person::all_columns),
+ aliases::person2.fields(person::all_columns).nullable(),
))
- .first::<PrivateMessageReportViewTuple>(conn)
- .await?;
-
- 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::<PrivateMessageReportViewTuple>(&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::<PrivateMessageReportViewTuple>(&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<Self, Error> {
+ queries().read(pool, report_id).await
}
/// Returns the current unresolved post report count for the communities you mod
- pub async fn get_report_count(pool: &DbPool) -> Result<i64, Error> {
- use diesel::dsl::*;
+ pub async fn get_report_count(pool: &mut DbPool<'_>) -> Result<i64, Error> {
+ use diesel::dsl::count;
let conn = &mut get_conn(pool).await?;
private_message_report::table
}
}
-#[derive(TypedBuilder)]
-#[builder(field_defaults(default))]
-pub struct PrivateMessageReportQuery<'a> {
- #[builder(!default)]
- pool: &'a DbPool,
- page: Option<i64>,
- limit: Option<i64>,
- unresolved_only: Option<bool>,
+#[derive(Default)]
+pub struct PrivateMessageReportQuery {
+ pub page: Option<i64>,
+ pub limit: Option<i64>,
+ pub unresolved_only: bool,
}
-impl<'a> PrivateMessageReportQuery<'a> {
- pub async fn list(self) -> Result<Vec<PrivateMessageReportView>, 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::safe_columns_tuple(),
- person_alias_1.fields(Person::safe_columns_tuple()),
- person_alias_2
- .fields(Person::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::<PrivateMessageReportViewTuple>(conn).await?;
-
- Ok(PrivateMessageReportView::from_tuple_to_vec(res))
+impl PrivateMessageReportQuery {
+ pub async fn list(self, pool: &mut DbPool<'_>) -> Result<Vec<PrivateMessageReportView>, Error> {
+ queries().list(pool, self).await
}
}
-impl ViewToVec for PrivateMessageReportView {
- type DbTuple = PrivateMessageReportViewTuple;
- fn from_tuple_to_vec(items: Vec<Self::DbTuple>) -> Vec<Self> {
- 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::<Vec<Self>>()
+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::{
#[serial]
async fn test_crud() {
let pool = &build_db_pool_for_tests().await;
+ let pool = &mut pool.into();
- let inserted_instance = Instance::create(pool, "my_domain.tld").await.unwrap();
+ 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())
.await
.unwrap();
- let reports = PrivateMessageReportQuery::builder()
- .pool(pool)
- .build()
- .list()
+ let reports = PrivateMessageReportQuery::default()
+ .list(pool)
.await
.unwrap();
assert_eq!(1, reports.len());
.await
.unwrap();
- let reports = PrivateMessageReportQuery::builder()
- .pool(pool)
- .unresolved_only(Some(false))
- .build()
- .list()
- .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());
projects / lemmy.git / blobdiff