Cache & Optimize Woodpecker CI (#3450)

[lemmy.git] / crates / db_views / src / post_view.rs

diff --git a/crates/db_views/src/post_view.rs b/crates/db_views/src/post_view.rs
index 14cf7fe1976e3832b2515d60839de9708997d339..0e6ad703cff9f3780fb60521033c383142787a9c 100644 (file)
--- a/crates/db_views/src/post_view.rs
+++ b/crates/db_views/src/post_view.rs
@@ -45,7 +45,6 @@ use lemmy_db_schema::{
   SortType,
 };
 use tracing::debug;
-use typed_builder::TypedBuilder;
 
 type PostViewTuple = (
   Post,
@@ -65,7 +64,7 @@ sql_function!(fn coalesce(x: sql_types::Nullable<sql_types::BigInt>, y: sql_type
 
 impl PostView {
   pub async fn read(
-    pool: &DbPool,
+    pool: &mut DbPool<'_>,
     post_id: PostId,
     my_person_id: Option<PersonId>,
     is_mod_or_admin: Option<bool>,
@@ -193,28 +192,25 @@ impl PostView {
   }
 }
 
-#[derive(TypedBuilder)]
-#[builder(field_defaults(default))]
+#[derive(Default)]
 pub struct PostQuery<'a> {
-  #[builder(!default)]
-  pool: &'a DbPool,
-  listing_type: Option<ListingType>,
-  sort: Option<SortType>,
-  creator_id: Option<PersonId>,
-  community_id: Option<CommunityId>,
-  local_user: Option<&'a LocalUser>,
-  search_term: Option<String>,
-  url_search: Option<String>,
-  saved_only: Option<bool>,
+  pub listing_type: Option<ListingType>,
+  pub sort: Option<SortType>,
+  pub creator_id: Option<PersonId>,
+  pub community_id: Option<CommunityId>,
+  pub local_user: Option<&'a LocalUser>,
+  pub search_term: Option<String>,
+  pub url_search: Option<String>,
+  pub saved_only: Option<bool>,
   /// Used to show deleted or removed posts for admins
-  is_mod_or_admin: Option<bool>,
-  page: Option<i64>,
-  limit: Option<i64>,
+  pub is_mod_or_admin: Option<bool>,
+  pub page: Option<i64>,
+  pub limit: Option<i64>,
 }
 
 impl<'a> PostQuery<'a> {
-  pub async fn list(self) -> Result<Vec<PostView>, Error> {
-    let conn = &mut get_conn(self.pool).await?;
+  pub async fn list(self, pool: &mut DbPool<'_>) -> Result<Vec<PostView>, 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));
@@ -430,6 +426,18 @@ impl<'a> PostQuery<'a> {
         .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)?;
@@ -465,6 +473,9 @@ impl JoinView for PostView {
 
 #[cfg(test)]
 mod tests {
+  #![allow(clippy::unwrap_used)]
+  #![allow(clippy::indexing_slicing)]
+
   use crate::post_view::{PostQuery, PostView};
   use lemmy_db_schema::{
     aggregates::structs::PostAggregates,
@@ -498,7 +509,7 @@ mod tests {
     inserted_post: Post,
   }
 
-  async fn init_data(pool: &DbPool) -> Data {
+  async fn init_data(pool: &mut DbPool<'_>) -> Data {
     let inserted_instance = Instance::read_or_create(pool, "my_domain.tld".to_string())
       .await
       .unwrap();
@@ -596,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()
@@ -606,15 +618,15 @@ mod tests {
         .await
         .unwrap();
 
-    let read_post_listing = PostQuery::builder()
-      .pool(pool)
-      .sort(Some(SortType::New))
-      .community_id(Some(data.inserted_community.id))
-      .local_user(Some(&inserted_local_user))
-      .build()
-      .list()
-      .await
-      .unwrap();
+    let read_post_listing = PostQuery {
+      sort: (Some(SortType::New)),
+      community_id: (Some(data.inserted_community.id)),
+      local_user: (Some(&inserted_local_user)),
+      ..Default::default()
+    }
+    .list(pool)
+    .await
+    .unwrap();
 
     let post_listing_single_with_person = PostView::read(
       pool,
@@ -645,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());
 
@@ -664,16 +676,17 @@ mod tests {
   #[serial]
   async fn post_listing_no_person() {
     let pool = &build_db_pool_for_tests().await;
+    let pool = &mut pool.into();
     let data = init_data(pool).await;
 
-    let read_post_listing_multiple_no_person = PostQuery::builder()
-      .pool(pool)
-      .sort(Some(SortType::New))
-      .community_id(Some(data.inserted_community.id))
-      .build()
-      .list()
-      .await
-      .unwrap();
+    let read_post_listing_multiple_no_person = PostQuery {
+      sort: (Some(SortType::New)),
+      community_id: (Some(data.inserted_community.id)),
+      ..Default::default()
+    }
+    .list(pool)
+    .await
+    .unwrap();
 
     let read_post_listing_single_no_person =
       PostView::read(pool, data.inserted_post.id, None, None)
@@ -701,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 {
@@ -709,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());
 
@@ -731,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 {
@@ -773,15 +788,15 @@ mod tests {
         .await
         .unwrap();
 
-    let read_post_listing = PostQuery::builder()
-      .pool(pool)
-      .sort(Some(SortType::New))
-      .community_id(Some(data.inserted_community.id))
-      .local_user(Some(&inserted_local_user))
-      .build()
-      .list()
-      .await
-      .unwrap();
+    let read_post_listing = PostQuery {
+      sort: (Some(SortType::New)),
+      community_id: (Some(data.inserted_community.id)),
+      local_user: (Some(&inserted_local_user)),
+      ..Default::default()
+    }
+    .list(pool)
+    .await
+    .unwrap();
     assert_eq!(1, read_post_listing.len());
 
     assert_eq!(expected_post_with_upvote, read_post_listing[0]);
@@ -797,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"))
@@ -812,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());
@@ -832,14 +848,14 @@ 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 post in french and one undetermined should be returned
     assert_eq!(2, post_listing_french.len());
@@ -854,14 +870,14 @@ mod tests {
     )
     .await
     .unwrap();
-    let post_listings_french_und = PostQuery::builder()
-      .pool(pool)
-      .sort(Some(SortType::New))
-      .local_user(Some(&data.inserted_local_user))
-      .build()
-      .list()
-      .await
-      .unwrap();
+    let post_listings_french_und = PostQuery {
+      sort: (Some(SortType::New)),
+      local_user: (Some(&data.inserted_local_user)),
+      ..Default::default()
+    }
+    .list(pool)
+    .await
+    .unwrap();
 
     // french post and undetermined language post should be returned
     assert_eq!(2, post_listings_french_und.len());
@@ -878,6 +894,7 @@ mod tests {
   #[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
@@ -890,35 +907,35 @@ mod tests {
     .unwrap();
 
     // Make sure you don't see the deleted post in the results
-    let post_listings_no_admin = PostQuery::builder()
-      .pool(pool)
-      .sort(Some(SortType::New))
-      .local_user(Some(&data.inserted_local_user))
-      .is_mod_or_admin(Some(false))
-      .build()
-      .list()
-      .await
-      .unwrap();
+    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::builder()
-      .pool(pool)
-      .sort(Some(SortType::New))
-      .local_user(Some(&data.inserted_local_user))
-      .is_mod_or_admin(Some(true))
-      .build()
-      .list()
-      .await
-      .unwrap();
+    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: &DbPool) {
+  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
@@ -934,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,