X-Git-Url: http://these/git/?a=blobdiff_plain;f=crates%2Fdb_views%2Fsrc%2Fpost_view.rs;h=5fcb73f69da09a24fdb2c14554037ecfd4730ad1;hb=a47b12bbdee274c761a912cde0baddb715674023;hp=a7207aa9ad1f0625d654b8da612a13561c391a58;hpb=f0e16278249ca83140649f87e29cd2c47a610915;p=lemmy.git

diff --git a/crates/db_views/src/post_view.rs b/crates/db_views/src/post_view.rs
index a7207aa9..5fcb73f6 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,11 +16,12 @@ 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,
     community_follower,
+    community_moderator,
     community_person_ban,
     local_user_language,
     person,
@@ -33,251 +34,175 @@ use lemmy_db_schema::{
     post_saved,
   },
   source::{
-    community::{Community, CommunityFollower, CommunityPersonBan, CommunitySafe},
-    local_user::LocalUser,
-    person::{Person, PersonSafe},
-    person_block::PersonBlock,
-    post::{Post, PostRead, PostSaved},
+    community::{Community, CommunityFollower},
+    person::Person,
+    post::Post,
   },
-  traits::{ToSafe, ViewToVec},
-  utils::{functions::hot_rank, fuzzy_search, get_conn, limit_and_offset, DbPool},
+  traits::JoinView,
+  utils::{fuzzy_search, limit_and_offset, DbConn, DbPool, ListFn, Queries, ReadFn},
   ListingType,
   SortType,
+  SubscribedType,
 };
 use tracing::debug;
-use typed_builder::TypedBuilder;
 
 type PostViewTuple = (
   Post,
-  PersonSafe,
-  CommunitySafe,
-  Option<CommunityPersonBan>,
+  Person,
+  Community,
+  bool,
   PostAggregates,
-  Option<CommunityFollower>,
-  Option<PostSaved>,
-  Option<PostRead>,
-  Option<PersonBlock>,
+  SubscribedType,
+  bool,
+  bool,
+  bool,
   Option<i16>,
   i64,
 );
 
 sql_function!(fn coalesce(x: sql_types::Nullable<sql_types::BigInt>, y: sql_types::BigInt) -> sql_types::BigInt);
 
-impl PostView {
-  pub async fn read(
-    pool: &DbPool,
-    post_id: PostId,
-    my_person_id: Option<PersonId>,
-  ) -> Result<Self, Error> {
-    let conn = &mut get_conn(pool).await?;
-
+fn queries<'a>() -> Queries<
+  impl ReadFn<'a, PostView, (PostId, Option<PersonId>, Option<bool>)>,
+  impl ListFn<'a, PostView, PostQuery<'a>>,
+> {
+  let all_joins = |query: post_aggregates::BoxedQuery<'a, Pg>, my_person_id: Option<PersonId>| {
     // 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
-      .find(post_id)
+
+    query
       .inner_join(person::table)
       .inner_join(community::table)
       .left_join(
         community_person_ban::table.on(
-          post::community_id
+          post_aggregates::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_aggregates::creator_id)),
         ),
       )
-      .inner_join(post_aggregates::table)
+      .inner_join(post::table)
       .left_join(
         community_follower::table.on(
-          post::community_id
+          post_aggregates::community_id
             .eq(community_follower::community_id)
             .and(community_follower::person_id.eq(person_id_join)),
         ),
       )
+      .left_join(
+        community_moderator::table.on(
+          post::community_id
+            .eq(community_moderator::community_id)
+            .and(community_moderator::person_id.eq(person_id_join)),
+        ),
+      )
       .left_join(
         post_saved::table.on(
-          post::id
+          post_aggregates::post_id
             .eq(post_saved::post_id)
             .and(post_saved::person_id.eq(person_id_join)),
         ),
       )
       .left_join(
         post_read::table.on(
-          post::id
+          post_aggregates::post_id
             .eq(post_read::post_id)
             .and(post_read::person_id.eq(person_id_join)),
         ),
       )
       .left_join(
         person_block::table.on(
-          post::creator_id
+          post_aggregates::creator_id
             .eq(person_block::target_id)
             .and(person_block::person_id.eq(person_id_join)),
         ),
       )
       .left_join(
         post_like::table.on(
-          post::id
+          post_aggregates::post_id
             .eq(post_like::post_id)
             .and(post_like::person_id.eq(person_id_join)),
         ),
       )
       .left_join(
         person_post_aggregates::table.on(
-          post::id
+          post_aggregates::post_id
             .eq(person_post_aggregates::post_id)
             .and(person_post_aggregates::person_id.eq(person_id_join)),
         ),
       )
-      .select((
-        post::all_columns,
-        Person::safe_columns_tuple(),
-        Community::safe_columns_tuple(),
-        community_person_ban::all_columns.nullable(),
-        post_aggregates::all_columns,
-        community_follower::all_columns.nullable(),
-        post_saved::all_columns.nullable(),
-        post_read::all_columns.nullable(),
-        person_block::all_columns.nullable(),
-        post_like::score.nullable(),
-        coalesce(
-          post_aggregates::comments.nullable() - person_post_aggregates::read_comments.nullable(),
-          post_aggregates::comments,
-        ),
-      ))
-      .first::<PostViewTuple>(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
-    let my_vote = if my_person_id.is_some() && post_like.is_none() {
-      Some(0)
-    } else {
-      post_like
-    };
+  let selection = (
+    post::all_columns,
+    person::all_columns,
+    community::all_columns,
+    community_person_ban::id.nullable().is_not_null(),
+    post_aggregates::all_columns,
+    CommunityFollower::select_subscribed_type(),
+    post_saved::id.nullable().is_not_null(),
+    post_read::id.nullable().is_not_null(),
+    person_block::id.nullable().is_not_null(),
+    post_like::score.nullable(),
+    coalesce(
+      post_aggregates::comments.nullable() - person_post_aggregates::read_comments.nullable(),
+      post_aggregates::comments,
+    ),
+  );
+
+  let read = move |mut conn: DbConn<'a>,
+                   (post_id, my_person_id, is_mod_or_admin): (
+    PostId,
+    Option<PersonId>,
+    Option<bool>,
+  )| async move {
+    // The left join below will return None in this case
+    let person_id_join = my_person_id.unwrap_or(PersonId(-1));
 
-    Ok(PostView {
-      post,
-      creator,
-      community,
-      creator_banned_from_community: creator_banned_from_community.is_some(),
-      counts,
-      subscribed: CommunityFollower::to_subscribed_type(&follower),
-      saved: saved.is_some(),
-      read: read.is_some(),
-      creator_blocked: creator_blocked.is_some(),
-      my_vote,
-      unread_comments,
-    })
-  }
-}
+    let mut query = all_joins(
+      post_aggregates::table
+        .filter(post_aggregates::post_id.eq(post_id))
+        .into_boxed(),
+      my_person_id,
+    )
+    .select(selection);
 
-#[derive(TypedBuilder)]
-#[builder(field_defaults(default))]
-pub struct PostQuery<'a> {
-  #[builder(!default)]
-  pool: &'a DbPool,
-  listing_type: Option<ListingType>,
-  sort: Option<SortType>,
-  creator_id: Option<PersonId>,
-  community_id: Option<CommunityId>,
-  community_actor_id: Option<DbUrl>,
-  local_user: Option<&'a LocalUser>,
-  search_term: Option<String>,
-  url_search: Option<String>,
-  saved_only: Option<bool>,
-  page: Option<i64>,
-  limit: Option<i64>,
-}
+    // 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)),
+        );
+    }
 
-impl<'a> PostQuery<'a> {
-  pub async fn list(self) -> Result<Vec<PostView>, Error> {
-    let conn = &mut get_conn(self.pool).await?;
+    query.first::<PostViewTuple>(&mut conn).await
+  };
+
+  let list = move |mut conn: DbConn<'a>, options: PostQuery<'a>| async move {
+    let person_id = options.local_user.map(|l| l.person.id);
+    let local_user_id = options.local_user.map(|l| l.local_user.id);
 
     // 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 = person_id.unwrap_or(PersonId(-1));
+    let local_user_id_join = local_user_id.unwrap_or(LocalUserId(-1));
 
-    let mut query = post::table
-      .inner_join(person::table)
-      .inner_join(community::table)
-      .left_join(
-        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)),
-            ),
-        ),
-      )
-      .inner_join(post_aggregates::table)
-      .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(
-        post_saved::table.on(
-          post::id
-            .eq(post_saved::post_id)
-            .and(post_saved::person_id.eq(person_id_join)),
-        ),
-      )
-      .left_join(
-        post_read::table.on(
-          post::id
-            .eq(post_read::post_id)
-            .and(post_read::person_id.eq(person_id_join)),
-        ),
-      )
-      .left_join(
-        person_block::table.on(
-          post::creator_id
-            .eq(person_block::target_id)
-            .and(person_block::person_id.eq(person_id_join)),
-        ),
-      )
+    let mut query = all_joins(post_aggregates::table.into_boxed(), person_id)
       .left_join(
         community_block::table.on(
-          community::id
+          post_aggregates::community_id
             .eq(community_block::community_id)
             .and(community_block::person_id.eq(person_id_join)),
         ),
       )
-      .left_join(
-        post_like::table.on(
-          post::id
-            .eq(post_like::post_id)
-            .and(post_like::person_id.eq(person_id_join)),
-        ),
-      )
-      .left_join(
-        person_post_aggregates::table.on(
-          post::id
-            .eq(person_post_aggregates::post_id)
-            .and(person_post_aggregates::person_id.eq(person_id_join)),
-        ),
-      )
       .left_join(
         local_user_language::table.on(
           post::language_id
@@ -285,29 +210,39 @@ impl<'a> PostQuery<'a> {
             .and(local_user_language::local_user_id.eq(local_user_id_join)),
         ),
       )
-      .select((
-        post::all_columns,
-        Person::safe_columns_tuple(),
-        Community::safe_columns_tuple(),
-        community_person_ban::all_columns.nullable(),
-        post_aggregates::all_columns,
-        community_follower::all_columns.nullable(),
-        post_saved::all_columns.nullable(),
-        post_read::all_columns.nullable(),
-        person_block::all_columns.nullable(),
-        post_like::score.nullable(),
-        coalesce(
-          post_aggregates::comments.nullable() - person_post_aggregates::read_comments.nullable(),
-          post_aggregates::comments,
-        ),
-      ))
-      .into_boxed();
+      .select(selection);
+
+    let is_creator = options.creator_id == options.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 = options.local_user.map(|l| l.person.admin).unwrap_or(false);
+    // only show removed posts to admin when viewing user profile
+    if !(options.is_profile_view && is_admin) {
+      query = query
+        .filter(community::removed.eq(false))
+        .filter(post::removed.eq(false));
+    }
 
-    if let Some(listing_type) = self.listing_type {
+    if options.community_id.is_none() {
+      query = query.then_order_by(post_aggregates::featured_local.desc());
+    } else if let Some(community_id) = options.community_id {
+      query = query
+        .filter(post_aggregates::community_id.eq(community_id))
+        .then_order_by(post_aggregates::featured_community.desc());
+    }
+
+    if let Some(creator_id) = options.creator_id {
+      query = query.filter(post_aggregates::creator_id.eq(creator_id));
+    }
+
+    if let Some(listing_type) = options.listing_type {
       match listing_type {
-        ListingType::Subscribed => {
-          query = query.filter(community_follower::person_id.is_not_null())
-        }
+        ListingType::Subscribed => query = query.filter(community_follower::pending.is_not_null()),
         ListingType::Local => {
           query = query.filter(community::local.eq(true)).filter(
             community::hidden
@@ -324,23 +259,12 @@ 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 {
+    if let Some(url_search) = options.url_search {
       query = query.filter(post::url.eq(url_search));
     }
 
-    if let Some(search_term) = self.search_term {
+    if let Some(search_term) = options.search_term {
       let searcher = fuzzy_search(&search_term);
       query = query.filter(
         post::name
@@ -349,52 +273,69 @@ 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 !options
+      .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 !options
+      .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::post_id.is_not_null());
+    if options.saved_only.unwrap_or(false) {
+      query = query.filter(post_saved::id.is_not_null());
+    }
+
+    if options.moderator_view.unwrap_or(false) {
+      query = query.filter(community_moderator::person_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::post_id.is_null());
+    else if !options
+      .local_user
+      .map(|l| l.local_user.show_read_posts)
+      .unwrap_or(true)
+    {
+      // Do not hide read posts when it is a user profile view
+      if !options.is_profile_view {
+        query = query.filter(post_read::post_id.is_null());
+      }
     }
 
-    if self.local_user.is_some() {
+    if options.liked_only.unwrap_or_default() {
+      query = query.filter(post_like::score.eq(1));
+    } else if options.disliked_only.unwrap_or_default() {
+      query = query.filter(post_like::score.eq(-1));
+    }
+
+    if options.local_user.is_some() {
       // Filter out the rows with missing languages
       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());
-      query = query.filter(person_block::person_id.is_null());
+      if !options.moderator_view.unwrap_or(false) {
+        query = query.filter(person_block::person_id.is_null());
+      }
     }
 
-    query = match self.sort.unwrap_or(SortType::Hot) {
+    query = match options.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::Controversial => query.then_order_by(post_aggregates::controversy_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,65 +361,131 @@ 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)?;
+    let (limit, offset) = limit_and_offset(options.page, options.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::<Pg, _>(&query));
 
-    let res = query.load::<PostViewTuple>(conn).await?;
+    query.load::<PostViewTuple>(&mut conn).await
+  };
+
+  Queries::new(read, list)
+}
+
+impl PostView {
+  pub async fn read(
+    pool: &mut DbPool<'_>,
+    post_id: PostId,
+    my_person_id: Option<PersonId>,
+    is_mod_or_admin: Option<bool>,
+  ) -> Result<Self, Error> {
+    let mut res = queries()
+      .read(pool, (post_id, my_person_id, is_mod_or_admin))
+      .await?;
 
-    Ok(PostView::from_tuple_to_vec(res))
+    // If a person is given, then my_vote, if None, should be 0, not null
+    // Necessary to differentiate between other person's votes
+    if my_person_id.is_some() && res.my_vote.is_none() {
+      res.my_vote = Some(0)
+    };
+
+    Ok(res)
   }
 }
 
-impl ViewToVec for PostView {
-  type DbTuple = PostViewTuple;
-  fn from_tuple_to_vec(items: Vec<Self::DbTuple>) -> Vec<Self> {
-    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::<Vec<Self>>()
+#[derive(Default)]
+pub struct PostQuery<'a> {
+  pub listing_type: Option<ListingType>,
+  pub sort: Option<SortType>,
+  pub creator_id: Option<PersonId>,
+  pub community_id: Option<CommunityId>,
+  pub local_user: Option<&'a LocalUserView>,
+  pub search_term: Option<String>,
+  pub url_search: Option<String>,
+  pub saved_only: Option<bool>,
+  pub liked_only: Option<bool>,
+  pub disliked_only: Option<bool>,
+  pub moderator_view: Option<bool>,
+  pub is_profile_view: bool,
+  pub page: Option<i64>,
+  pub limit: Option<i64>,
+}
+
+impl<'a> PostQuery<'a> {
+  pub async fn list(self, pool: &mut DbPool<'_>) -> Result<Vec<PostView>, Error> {
+    queries().list(pool, self).await
+  }
+}
+
+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,
+      counts: a.4,
+      subscribed: a.5,
+      saved: a.6,
+      read: a.7,
+      creator_blocked: a.8,
+      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},
@@ -489,16 +496,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();
 
@@ -577,11 +585,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,
@@ -593,30 +605,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;
 
@@ -634,19 +652,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());
 
@@ -657,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;
 
@@ -693,23 +714,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());
 
@@ -723,11 +745,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,
     };
 
@@ -736,15 +759,75 @@ 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 read_liked_post_listing = PostQuery {
+      community_id: (Some(data.inserted_community.id)),
+      local_user: (Some(&data.local_user_view)),
+      liked_only: (Some(true)),
+      ..Default::default()
+    }
+    .list(pool)
+    .await
+    .unwrap();
+    assert_eq!(read_post_listing, read_liked_post_listing);
+
+    let read_disliked_post_listing = PostQuery {
+      community_id: (Some(data.inserted_community.id)),
+      local_user: (Some(&data.local_user_view)),
+      disliked_only: (Some(true)),
+      ..Default::default()
+    }
+    .list(pool)
+    .await
+    .unwrap();
+    assert!(read_disliked_post_listing.is_empty());
+
+    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;
   }
@@ -753,6 +836,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"))
@@ -761,21 +845,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());
@@ -784,38 +868,40 @@ 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));
 
     LocalUserLanguage::update(
       pool,
       vec![french_id, UNDETERMINED_ID],
-      data.inserted_local_user.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());
@@ -828,12 +914,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: 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
@@ -844,9 +1023,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,
     );
@@ -878,7 +1057,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,
@@ -898,9 +1077,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,
@@ -917,6 +1099,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,
@@ -930,6 +1120,11 @@ mod tests {
         newest_comment_time: inserted_post.published,
         featured_community: false,
         featured_local: false,
+        hot_rank: 1728,
+        hot_rank_active: 1728,
+        controversy_rank: 0.0,
+        community_id: inserted_post.community_id,
+        creator_id: inserted_post.creator_id,
       },
       subscribed: SubscribedType::NotSubscribed,
       read: false,