X-Git-Url: http://these/git/?a=blobdiff_plain;f=crates%2Fdb_views%2Fsrc%2Fpost_view.rs;h=1d85df3c83e0ea6cd51817d7f378556fd528915c;hb=ced3aa5bd8bc78fb7a1a98bd839531255b773a9c;hp=0804815dfb3485270b9925d47cc213df16bd0815;hpb=eb78af9b02a05a65aa56748a947c13ca1560ba89;p=lemmy.git diff --git a/crates/db_views/src/post_view.rs b/crates/db_views/src/post_view.rs index 0804815d..1d85df3c 100644 --- a/crates/db_views/src/post_view.rs +++ b/crates/db_views/src/post_view.rs @@ -1,4 +1,4 @@ -use crate::structs::PostView; +use crate::structs::{LocalUserView, PostView}; use diesel::{ debug_query, dsl::{now, IntervalDsl}, @@ -16,7 +16,7 @@ use diesel::{ use diesel_async::RunQueryDsl; use lemmy_db_schema::{ aggregates::structs::PostAggregates, - newtypes::{CommunityId, DbUrl, LocalUserId, PersonId, PostId}, + newtypes::{CommunityId, LocalUserId, PersonId, PostId}, schema::{ community, community_block, @@ -33,24 +33,22 @@ use lemmy_db_schema::{ post_saved, }, source::{ - community::{Community, CommunityFollower, CommunityPersonBan, CommunitySafe}, - local_user::LocalUser, - person::{Person, PersonSafe}, + community::{Community, CommunityFollower, CommunityPersonBan}, + person::Person, person_block::PersonBlock, post::{Post, PostRead, PostSaved}, }, - traits::{ToSafe, ViewToVec}, - utils::{functions::hot_rank, fuzzy_search, get_conn, limit_and_offset, DbPool}, + traits::JoinView, + utils::{fuzzy_search, get_conn, limit_and_offset, DbPool}, ListingType, SortType, }; use tracing::debug; -use typed_builder::TypedBuilder; type PostViewTuple = ( Post, - PersonSafe, - CommunitySafe, + Person, + Community, Option, PostAggregates, Option, @@ -65,27 +63,16 @@ 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, ) -> Result { let conn = &mut get_conn(pool).await?; // The left join below will return None in this case let person_id_join = my_person_id.unwrap_or(PersonId(-1)); - let ( - post, - creator, - community, - creator_banned_from_community, - counts, - follower, - saved, - read, - creator_blocked, - post_like, - unread_comments, - ) = post::table + let mut query = post::table .find(post_id) .inner_join(person::table) .inner_join(community::table) @@ -93,12 +80,7 @@ impl PostView { community_person_ban::table.on( post::community_id .eq(community_person_ban::community_id) - .and(community_person_ban::person_id.eq(post::creator_id)) - .and( - community_person_ban::expires - .is_null() - .or(community_person_ban::expires.gt(now)), - ), + .and(community_person_ban::person_id.eq(post::creator_id)), ), ) .inner_join(post_aggregates::table) @@ -146,8 +128,8 @@ impl PostView { ) .select(( post::all_columns, - Person::safe_columns_tuple(), - Community::safe_columns_tuple(), + person::all_columns, + community::all_columns, community_person_ban::all_columns.nullable(), post_aggregates::all_columns, community_follower::all_columns.nullable(), @@ -160,8 +142,39 @@ impl PostView { post_aggregates::comments, ), )) - .first::(conn) - .await?; + .into_boxed(); + + // Hide deleted and removed for non-admins or mods + if !is_mod_or_admin.unwrap_or(false) { + query = query + .filter(community::removed.eq(false)) + .filter(post::removed.eq(false)) + // users can see their own deleted posts + .filter( + community::deleted + .eq(false) + .or(post::creator_id.eq(person_id_join)), + ) + .filter( + post::deleted + .eq(false) + .or(post::creator_id.eq(person_id_join)), + ); + } + + let ( + post, + creator, + community, + creator_banned_from_community, + counts, + follower, + saved, + read, + creator_blocked, + post_like, + unread_comments, + ) = query.first::(conn).await?; // If a person is given, then my_vote, if None, should be 0, not null // Necessary to differentiate between other person's votes @@ -187,31 +200,31 @@ 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, - community_actor_id: Option, - local_user: Option<&'a LocalUser>, - search_term: Option, - url_search: Option, - saved_only: Option, - page: Option, - limit: Option, + pub listing_type: Option, + pub sort: Option, + pub creator_id: Option, + pub community_id: Option, + pub local_user: Option<&'a LocalUserView>, + pub search_term: Option, + pub url_search: Option, + pub saved_only: Option, + pub is_profile_view: 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)); - let local_user_id_join = self.local_user.map(|l| l.id).unwrap_or(LocalUserId(-1)); + let person_id_join = self.local_user.map(|l| l.person.id).unwrap_or(PersonId(-1)); + let local_user_id_join = self + .local_user + .map(|l| l.local_user.id) + .unwrap_or(LocalUserId(-1)); let mut query = post::table .inner_join(person::table) @@ -220,12 +233,7 @@ impl<'a> PostQuery<'a> { community_person_ban::table.on( post::community_id .eq(community_person_ban::community_id) - .and(community_person_ban::person_id.eq(post::creator_id)) - .and( - community_person_ban::expires - .is_null() - .or(community_person_ban::expires.gt(now)), - ), + .and(community_person_ban::person_id.eq(post::creator_id)), ), ) .inner_join(post_aggregates::table) @@ -259,7 +267,7 @@ impl<'a> PostQuery<'a> { ) .left_join( community_block::table.on( - community::id + post::community_id .eq(community_block::community_id) .and(community_block::person_id.eq(person_id_join)), ), @@ -287,8 +295,8 @@ impl<'a> PostQuery<'a> { ) .select(( post::all_columns, - Person::safe_columns_tuple(), - Community::safe_columns_tuple(), + person::all_columns, + community::all_columns, community_person_ban::all_columns.nullable(), post_aggregates::all_columns, community_follower::all_columns.nullable(), @@ -303,6 +311,35 @@ impl<'a> PostQuery<'a> { )) .into_boxed(); + let is_profile_view = self.is_profile_view.unwrap_or(false); + let is_creator = self.creator_id == self.local_user.map(|l| l.person.id); + // only show deleted posts to creator + if is_creator { + query = query + .filter(community::deleted.eq(false)) + .filter(post::deleted.eq(false)); + } + + let is_admin = self.local_user.map(|l| l.person.admin).unwrap_or(false); + // only show removed posts to admin when viewing user profile + if !(is_profile_view && is_admin) { + query = query + .filter(community::removed.eq(false)) + .filter(post::removed.eq(false)); + } + + if self.community_id.is_none() { + query = query.then_order_by(post_aggregates::featured_local.desc()); + } else if let Some(community_id) = self.community_id { + query = query + .filter(post::community_id.eq(community_id)) + .then_order_by(post_aggregates::featured_community.desc()); + } + + if let Some(creator_id) = self.creator_id { + query = query.filter(post::creator_id.eq(creator_id)); + } + if let Some(listing_type) = self.listing_type { match listing_type { ListingType::Subscribed => { @@ -324,17 +361,6 @@ impl<'a> PostQuery<'a> { } } } - if self.community_id.is_none() && self.community_actor_id.is_none() { - query = query.then_order_by(post_aggregates::featured_local.desc()); - } else if let Some(community_id) = self.community_id { - query = query - .filter(post::community_id.eq(community_id)) - .then_order_by(post_aggregates::featured_community.desc()); - } else if let Some(community_actor_id) = self.community_actor_id { - query = query - .filter(community::actor_id.eq(community_actor_id)) - .then_order_by(post_aggregates::featured_community.desc()); - } if let Some(url_search) = self.url_search { query = query.filter(post::url.eq(url_search)); @@ -349,33 +375,40 @@ impl<'a> PostQuery<'a> { ); } - // If its for a specific person, show the removed / deleted - if let Some(creator_id) = self.creator_id { - query = query.filter(post::creator_id.eq(creator_id)); - } - - if !self.local_user.map(|l| l.show_nsfw).unwrap_or(false) { + if !self + .local_user + .map(|l| l.local_user.show_nsfw) + .unwrap_or(false) + { query = query .filter(post::nsfw.eq(false)) .filter(community::nsfw.eq(false)); }; - if !self.local_user.map(|l| l.show_bot_accounts).unwrap_or(true) { + if !self + .local_user + .map(|l| l.local_user.show_bot_accounts) + .unwrap_or(true) + { query = query.filter(person::bot_account.eq(false)); }; if self.saved_only.unwrap_or(false) { - query = query.filter(post_saved::id.is_not_null()); + query = query.filter(post_saved::post_id.is_not_null()); } // Only hide the read posts, if the saved_only is false. Otherwise ppl with the hide_read // setting wont be able to see saved posts. - else if !self.local_user.map(|l| l.show_read_posts).unwrap_or(true) { - query = query.filter(post_read::id.is_null()); + else if !self + .local_user + .map(|l| l.local_user.show_read_posts) + .unwrap_or(true) + { + query = query.filter(post_read::post_id.is_null()); } if self.local_user.is_some() { // Filter out the rows with missing languages - query = query.filter(local_user_language::id.is_not_null()); + query = query.filter(local_user_language::language_id.is_not_null()); // Don't show blocked communities or persons query = query.filter(community_block::person_id.is_null()); @@ -384,16 +417,10 @@ 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()), + .then_order_by(post_aggregates::hot_rank_active.desc()) + .then_order_by(post_aggregates::published.desc()), SortType::Hot => query - .then_order_by(hot_rank(post_aggregates::score, post_aggregates::published).desc()) + .then_order_by(post_aggregates::hot_rank.desc()) .then_order_by(post_aggregates::published.desc()), SortType::New => query.then_order_by(post_aggregates::published.desc()), SortType::Old => query.then_order_by(post_aggregates::published.asc()), @@ -420,64 +447,86 @@ 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)?; - query = query - .limit(limit) - .offset(offset) - .filter(post::removed.eq(false)) - .filter(post::deleted.eq(false)) - .filter(community::removed.eq(false)) - .filter(community::deleted.eq(false)); + query = query.limit(limit).offset(offset); debug!("Post View Query: {:?}", debug_query::(&query)); let res = query.load::(conn).await?; - Ok(PostView::from_tuple_to_vec(res)) + Ok(res.into_iter().map(PostView::from_tuple).collect()) } } -impl ViewToVec for PostView { - type DbTuple = PostViewTuple; - fn from_tuple_to_vec(items: Vec) -> Vec { - items - .into_iter() - .map(|a| Self { - post: a.0, - creator: a.1, - community: a.2, - creator_banned_from_community: a.3.is_some(), - counts: a.4, - subscribed: CommunityFollower::to_subscribed_type(&a.5), - saved: a.6.is_some(), - read: a.7.is_some(), - creator_blocked: a.8.is_some(), - my_vote: a.9, - unread_comments: a.10, - }) - .collect::>() +impl JoinView for PostView { + type JoinTuple = PostViewTuple; + fn from_tuple(a: Self::JoinTuple) -> Self { + Self { + post: a.0, + creator: a.1, + community: a.2, + creator_banned_from_community: a.3.is_some(), + counts: a.4, + subscribed: CommunityFollower::to_subscribed_type(&a.5), + saved: a.6.is_some(), + read: a.7.is_some(), + creator_blocked: a.8.is_some(), + my_vote: a.9, + unread_comments: a.10, + } } } #[cfg(test)] mod tests { - use crate::post_view::{PostQuery, PostView}; + #![allow(clippy::unwrap_used)] + #![allow(clippy::indexing_slicing)] + + use crate::{ + post_view::{PostQuery, PostView}, + structs::LocalUserView, + }; use lemmy_db_schema::{ aggregates::structs::PostAggregates, + impls::actor_language::UNDETERMINED_ID, newtypes::LanguageId, source::{ actor_language::LocalUserLanguage, - community::{Community, CommunityInsertForm, CommunitySafe}, + community::{Community, CommunityInsertForm}, community_block::{CommunityBlock, CommunityBlockForm}, instance::Instance, language::Language, local_user::{LocalUser, LocalUserInsertForm, LocalUserUpdateForm}, - person::{Person, PersonInsertForm, PersonSafe}, + 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}, @@ -488,16 +537,17 @@ mod tests { struct Data { inserted_instance: Instance, - inserted_person: Person, - inserted_local_user: LocalUser, + local_user_view: LocalUserView, inserted_blocked_person: Person, inserted_bot: Person, inserted_community: Community, inserted_post: Post, } - async fn init_data(pool: &DbPool) -> Data { - let inserted_instance = Instance::create(pool, "my_domain.tld").await.unwrap(); + async fn init_data(pool: &mut DbPool<'_>) -> Data { + let inserted_instance = Instance::read_or_create(pool, "my_domain.tld".to_string()) + .await + .unwrap(); let person_name = "tegan".to_string(); @@ -576,11 +626,15 @@ mod tests { .build(); let _inserted_bot_post = Post::create(pool, &new_bot_post).await.unwrap(); + let local_user_view = LocalUserView { + local_user: inserted_local_user, + person: inserted_person, + counts: Default::default(), + }; Data { inserted_instance, - inserted_person, - inserted_local_user, + local_user_view, inserted_blocked_person, inserted_bot, inserted_community, @@ -592,30 +646,36 @@ mod tests { #[serial] async fn post_listing_with_person() { let pool = &build_db_pool_for_tests().await; - let data = init_data(pool).await; + let pool = &mut pool.into(); + let mut data = init_data(pool).await; 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) + LocalUser::update(pool, data.local_user_view.local_user.id, &local_user_form) .await .unwrap(); + data.local_user_view.local_user = inserted_local_user; - 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(&data.local_user_view)), + ..Default::default() + } + .list(pool) + .await + .unwrap(); - let post_listing_single_with_person = - PostView::read(pool, data.inserted_post.id, Some(data.inserted_person.id)) - .await - .unwrap(); + let post_listing_single_with_person = PostView::read( + pool, + data.inserted_post.id, + Some(data.local_user_view.person.id), + None, + ) + .await + .unwrap(); let mut expected_post_listing_with_user = expected_post_view(&data, pool).await; @@ -633,19 +693,20 @@ mod tests { .show_bot_accounts(Some(true)) .build(); let inserted_local_user = - LocalUser::update(pool, data.inserted_local_user.id, &local_user_form) + LocalUser::update(pool, data.local_user_view.local_user.id, &local_user_form) .await .unwrap(); + data.local_user_view.local_user = inserted_local_user; - 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(&data.local_user_view)), + ..Default::default() + } + .list(pool) + .await + .unwrap(); // should include bot post which has "undetermined" language assert_eq!(2, post_listings_with_bots.len()); @@ -656,20 +717,22 @@ 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) - .await - .unwrap(); + let read_post_listing_single_no_person = + PostView::read(pool, data.inserted_post.id, None, None) + .await + .unwrap(); let expected_post_listing_no_person = expected_post_view(&data, pool).await; @@ -692,23 +755,24 @@ 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 { - person_id: data.inserted_person.id, + person_id: data.local_user_view.person.id, community_id: data.inserted_community.id, }; 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.local_user_view)), + ..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()); @@ -722,11 +786,12 @@ mod tests { #[serial] async fn post_listing_like() { let pool = &build_db_pool_for_tests().await; - let data = init_data(pool).await; + let pool = &mut pool.into(); + let mut data = init_data(pool).await; let post_like_form = PostLikeForm { post_id: data.inserted_post.id, - person_id: data.inserted_person.id, + person_id: data.local_user_view.person.id, score: 1, }; @@ -735,15 +800,53 @@ mod tests { let expected_post_like = PostLike { id: inserted_post_like.id, post_id: data.inserted_post.id, - person_id: data.inserted_person.id, + person_id: data.local_user_view.person.id, published: inserted_post_like.published, score: 1, }; assert_eq!(expected_post_like, inserted_post_like); - let like_removed = PostLike::remove(pool, data.inserted_person.id, data.inserted_post.id) - .await - .unwrap(); + let post_listing_single_with_person = PostView::read( + pool, + data.inserted_post.id, + Some(data.local_user_view.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.local_user_view.local_user.id, &local_user_form) + .await + .unwrap(); + data.local_user_view.local_user = inserted_local_user; + + let read_post_listing = PostQuery { + sort: (Some(SortType::New)), + community_id: (Some(data.inserted_community.id)), + local_user: (Some(&data.local_user_view)), + ..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.local_user_view.person.id, data.inserted_post.id) + .await + .unwrap(); assert_eq!(1, like_removed); cleanup(data, pool).await; } @@ -752,6 +855,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")) @@ -760,21 +864,21 @@ mod tests { .unwrap(); let post_spanish = PostInsertForm::builder() .name("asffgdsc".to_string()) - .creator_id(data.inserted_person.id) + .creator_id(data.local_user_view.person.id) .community_id(data.inserted_community.id) .language_id(Some(spanish_id)) .build(); 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.local_user_view)), + ..Default::default() + } + .list(pool) + .await + .unwrap(); // no language filters specified, all posts should be returned assert_eq!(3, post_listings_all.len()); @@ -783,47 +887,45 @@ mod tests { .await .unwrap() .unwrap(); - LocalUserLanguage::update(pool, vec![french_id], data.inserted_local_user.id) + LocalUserLanguage::update(pool, vec![french_id], data.local_user_view.local_user.id) .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.local_user_view)), + ..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)); - let undetermined_id = Language::read_id_from_code(pool, Some("und")) - .await - .unwrap() - .unwrap(); LocalUserLanguage::update( pool, - vec![french_id, undetermined_id], - data.inserted_local_user.id, + vec![french_id, UNDETERMINED_ID], + data.local_user_view.local_user.id, ) .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.local_user_view)), + ..Default::default() + } + .list(pool) + .await + .unwrap(); // french post and undetermined language post should be returned assert_eq!(2, post_listings_french_und.len()); assert_eq!( - undetermined_id, + UNDETERMINED_ID, post_listings_french_und[0].post.language_id ); assert_eq!(french_id, post_listings_french_und[1].post.language_id); @@ -831,12 +933,105 @@ mod tests { cleanup(data, pool).await; } - async fn cleanup(data: Data, pool: &DbPool) { + #[tokio::test] + #[serial] + async fn post_listings_removed() { + let pool = &build_db_pool_for_tests().await; + let pool = &mut pool.into(); + let mut data = init_data(pool).await; + + // Remove the post + Post::update( + pool, + data.inserted_post.id, + &PostUpdateForm::builder().removed(Some(true)).build(), + ) + .await + .unwrap(); + + // Make sure you don't see the removed post in the results + let post_listings_no_admin = PostQuery { + sort: Some(SortType::New), + local_user: Some(&data.local_user_view), + ..Default::default() + } + .list(pool) + .await + .unwrap(); + assert_eq!(1, post_listings_no_admin.len()); + + // Removed post is shown to admins on profile page + data.local_user_view.person.admin = true; + let post_listings_is_admin = PostQuery { + sort: Some(SortType::New), + local_user: Some(&data.local_user_view), + is_profile_view: Some(true), + ..Default::default() + } + .list(pool) + .await + .unwrap(); + assert_eq!(2, post_listings_is_admin.len()); + + cleanup(data, pool).await; + } + + #[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_creator = PostQuery { + sort: Some(SortType::New), + ..Default::default() + } + .list(pool) + .await + .unwrap(); + let not_contains_deleted = post_listings_no_creator + .iter() + .map(|p| p.post.id) + .all(|p| p != data.inserted_post.id); + assert!(not_contains_deleted); + + // Deleted post is shown to creator + let post_listings_is_creator = PostQuery { + sort: Some(SortType::New), + local_user: Some(&data.local_user_view), + ..Default::default() + } + .list(pool) + .await + .unwrap(); + let contains_deleted = post_listings_is_creator + .iter() + .map(|p| p.post.id) + .any(|p| p == data.inserted_post.id); + assert!(contains_deleted); + + 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 .unwrap(); - Person::delete(pool, data.inserted_person.id).await.unwrap(); + Person::delete(pool, data.local_user_view.person.id) + .await + .unwrap(); Person::delete(pool, data.inserted_bot.id).await.unwrap(); Person::delete(pool, data.inserted_blocked_person.id) .await @@ -847,9 +1042,9 @@ 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.local_user_view.person, &data.inserted_community, &data.inserted_post, ); @@ -881,7 +1076,7 @@ mod tests { }, my_vote: None, unread_comments: 0, - creator: PersonSafe { + creator: Person { id: inserted_person.id, name: inserted_person.name.clone(), display_name: None, @@ -901,9 +1096,12 @@ mod tests { matrix_user_id: None, ban_expires: None, instance_id: data.inserted_instance.id, + private_key: inserted_person.private_key.clone(), + public_key: inserted_person.public_key.clone(), + last_refreshed_at: inserted_person.last_refreshed_at, }, creator_banned_from_community: false, - community: CommunitySafe { + community: Community { id: inserted_community.id, name: inserted_community.name.clone(), icon: None, @@ -920,6 +1118,14 @@ mod tests { posting_restricted_to_mods: false, published: inserted_community.published, instance_id: data.inserted_instance.id, + private_key: inserted_community.private_key.clone(), + public_key: inserted_community.public_key.clone(), + last_refreshed_at: inserted_community.last_refreshed_at, + followers_url: inserted_community.followers_url.clone(), + inbox_url: inserted_community.inbox_url.clone(), + shared_inbox_url: inserted_community.shared_inbox_url.clone(), + moderators_url: inserted_community.moderators_url.clone(), + featured_url: inserted_community.featured_url.clone(), }, counts: PostAggregates { id: agg.id, @@ -933,6 +1139,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,