X-Git-Url: http://these/git/?a=blobdiff_plain;f=crates%2Fdb_views%2Fsrc%2Fprivate_message_view.rs;h=55d6583baeb98c75d6604ad6349c4154097d85ac;hb=9a5a13c734a1792511e1bfef7b9ac4121e0e7371;hp=151c50aac0977b57ed78794c328ba7a4dc593c59;hpb=8a4d9cc1ba81062b08dfca2e4b2594d1b053eca3;p=lemmy.git diff --git a/crates/db_views/src/private_message_view.rs b/crates/db_views/src/private_message_view.rs index 151c50aa..55d6583b 100644 --- a/crates/db_views/src/private_message_view.rs +++ b/crates/db_views/src/private_message_view.rs @@ -1,93 +1,72 @@ use crate::structs::PrivateMessageView; -use diesel::{pg::Pg, result::Error, *}; +use diesel::{ + debug_query, + pg::Pg, + result::Error, + BoolExpressionMethods, + ExpressionMethods, + JoinOnDsl, + QueryDsl, +}; +use diesel_async::RunQueryDsl; use lemmy_db_schema::{ + aliases, newtypes::{PersonId, PrivateMessageId}, - schema::{person, person_alias_1, private_message}, - source::{ - person::{Person, PersonAlias1, PersonSafe, PersonSafeAlias1}, - private_message::PrivateMessage, - }, - traits::{ToSafe, ViewToVec}, - utils::limit_and_offset, + schema::{person, private_message}, + source::{person::Person, private_message::PrivateMessage}, + traits::JoinView, + utils::{get_conn, limit_and_offset, DbConn, DbPool, ListFn, Queries, ReadFn}, }; use tracing::debug; -use typed_builder::TypedBuilder; -type PrivateMessageViewTuple = (PrivateMessage, PersonSafe, PersonSafeAlias1); +type PrivateMessageViewTuple = (PrivateMessage, Person, Person); -impl PrivateMessageView { - pub fn read(conn: &PgConnection, private_message_id: PrivateMessageId) -> Result { - let (private_message, creator, recipient) = private_message::table - .find(private_message_id) +fn queries<'a>() -> Queries< + impl ReadFn<'a, PrivateMessageView, PrivateMessageId>, + impl ListFn<'a, PrivateMessageView, (PrivateMessageQuery, PersonId)>, +> { + let all_joins = |query: private_message::BoxedQuery<'a, Pg>| { + query .inner_join(person::table.on(private_message::creator_id.eq(person::id))) - .inner_join(person_alias_1::table.on(private_message::recipient_id.eq(person_alias_1::id))) - .order_by(private_message::published.desc()) - .select(( - private_message::all_columns, - Person::safe_columns_tuple(), - PersonAlias1::safe_columns_tuple(), - )) - .first::(conn)?; - - Ok(PrivateMessageView { - private_message, - creator, - recipient, - }) - } + .inner_join( + aliases::person1.on(private_message::recipient_id.eq(aliases::person1.field(person::id))), + ) + }; - /// Gets the number of unread messages - pub fn get_unread_messages(conn: &PgConnection, my_person_id: PersonId) -> Result { - use diesel::dsl::*; - private_message::table - .filter(private_message::read.eq(false)) - .filter(private_message::recipient_id.eq(my_person_id)) - .filter(private_message::deleted.eq(false)) - .select(count(private_message::id)) - .first::(conn) - } -} + let selection = ( + private_message::all_columns, + person::all_columns, + aliases::person1.fields(person::all_columns), + ); -#[derive(TypedBuilder)] -#[builder(field_defaults(default))] -pub struct PrivateMessageQuery<'a> { - #[builder(!default)] - conn: &'a PgConnection, - #[builder(!default)] - recipient_id: PersonId, - unread_only: Option, - page: Option, - limit: Option, -} + let read = move |mut conn: DbConn<'a>, private_message_id: PrivateMessageId| async move { + all_joins(private_message::table.find(private_message_id).into_boxed()) + .order_by(private_message::published.desc()) + .select(selection) + .first::(&mut conn) + .await + }; -impl<'a> PrivateMessageQuery<'a> { - pub fn list(self) -> Result, Error> { - let mut query = private_message::table - .inner_join(person::table.on(private_message::creator_id.eq(person::id))) - .inner_join(person_alias_1::table.on(private_message::recipient_id.eq(person_alias_1::id))) - .select(( - private_message::all_columns, - Person::safe_columns_tuple(), - PersonAlias1::safe_columns_tuple(), - )) - .into_boxed(); + let list = move |mut conn: DbConn<'a>, + (options, recipient_id): (PrivateMessageQuery, PersonId)| async move { + let mut query = all_joins(private_message::table.into_boxed()).select(selection); // If its unread, I only want the ones to me - if self.unread_only.unwrap_or(false) { + if options.unread_only.unwrap_or(false) { query = query .filter(private_message::read.eq(false)) - .filter(private_message::recipient_id.eq(self.recipient_id)); + .filter(private_message::recipient_id.eq(recipient_id)); } // Otherwise, I want the ALL view to show both sent and received else { query = query.filter( private_message::recipient_id - .eq(self.recipient_id) - .or(private_message::creator_id.eq(self.recipient_id)), + .eq(recipient_id) + .or(private_message::creator_id.eq(recipient_id)), ) } - let (limit, offset) = limit_and_offset(self.page, self.limit)?; + let (limit, offset) = limit_and_offset(options.page, options.limit)?; query = query .filter(private_message::deleted.eq(false)) @@ -100,22 +79,61 @@ impl<'a> PrivateMessageQuery<'a> { debug_query::(&query) ); - let res = query.load::(self.conn)?; + query.load::(&mut conn).await + }; - Ok(PrivateMessageView::from_tuple_to_vec(res)) + Queries::new(read, list) +} + +impl PrivateMessageView { + pub async fn read( + pool: &mut DbPool<'_>, + private_message_id: PrivateMessageId, + ) -> Result { + queries().read(pool, private_message_id).await } + + /// Gets the number of unread messages + pub async fn get_unread_messages( + pool: &mut DbPool<'_>, + my_person_id: PersonId, + ) -> Result { + use diesel::dsl::count; + let conn = &mut get_conn(pool).await?; + private_message::table + .filter(private_message::read.eq(false)) + .filter(private_message::recipient_id.eq(my_person_id)) + .filter(private_message::deleted.eq(false)) + .select(count(private_message::id)) + .first::(conn) + .await + } +} + +#[derive(Default)] +pub struct PrivateMessageQuery { + pub unread_only: Option, + pub page: Option, + pub limit: Option, } -impl ViewToVec for PrivateMessageView { - type DbTuple = PrivateMessageViewTuple; - fn from_tuple_to_vec(items: Vec) -> Vec { - items - .into_iter() - .map(|a| Self { - private_message: a.0, - creator: a.1, - recipient: a.2, - }) - .collect::>() +impl PrivateMessageQuery { + pub async fn list( + self, + pool: &mut DbPool<'_>, + recipient_id: PersonId, + ) -> Result, Error> { + queries().list(pool, (self, recipient_id)).await + } +} + +impl JoinView for PrivateMessageView { + type JoinTuple = PrivateMessageViewTuple; + fn from_tuple(a: Self::JoinTuple) -> Self { + Self { + private_message: a.0, + creator: a.1, + recipient: a.2, + } } }