X-Git-Url: http://these/git/?a=blobdiff_plain;f=crates%2Fdb_views%2Fsrc%2Fpost_view.rs;h=0e6ad703cff9f3780fb60521033c383142787a9c;hb=92568956353f21649ed9aff68b42699c9d036f30;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..0e6ad703 100644 --- a/crates/db_views/src/post_view.rs +++ b/crates/db_views/src/post_view.rs @@ -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,23 @@ use lemmy_db_schema::{ post_saved, }, source::{ - community::{Community, CommunityFollower, CommunityPersonBan, CommunitySafe}, + community::{Community, CommunityFollower, CommunityPersonBan}, local_user::LocalUser, - person::{Person, PersonSafe}, + 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 +64,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 +81,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 +129,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 +143,30 @@ 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(community::deleted.eq(false)) + .filter(post::removed.eq(false)) + .filter(post::deleted.eq(false)); + } + + 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,27 +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, - 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 LocalUser>, + pub search_term: Option, + pub url_search: Option, + pub saved_only: Option, + /// Used to show deleted or removed posts for admins + 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)); @@ -220,12 +223,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 +257,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 +285,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 +301,28 @@ impl<'a> PostQuery<'a> { )) .into_boxed(); + // 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(false) { + query = query + .filter(community::removed.eq(false)) + .filter(community::deleted.eq(false)) + .filter(post::removed.eq(false)) + .filter(post::deleted.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 +344,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,11 +358,6 @@ 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) { query = query .filter(post::nsfw.eq(false)) @@ -365,17 +369,17 @@ impl<'a> PostQuery<'a> { }; 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()); + 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()); @@ -383,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()), @@ -420,64 +414,83 @@ 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 { + #![allow(clippy::unwrap_used)] + #![allow(clippy::indexing_slicing)] + use crate::post_view::{PostQuery, PostView}; 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}, @@ -496,8 +509,10 @@ mod tests { 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(); @@ -592,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() @@ -602,20 +618,24 @@ 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, 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.inserted_person.id), + None, + ) + .await + .unwrap(); let mut expected_post_listing_with_user = expected_post_view(&data, pool).await; @@ -637,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()); @@ -656,20 +676,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,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 { @@ -700,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()); @@ -722,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 { @@ -741,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(); @@ -752,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")) @@ -767,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()); @@ -787,43 +848,41 @@ 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)); - let undetermined_id = Language::read_id_from_code(pool, Some("und")) - .await - .unwrap() - .unwrap(); LocalUserLanguage::update( pool, - vec![french_id, undetermined_id], + vec![french_id, UNDETERMINED_ID], data.inserted_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.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()); 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,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 @@ -847,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, @@ -881,7 +985,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 +1005,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 +1027,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 +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,