X-Git-Url: http://these/git/?a=blobdiff_plain;f=crates%2Fdb_views%2Fsrc%2Fpost_view.rs;h=0e6ad703cff9f3780fb60521033c383142787a9c;hb=92568956353f21649ed9aff68b42699c9d036f30;hp=f3319a90c0815c42c4d64a6a836eb1412989af25;hpb=1b5437cbe3fe0b9726c5760c05f52054ab4e54c2;p=lemmy.git diff --git a/crates/db_views/src/post_view.rs b/crates/db_views/src/post_view.rs index f3319a90..0e6ad703 100644 --- a/crates/db_views/src/post_view.rs +++ b/crates/db_views/src/post_view.rs @@ -40,12 +40,11 @@ use lemmy_db_schema::{ post::{Post, PostRead, PostSaved}, }, traits::JoinView, - utils::{functions::hot_rank, fuzzy_search, get_conn, limit_and_offset, DbPool}, + utils::{fuzzy_search, get_conn, limit_and_offset, DbPool}, ListingType, SortType, }; use tracing::debug; -use typed_builder::TypedBuilder; type PostViewTuple = ( Post, @@ -65,7 +64,7 @@ sql_function!(fn coalesce(x: sql_types::Nullable, y: sql_type impl PostView { pub async fn read( - pool: &DbPool, + pool: &mut DbPool<'_>, post_id: PostId, my_person_id: Option, is_mod_or_admin: Option, @@ -147,10 +146,12 @@ impl PostView { .into_boxed(); // Hide deleted and removed for non-admins or mods - if !is_mod_or_admin.unwrap_or(true) { + if !is_mod_or_admin.unwrap_or(false) { query = query .filter(community::removed.eq(false)) - .filter(community::deleted.eq(false)); + .filter(community::deleted.eq(false)) + .filter(post::removed.eq(false)) + .filter(post::deleted.eq(false)); } let ( @@ -191,28 +192,25 @@ impl PostView { } } -#[derive(TypedBuilder)] -#[builder(field_defaults(default))] +#[derive(Default)] pub struct PostQuery<'a> { - #[builder(!default)] - pool: &'a DbPool, - listing_type: Option, - sort: Option, - creator_id: Option, - community_id: Option, - local_user: Option<&'a LocalUser>, - search_term: Option, - url_search: Option, - saved_only: Option, + pub listing_type: Option, + pub sort: Option, + pub creator_id: Option, + pub community_id: Option, + pub local_user: Option<&'a LocalUser>, + pub search_term: Option, + pub url_search: Option, + pub saved_only: Option, /// Used to show deleted or removed posts for admins - is_mod_or_admin: Option, - page: Option, - limit: Option, + pub is_mod_or_admin: Option, + pub page: Option, + pub limit: Option, } impl<'a> PostQuery<'a> { - pub async fn list(self) -> Result, Error> { - let conn = &mut get_conn(self.pool).await?; + pub async fn list(self, pool: &mut DbPool<'_>) -> Result, Error> { + let conn = &mut get_conn(pool).await?; // The left join below will return None in this case let person_id_join = self.local_user.map(|l| l.person_id).unwrap_or(PersonId(-1)); @@ -305,10 +303,12 @@ impl<'a> PostQuery<'a> { // Hide deleted and removed for non-admins or mods // TODO This eventually needs to show posts where you are the creator - if !self.is_mod_or_admin.unwrap_or(true) { + if !self.is_mod_or_admin.unwrap_or(false) { query = query .filter(community::removed.eq(false)) - .filter(community::deleted.eq(false)); + .filter(community::deleted.eq(false)) + .filter(post::removed.eq(false)) + .filter(post::deleted.eq(false)); } if self.community_id.is_none() { @@ -387,18 +387,8 @@ impl<'a> PostQuery<'a> { } query = match self.sort.unwrap_or(SortType::Hot) { - SortType::Active => query - .then_order_by( - hot_rank( - post_aggregates::score, - post_aggregates::newest_comment_time_necro, - ) - .desc(), - ) - .then_order_by(post_aggregates::newest_comment_time_necro.desc()), - SortType::Hot => query - .then_order_by(hot_rank(post_aggregates::score, post_aggregates::published).desc()) - .then_order_by(post_aggregates::published.desc()), + SortType::Active => query.then_order_by(post_aggregates::hot_rank_active.desc()), + SortType::Hot => query.then_order_by(post_aggregates::hot_rank.desc()), SortType::New => query.then_order_by(post_aggregates::published.desc()), SortType::Old => query.then_order_by(post_aggregates::published.asc()), SortType::NewComments => query.then_order_by(post_aggregates::newest_comment_time.desc()), @@ -424,6 +414,30 @@ impl<'a> PostQuery<'a> { .filter(post_aggregates::published.gt(now - 1.days())) .then_order_by(post_aggregates::score.desc()) .then_order_by(post_aggregates::published.desc()), + SortType::TopHour => query + .filter(post_aggregates::published.gt(now - 1.hours())) + .then_order_by(post_aggregates::score.desc()) + .then_order_by(post_aggregates::published.desc()), + SortType::TopSixHour => query + .filter(post_aggregates::published.gt(now - 6.hours())) + .then_order_by(post_aggregates::score.desc()) + .then_order_by(post_aggregates::published.desc()), + SortType::TopTwelveHour => query + .filter(post_aggregates::published.gt(now - 12.hours())) + .then_order_by(post_aggregates::score.desc()) + .then_order_by(post_aggregates::published.desc()), + SortType::TopThreeMonths => query + .filter(post_aggregates::published.gt(now - 3.months())) + .then_order_by(post_aggregates::score.desc()) + .then_order_by(post_aggregates::published.desc()), + SortType::TopSixMonths => query + .filter(post_aggregates::published.gt(now - 6.months())) + .then_order_by(post_aggregates::score.desc()) + .then_order_by(post_aggregates::published.desc()), + SortType::TopNineMonths => query + .filter(post_aggregates::published.gt(now - 9.months())) + .then_order_by(post_aggregates::score.desc()) + .then_order_by(post_aggregates::published.desc()), }; let (limit, offset) = limit_and_offset(self.page, self.limit)?; @@ -459,6 +473,9 @@ impl JoinView for PostView { #[cfg(test)] mod tests { + #![allow(clippy::unwrap_used)] + #![allow(clippy::indexing_slicing)] + use crate::post_view::{PostQuery, PostView}; use lemmy_db_schema::{ aggregates::structs::PostAggregates, @@ -473,7 +490,7 @@ mod tests { local_user::{LocalUser, LocalUserInsertForm, LocalUserUpdateForm}, person::{Person, PersonInsertForm}, person_block::{PersonBlock, PersonBlockForm}, - post::{Post, PostInsertForm, PostLike, PostLikeForm}, + post::{Post, PostInsertForm, PostLike, PostLikeForm, PostUpdateForm}, }, traits::{Blockable, Crud, Likeable}, utils::{build_db_pool_for_tests, DbPool}, @@ -492,7 +509,7 @@ mod tests { inserted_post: Post, } - async fn init_data(pool: &DbPool) -> Data { + async fn init_data(pool: &mut DbPool<'_>) -> Data { let inserted_instance = Instance::read_or_create(pool, "my_domain.tld".to_string()) .await .unwrap(); @@ -590,6 +607,7 @@ mod tests { #[serial] async fn post_listing_with_person() { let pool = &build_db_pool_for_tests().await; + let pool = &mut pool.into(); let data = init_data(pool).await; let local_user_form = LocalUserUpdateForm::builder() @@ -600,15 +618,15 @@ mod tests { .await .unwrap(); - let read_post_listing = PostQuery::builder() - .pool(pool) - .sort(Some(SortType::New)) - .community_id(Some(data.inserted_community.id)) - .local_user(Some(&inserted_local_user)) - .build() - .list() - .await - .unwrap(); + let read_post_listing = PostQuery { + sort: (Some(SortType::New)), + community_id: (Some(data.inserted_community.id)), + local_user: (Some(&inserted_local_user)), + ..Default::default() + } + .list(pool) + .await + .unwrap(); let post_listing_single_with_person = PostView::read( pool, @@ -639,15 +657,15 @@ mod tests { .await .unwrap(); - let post_listings_with_bots = PostQuery::builder() - .pool(pool) - .sort(Some(SortType::New)) - .community_id(Some(data.inserted_community.id)) - .local_user(Some(&inserted_local_user)) - .build() - .list() - .await - .unwrap(); + let post_listings_with_bots = PostQuery { + sort: (Some(SortType::New)), + community_id: (Some(data.inserted_community.id)), + local_user: (Some(&inserted_local_user)), + ..Default::default() + } + .list(pool) + .await + .unwrap(); // should include bot post which has "undetermined" language assert_eq!(2, post_listings_with_bots.len()); @@ -658,16 +676,17 @@ mod tests { #[serial] async fn post_listing_no_person() { let pool = &build_db_pool_for_tests().await; + let pool = &mut pool.into(); let data = init_data(pool).await; - let read_post_listing_multiple_no_person = PostQuery::builder() - .pool(pool) - .sort(Some(SortType::New)) - .community_id(Some(data.inserted_community.id)) - .build() - .list() - .await - .unwrap(); + let read_post_listing_multiple_no_person = PostQuery { + sort: (Some(SortType::New)), + community_id: (Some(data.inserted_community.id)), + ..Default::default() + } + .list(pool) + .await + .unwrap(); let read_post_listing_single_no_person = PostView::read(pool, data.inserted_post.id, None, None) @@ -695,6 +714,7 @@ mod tests { #[serial] async fn post_listing_block_community() { let pool = &build_db_pool_for_tests().await; + let pool = &mut pool.into(); let data = init_data(pool).await; let community_block = CommunityBlockForm { @@ -703,15 +723,15 @@ mod tests { }; CommunityBlock::block(pool, &community_block).await.unwrap(); - let read_post_listings_with_person_after_block = PostQuery::builder() - .pool(pool) - .sort(Some(SortType::New)) - .community_id(Some(data.inserted_community.id)) - .local_user(Some(&data.inserted_local_user)) - .build() - .list() - .await - .unwrap(); + let read_post_listings_with_person_after_block = PostQuery { + sort: (Some(SortType::New)), + community_id: (Some(data.inserted_community.id)), + local_user: (Some(&data.inserted_local_user)), + ..Default::default() + } + .list(pool) + .await + .unwrap(); // Should be 0 posts after the community block assert_eq!(0, read_post_listings_with_person_after_block.len()); @@ -725,6 +745,7 @@ mod tests { #[serial] async fn post_listing_like() { let pool = &build_db_pool_for_tests().await; + let pool = &mut pool.into(); let data = init_data(pool).await; let post_like_form = PostLikeForm { @@ -744,6 +765,42 @@ mod tests { }; assert_eq!(expected_post_like, inserted_post_like); + let post_listing_single_with_person = PostView::read( + pool, + data.inserted_post.id, + Some(data.inserted_person.id), + None, + ) + .await + .unwrap(); + + let mut expected_post_with_upvote = expected_post_view(&data, pool).await; + expected_post_with_upvote.my_vote = Some(1); + expected_post_with_upvote.counts.score = 1; + expected_post_with_upvote.counts.upvotes = 1; + assert_eq!(expected_post_with_upvote, post_listing_single_with_person); + + let local_user_form = LocalUserUpdateForm::builder() + .show_bot_accounts(Some(false)) + .build(); + let inserted_local_user = + LocalUser::update(pool, data.inserted_local_user.id, &local_user_form) + .await + .unwrap(); + + let read_post_listing = PostQuery { + sort: (Some(SortType::New)), + community_id: (Some(data.inserted_community.id)), + local_user: (Some(&inserted_local_user)), + ..Default::default() + } + .list(pool) + .await + .unwrap(); + assert_eq!(1, read_post_listing.len()); + + assert_eq!(expected_post_with_upvote, read_post_listing[0]); + let like_removed = PostLike::remove(pool, data.inserted_person.id, data.inserted_post.id) .await .unwrap(); @@ -755,6 +812,7 @@ mod tests { #[serial] async fn post_listing_person_language() { let pool = &build_db_pool_for_tests().await; + let pool = &mut pool.into(); let data = init_data(pool).await; let spanish_id = Language::read_id_from_code(pool, Some("es")) @@ -770,14 +828,14 @@ mod tests { Post::create(pool, &post_spanish).await.unwrap(); - let post_listings_all = PostQuery::builder() - .pool(pool) - .sort(Some(SortType::New)) - .local_user(Some(&data.inserted_local_user)) - .build() - .list() - .await - .unwrap(); + let post_listings_all = PostQuery { + sort: (Some(SortType::New)), + local_user: (Some(&data.inserted_local_user)), + ..Default::default() + } + .list(pool) + .await + .unwrap(); // no language filters specified, all posts should be returned assert_eq!(3, post_listings_all.len()); @@ -790,18 +848,20 @@ mod tests { .await .unwrap(); - let post_listing_french = PostQuery::builder() - .pool(pool) - .sort(Some(SortType::New)) - .local_user(Some(&data.inserted_local_user)) - .build() - .list() - .await - .unwrap(); + let post_listing_french = PostQuery { + sort: (Some(SortType::New)), + local_user: (Some(&data.inserted_local_user)), + ..Default::default() + } + .list(pool) + .await + .unwrap(); - // only one french language post should be returned - assert_eq!(1, post_listing_french.len()); - assert_eq!(french_id, post_listing_french[0].post.language_id); + // only one post in french and one undetermined should be returned + assert_eq!(2, post_listing_french.len()); + assert!(post_listing_french + .iter() + .any(|p| p.post.language_id == french_id)); LocalUserLanguage::update( pool, @@ -810,14 +870,14 @@ mod tests { ) .await .unwrap(); - let post_listings_french_und = PostQuery::builder() - .pool(pool) - .sort(Some(SortType::New)) - .local_user(Some(&data.inserted_local_user)) - .build() - .list() - .await - .unwrap(); + let post_listings_french_und = PostQuery { + sort: (Some(SortType::New)), + local_user: (Some(&data.inserted_local_user)), + ..Default::default() + } + .list(pool) + .await + .unwrap(); // french post and undetermined language post should be returned assert_eq!(2, post_listings_french_und.len()); @@ -830,7 +890,52 @@ mod tests { cleanup(data, pool).await; } - async fn cleanup(data: Data, pool: &DbPool) { + #[tokio::test] + #[serial] + async fn post_listings_deleted() { + let pool = &build_db_pool_for_tests().await; + let pool = &mut pool.into(); + let data = init_data(pool).await; + + // Delete the post + Post::update( + pool, + data.inserted_post.id, + &PostUpdateForm::builder().deleted(Some(true)).build(), + ) + .await + .unwrap(); + + // Make sure you don't see the deleted post in the results + let post_listings_no_admin = PostQuery { + sort: (Some(SortType::New)), + local_user: (Some(&data.inserted_local_user)), + is_mod_or_admin: (Some(false)), + ..Default::default() + } + .list(pool) + .await + .unwrap(); + + assert_eq!(1, post_listings_no_admin.len()); + + // Make sure they see both + let post_listings_is_admin = PostQuery { + sort: (Some(SortType::New)), + local_user: (Some(&data.inserted_local_user)), + is_mod_or_admin: (Some(true)), + ..Default::default() + } + .list(pool) + .await + .unwrap(); + + assert_eq!(2, post_listings_is_admin.len()); + + cleanup(data, pool).await; + } + + async fn cleanup(data: Data, pool: &mut DbPool<'_>) { let num_deleted = Post::delete(pool, data.inserted_post.id).await.unwrap(); Community::delete(pool, data.inserted_community.id) .await @@ -846,7 +951,7 @@ mod tests { assert_eq!(1, num_deleted); } - async fn expected_post_view(data: &Data, pool: &DbPool) -> PostView { + async fn expected_post_view(data: &Data, pool: &mut DbPool<'_>) -> PostView { let (inserted_person, inserted_community, inserted_post) = ( &data.inserted_person, &data.inserted_community, @@ -943,6 +1048,8 @@ mod tests { newest_comment_time: inserted_post.published, featured_community: false, featured_local: false, + hot_rank: 1728, + hot_rank_active: 1728, }, subscribed: SubscribedType::NotSubscribed, read: false,