X-Git-Url: http://these/git/?a=blobdiff_plain;f=crates%2Fdb_views_actor%2Fsrc%2Fperson_mention_view.rs;h=1a55443024ef485060d9662c132b704f4d2afe3a;hb=c8063f3267cf2b3622f1fdc69128c6b55feefbbc;hp=0be446a919ff8530de76b369656965d50b35baa8;hpb=e65c45f15272b5f43053a214600ee3b8cebffc0d;p=lemmy.git diff --git a/crates/db_views_actor/src/person_mention_view.rs b/crates/db_views_actor/src/person_mention_view.rs index 0be446a9..1a554430 100644 --- a/crates/db_views_actor/src/person_mention_view.rs +++ b/crates/db_views_actor/src/person_mention_view.rs @@ -1,8 +1,18 @@ -use diesel::{dsl::*, result::Error, *}; +use crate::structs::PersonMentionView; +use diesel::{ + dsl::now, + pg::Pg, + result::Error, + BoolExpressionMethods, + ExpressionMethods, + JoinOnDsl, + NullableExpressionMethods, + QueryDsl, +}; +use diesel_async::RunQueryDsl; use lemmy_db_schema::{ - aggregates::comment_aggregates::CommentAggregates, - functions::hot_rank, - limit_and_offset, + aggregates::structs::CommentAggregates, + aliases, newtypes::{PersonId, PersonMentionId}, schema::{ comment, @@ -13,97 +23,53 @@ use lemmy_db_schema::{ community_follower, community_person_ban, person, - person_alias_1, person_block, person_mention, post, }, source::{ - comment::{Comment, CommentSaved}, - community::{Community, CommunityFollower, CommunityPersonBan, CommunitySafe}, - person::{Person, PersonAlias1, PersonSafe, PersonSafeAlias1}, - person_block::PersonBlock, + comment::Comment, + community::{Community, CommunityFollower}, + person::Person, person_mention::PersonMention, post::Post, }, - traits::{MaybeOptional, ToSafe, ViewToVec}, - SortType, + traits::JoinView, + utils::{get_conn, limit_and_offset, DbConn, DbPool, ListFn, Queries, ReadFn}, + CommentSortType, + SubscribedType, }; -use serde::{Deserialize, Serialize}; - -#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)] -pub struct PersonMentionView { - pub person_mention: PersonMention, - pub comment: Comment, - pub creator: PersonSafe, - pub post: Post, - pub community: CommunitySafe, - pub recipient: PersonSafeAlias1, - pub counts: CommentAggregates, - pub creator_banned_from_community: bool, // Left Join to CommunityPersonBan - pub subscribed: bool, // Left join to CommunityFollower - pub saved: bool, // Left join to CommentSaved - pub creator_blocked: bool, // Left join to PersonBlock - pub my_vote: Option, // Left join to CommentLike -} type PersonMentionViewTuple = ( PersonMention, Comment, - PersonSafe, + Person, Post, - CommunitySafe, - PersonSafeAlias1, + Community, + Person, CommentAggregates, - Option, - Option, - Option, - Option, + bool, + SubscribedType, + bool, + bool, Option, ); -impl PersonMentionView { - pub fn read( - conn: &PgConnection, - person_mention_id: PersonMentionId, - my_person_id: Option, - ) -> Result { +fn queries<'a>() -> Queries< + impl ReadFn<'a, PersonMentionView, (PersonMentionId, Option)>, + impl ListFn<'a, PersonMentionView, PersonMentionQuery>, +> { + let all_joins = |query: person_mention::BoxedQuery<'a, Pg>, my_person_id: Option| { // The left join below will return None in this case let person_id_join = my_person_id.unwrap_or(PersonId(-1)); - let ( - person_mention, - comment, - creator, - post, - community, - recipient, - counts, - creator_banned_from_community, - subscribed, - saved, - creator_blocked, - my_vote, - ) = person_mention::table - .find(person_mention_id) + query .inner_join(comment::table) .inner_join(person::table.on(comment::creator_id.eq(person::id))) .inner_join(post::table.on(comment::post_id.eq(post::id))) .inner_join(community::table.on(post::community_id.eq(community::id))) - .inner_join(person_alias_1::table) + .inner_join(aliases::person1) .inner_join(comment_aggregates::table.on(comment::id.eq(comment_aggregates::comment_id))) - .left_join( - community_person_ban::table.on( - community::id - .eq(community_person_ban::community_id) - .and(community_person_ban::person_id.eq(comment::creator_id)) - .and( - community_person_ban::expires - .is_null() - .or(community_person_ban::expires.gt(now)), - ), - ), - ) .left_join( community_follower::table.on( post::community_id @@ -132,116 +98,44 @@ impl PersonMentionView { .and(comment_like::person_id.eq(person_id_join)), ), ) - .select(( - person_mention::all_columns, - comment::all_columns, - Person::safe_columns_tuple(), - post::all_columns, - Community::safe_columns_tuple(), - PersonAlias1::safe_columns_tuple(), - comment_aggregates::all_columns, - community_person_ban::all_columns.nullable(), - community_follower::all_columns.nullable(), - comment_saved::all_columns.nullable(), - person_block::all_columns.nullable(), - comment_like::score.nullable(), - )) - .first::(conn)?; - - Ok(PersonMentionView { - person_mention, - comment, - creator, - post, - community, - recipient, - counts, - creator_banned_from_community: creator_banned_from_community.is_some(), - subscribed: subscribed.is_some(), - saved: saved.is_some(), - creator_blocked: creator_blocked.is_some(), - my_vote, - }) - } - - /// Gets the number of unread mentions - pub fn get_unread_mentions(conn: &PgConnection, my_person_id: PersonId) -> Result { - use diesel::dsl::*; - - person_mention::table - .filter(person_mention::recipient_id.eq(my_person_id)) - .filter(person_mention::read.eq(false)) - .select(count(person_mention::id)) - .first::(conn) - } -} - -pub struct PersonMentionQueryBuilder<'a> { - conn: &'a PgConnection, - my_person_id: Option, - recipient_id: Option, - sort: Option, - unread_only: Option, - page: Option, - limit: Option, -} - -impl<'a> PersonMentionQueryBuilder<'a> { - pub fn create(conn: &'a PgConnection) -> Self { - PersonMentionQueryBuilder { - conn, - my_person_id: None, - recipient_id: None, - sort: None, - unread_only: None, - page: None, - limit: None, - } - } - - pub fn sort>(mut self, sort: T) -> Self { - self.sort = sort.get_optional(); - self - } - - pub fn unread_only>(mut self, unread_only: T) -> Self { - self.unread_only = unread_only.get_optional(); - self - } - - pub fn recipient_id>(mut self, recipient_id: T) -> Self { - self.recipient_id = recipient_id.get_optional(); - self - } - - pub fn my_person_id>(mut self, my_person_id: T) -> Self { - self.my_person_id = my_person_id.get_optional(); - self - } - - pub fn page>(mut self, page: T) -> Self { - self.page = page.get_optional(); - self - } - - pub fn limit>(mut self, limit: T) -> Self { - self.limit = limit.get_optional(); - self - } - - pub fn list(self) -> Result, Error> { - use diesel::dsl::*; - - // The left join below will return None in this case - let person_id_join = self.my_person_id.unwrap_or(PersonId(-1)); + }; + + let selection = ( + person_mention::all_columns, + comment::all_columns, + person::all_columns, + post::all_columns, + community::all_columns, + aliases::person1.fields(person::all_columns), + comment_aggregates::all_columns, + community_person_ban::id.nullable().is_not_null(), + CommunityFollower::select_subscribed_type(), + comment_saved::id.nullable().is_not_null(), + person_block::id.nullable().is_not_null(), + comment_like::score.nullable(), + ); + + let read = + move |mut conn: DbConn<'a>, + (person_mention_id, my_person_id): (PersonMentionId, Option)| async move { + all_joins( + person_mention::table.find(person_mention_id).into_boxed(), + my_person_id, + ) + .left_join( + community_person_ban::table.on( + community::id + .eq(community_person_ban::community_id) + .and(community_person_ban::person_id.eq(comment::creator_id)), + ), + ) + .select(selection) + .first::(&mut conn) + .await + }; - let mut query = person_mention::table - .inner_join(comment::table) - .inner_join(person::table.on(comment::creator_id.eq(person::id))) - .inner_join(post::table.on(comment::post_id.eq(post::id))) - .inner_join(community::table.on(post::community_id.eq(community::id))) - .inner_join(person_alias_1::table) - .inner_join(comment_aggregates::table.on(comment::id.eq(comment_aggregates::comment_id))) + let list = move |mut conn: DbConn<'a>, options: PersonMentionQuery| async move { + let mut query = all_joins(person_mention::table.into_boxed(), options.my_person_id) .left_join( community_person_ban::table.on( community::id @@ -254,110 +148,106 @@ impl<'a> PersonMentionQueryBuilder<'a> { ), ), ) - .left_join( - community_follower::table.on( - post::community_id - .eq(community_follower::community_id) - .and(community_follower::person_id.eq(person_id_join)), - ), - ) - .left_join( - comment_saved::table.on( - comment::id - .eq(comment_saved::comment_id) - .and(comment_saved::person_id.eq(person_id_join)), - ), - ) - .left_join( - person_block::table.on( - comment::creator_id - .eq(person_block::target_id) - .and(person_block::person_id.eq(person_id_join)), - ), - ) - .left_join( - comment_like::table.on( - comment::id - .eq(comment_like::comment_id) - .and(comment_like::person_id.eq(person_id_join)), - ), - ) - .select(( - person_mention::all_columns, - comment::all_columns, - Person::safe_columns_tuple(), - post::all_columns, - Community::safe_columns_tuple(), - PersonAlias1::safe_columns_tuple(), - comment_aggregates::all_columns, - community_person_ban::all_columns.nullable(), - community_follower::all_columns.nullable(), - comment_saved::all_columns.nullable(), - person_block::all_columns.nullable(), - comment_like::score.nullable(), - )) - .into_boxed(); + .select(selection); - if let Some(recipient_id) = self.recipient_id { + if let Some(recipient_id) = options.recipient_id { query = query.filter(person_mention::recipient_id.eq(recipient_id)); } - if self.unread_only.unwrap_or(false) { + if options.unread_only { query = query.filter(person_mention::read.eq(false)); } - query = match self.sort.unwrap_or(SortType::Hot) { - SortType::Hot | SortType::Active => query - .order_by(hot_rank(comment_aggregates::score, comment_aggregates::published).desc()) - .then_order_by(comment_aggregates::published.desc()), - SortType::New | SortType::MostComments | SortType::NewComments => { - query.order_by(comment::published.desc()) + if !options.show_bot_accounts { + query = query.filter(person::bot_account.eq(false)); + }; + + query = match options.sort.unwrap_or(CommentSortType::Hot) { + CommentSortType::Hot => query.then_order_by(comment_aggregates::hot_rank.desc()), + CommentSortType::Controversial => { + query.then_order_by(comment_aggregates::controversy_rank.desc()) } - SortType::TopAll => query.order_by(comment_aggregates::score.desc()), - SortType::TopYear => query - .filter(comment::published.gt(now - 1.years())) - .order_by(comment_aggregates::score.desc()), - SortType::TopMonth => query - .filter(comment::published.gt(now - 1.months())) - .order_by(comment_aggregates::score.desc()), - SortType::TopWeek => query - .filter(comment::published.gt(now - 1.weeks())) - .order_by(comment_aggregates::score.desc()), - SortType::TopDay => query - .filter(comment::published.gt(now - 1.days())) - .order_by(comment_aggregates::score.desc()), + CommentSortType::New => query.then_order_by(comment::published.desc()), + CommentSortType::Old => query.then_order_by(comment::published.asc()), + CommentSortType::Top => query.order_by(comment_aggregates::score.desc()), }; - let (limit, offset) = limit_and_offset(self.page, self.limit); + let (limit, offset) = limit_and_offset(options.page, options.limit)?; - let res = query + query .limit(limit) .offset(offset) - .load::(self.conn)?; + .load::(&mut conn) + .await + }; - Ok(PersonMentionView::from_tuple_to_vec(res)) + Queries::new(read, list) +} + +impl PersonMentionView { + pub async fn read( + pool: &mut DbPool<'_>, + person_mention_id: PersonMentionId, + my_person_id: Option, + ) -> Result { + queries() + .read(pool, (person_mention_id, my_person_id)) + .await } + + /// Gets the number of unread mentions + pub async fn get_unread_mentions( + pool: &mut DbPool<'_>, + my_person_id: PersonId, + ) -> Result { + use diesel::dsl::count; + let conn = &mut get_conn(pool).await?; + + person_mention::table + .inner_join(comment::table) + .filter(person_mention::recipient_id.eq(my_person_id)) + .filter(person_mention::read.eq(false)) + .filter(comment::deleted.eq(false)) + .filter(comment::removed.eq(false)) + .select(count(person_mention::id)) + .first::(conn) + .await + } +} + +#[derive(Default)] +pub struct PersonMentionQuery { + pub my_person_id: Option, + pub recipient_id: Option, + pub sort: Option, + pub unread_only: bool, + pub show_bot_accounts: bool, + pub page: Option, + pub limit: Option, } -impl ViewToVec for PersonMentionView { - type DbTuple = PersonMentionViewTuple; - fn from_tuple_to_vec(items: Vec) -> Vec { - items - .iter() - .map(|a| Self { - person_mention: a.0.to_owned(), - comment: a.1.to_owned(), - creator: a.2.to_owned(), - post: a.3.to_owned(), - community: a.4.to_owned(), - recipient: a.5.to_owned(), - counts: a.6.to_owned(), - creator_banned_from_community: a.7.is_some(), - subscribed: a.8.is_some(), - saved: a.9.is_some(), - creator_blocked: a.10.is_some(), - my_vote: a.11, - }) - .collect::>() +impl PersonMentionQuery { + pub async fn list(self, pool: &mut DbPool<'_>) -> Result, Error> { + queries().list(pool, self).await + } +} + +impl JoinView for PersonMentionView { + type JoinTuple = PersonMentionViewTuple; + fn from_tuple(a: Self::JoinTuple) -> Self { + Self { + person_mention: a.0, + comment: a.1, + creator: a.2, + post: a.3, + community: a.4, + recipient: a.5, + counts: a.6, + creator_banned_from_community: a.7, + subscribed: a.8, + saved: a.9, + creator_blocked: a.10, + my_vote: a.11, + } } }