]> Untitled Git - lemmy.git/blobdiff - crates/db_views/src/post_view.rs
Adding temporary bans. Fixes #1423 (#1999)
[lemmy.git] / crates / db_views / src / post_view.rs
index fe852e3767b4a1266a974290856013ffc92a1008..14138374a146f837f623eb5ed11214c4df54c086 100644 (file)
@@ -1,21 +1,17 @@
-use diesel::{pg::Pg, result::Error, *};
-use lemmy_db_queries::{
+use diesel::{dsl::*, pg::Pg, result::Error, *};
+use lemmy_db_schema::{
   aggregates::post_aggregates::PostAggregates,
   functions::hot_rank,
   fuzzy_search,
   limit_and_offset,
-  ListingType,
-  MaybeOptional,
-  SortType,
-  ToSafe,
-  ViewToVec,
-};
-use lemmy_db_schema::{
+  newtypes::{CommunityId, DbUrl, PersonId, PostId},
   schema::{
     community,
+    community_block,
     community_follower,
     community_person_ban,
     person,
+    person_block,
     post,
     post_aggregates,
     post_like,
@@ -25,26 +21,28 @@ use lemmy_db_schema::{
   source::{
     community::{Community, CommunityFollower, CommunityPersonBan, CommunitySafe},
     person::{Person, PersonSafe},
+    person_block::PersonBlock,
     post::{Post, PostRead, PostSaved},
   },
-  CommunityId,
-  PersonId,
-  PostId,
+  traits::{MaybeOptional, ToSafe, ViewToVec},
+  ListingType,
+  SortType,
 };
-use log::debug;
-use serde::Serialize;
+use serde::{Deserialize, Serialize};
+use tracing::debug;
 
-#[derive(Debug, PartialEq, Serialize, Clone)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
 pub struct PostView {
   pub post: Post,
   pub creator: PersonSafe,
   pub community: CommunitySafe,
   pub creator_banned_from_community: bool, // Left Join to CommunityPersonBan
   pub counts: PostAggregates,
-  pub subscribed: bool,     // Left join to CommunityFollower
-  pub saved: bool,          // Left join to PostSaved
-  pub read: bool,           // Left join to PostRead
-  pub my_vote: Option<i16>, // Left join to PostLike
+  pub subscribed: bool,      // Left join to CommunityFollower
+  pub saved: bool,           // Left join to PostSaved
+  pub read: bool,            // Left join to PostRead
+  pub creator_blocked: bool, // Left join to PersonBlock
+  pub my_vote: Option<i16>,  // Left join to PostLike
 }
 
 type PostViewTuple = (
@@ -56,6 +54,7 @@ type PostViewTuple = (
   Option<CommunityFollower>,
   Option<PostSaved>,
   Option<PostRead>,
+  Option<PersonBlock>,
   Option<i16>,
 );
 
@@ -77,6 +76,7 @@ impl PostView {
       follower,
       saved,
       read,
+      creator_blocked,
       post_like,
     ) = post::table
       .find(post_id)
@@ -86,7 +86,12 @@ 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::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)
@@ -111,6 +116,13 @@ impl PostView {
             .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)),
+        ),
+      )
       .left_join(
         post_like::table.on(
           post::id
@@ -127,6 +139,7 @@ impl PostView {
         community_follower::all_columns.nullable(),
         post_saved::all_columns.nullable(),
         post_read::all_columns.nullable(),
+        person_block::all_columns.nullable(),
         post_like::score.nullable(),
       ))
       .first::<PostViewTuple>(conn)?;
@@ -148,6 +161,7 @@ impl PostView {
       subscribed: follower.is_some(),
       saved: saved.is_some(),
       read: read.is_some(),
+      creator_blocked: creator_blocked.is_some(),
       my_vote,
     })
   }
@@ -155,17 +169,18 @@ impl PostView {
 
 pub struct PostQueryBuilder<'a> {
   conn: &'a PgConnection,
-  listing_type: &'a ListingType,
-  sort: &'a SortType,
+  listing_type: Option<ListingType>,
+  sort: Option<SortType>,
   creator_id: Option<PersonId>,
   community_id: Option<CommunityId>,
-  community_name: Option<String>,
+  community_actor_id: Option<DbUrl>,
   my_person_id: Option<PersonId>,
   search_term: Option<String>,
   url_search: Option<String>,
-  show_nsfw: bool,
-  saved_only: bool,
-  unread_only: bool,
+  show_nsfw: Option<bool>,
+  show_bot_accounts: Option<bool>,
+  show_read_posts: Option<bool>,
+  saved_only: Option<bool>,
   page: Option<i64>,
   limit: Option<i64>,
 }
@@ -174,29 +189,30 @@ impl<'a> PostQueryBuilder<'a> {
   pub fn create(conn: &'a PgConnection) -> Self {
     PostQueryBuilder {
       conn,
-      listing_type: &ListingType::All,
-      sort: &SortType::Hot,
+      listing_type: None,
+      sort: None,
       creator_id: None,
       community_id: None,
-      community_name: None,
+      community_actor_id: None,
       my_person_id: None,
       search_term: None,
       url_search: None,
-      show_nsfw: true,
-      saved_only: false,
-      unread_only: false,
+      show_nsfw: None,
+      show_bot_accounts: None,
+      show_read_posts: None,
+      saved_only: None,
       page: None,
       limit: None,
     }
   }
 
-  pub fn listing_type(mut self, listing_type: &'a ListingType) -> Self {
-    self.listing_type = listing_type;
+  pub fn listing_type<T: MaybeOptional<ListingType>>(mut self, listing_type: T) -> Self {
+    self.listing_type = listing_type.get_optional();
     self
   }
 
-  pub fn sort(mut self, sort: &'a SortType) -> Self {
-    self.sort = sort;
+  pub fn sort<T: MaybeOptional<SortType>>(mut self, sort: T) -> Self {
+    self.sort = sort.get_optional();
     self
   }
 
@@ -210,8 +226,8 @@ impl<'a> PostQueryBuilder<'a> {
     self
   }
 
-  pub fn community_name<T: MaybeOptional<String>>(mut self, community_name: T) -> Self {
-    self.community_name = community_name.get_optional();
+  pub fn community_actor_id<T: MaybeOptional<DbUrl>>(mut self, community_actor_id: T) -> Self {
+    self.community_actor_id = community_actor_id.get_optional();
     self
   }
 
@@ -230,13 +246,23 @@ impl<'a> PostQueryBuilder<'a> {
     self
   }
 
-  pub fn show_nsfw(mut self, show_nsfw: bool) -> Self {
-    self.show_nsfw = show_nsfw;
+  pub fn show_nsfw<T: MaybeOptional<bool>>(mut self, show_nsfw: T) -> Self {
+    self.show_nsfw = show_nsfw.get_optional();
+    self
+  }
+
+  pub fn show_bot_accounts<T: MaybeOptional<bool>>(mut self, show_bot_accounts: T) -> Self {
+    self.show_bot_accounts = show_bot_accounts.get_optional();
     self
   }
 
-  pub fn saved_only(mut self, saved_only: bool) -> Self {
-    self.saved_only = saved_only;
+  pub fn show_read_posts<T: MaybeOptional<bool>>(mut self, show_read_posts: T) -> Self {
+    self.show_read_posts = show_read_posts.get_optional();
+    self
+  }
+
+  pub fn saved_only<T: MaybeOptional<bool>>(mut self, saved_only: T) -> Self {
+    self.saved_only = saved_only.get_optional();
     self
   }
 
@@ -263,7 +289,12 @@ impl<'a> PostQueryBuilder<'a> {
         community_person_ban::table.on(
           post::community_id
             .eq(community_person_ban::community_id)
-            .and(community_person_ban::person_id.eq(community::creator_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)
@@ -288,6 +319,20 @@ impl<'a> PostQueryBuilder<'a> {
             .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)),
+        ),
+      )
+      .left_join(
+        community_block::table.on(
+          community::id
+            .eq(community_block::community_id)
+            .and(community_block::person_id.eq(person_id_join)),
+        ),
+      )
       .left_join(
         post_like::table.on(
           post::id
@@ -304,15 +349,18 @@ impl<'a> PostQueryBuilder<'a> {
         community_follower::all_columns.nullable(),
         post_saved::all_columns.nullable(),
         post_read::all_columns.nullable(),
+        person_block::all_columns.nullable(),
         post_like::score.nullable(),
       ))
       .into_boxed();
 
-    query = match self.listing_type {
-      ListingType::Subscribed => query.filter(community_follower::person_id.is_not_null()), // TODO could be this: and(community_follower::person_id.eq(person_id_join)),
-      ListingType::Local => query.filter(community::local.eq(true)),
-      _ => query,
-    };
+    if let Some(listing_type) = self.listing_type {
+      query = match listing_type {
+        ListingType::Subscribed => query.filter(community_follower::person_id.is_not_null()),
+        ListingType::Local => query.filter(community::local.eq(true)),
+        _ => query,
+      };
+    }
 
     if let Some(community_id) = self.community_id {
       query = query
@@ -320,10 +368,9 @@ impl<'a> PostQueryBuilder<'a> {
         .then_order_by(post_aggregates::stickied.desc());
     }
 
-    if let Some(community_name) = self.community_name {
+    if let Some(community_actor_id) = self.community_actor_id {
       query = query
-        .filter(community::name.eq(community_name))
-        .filter(community::local.eq(true))
+        .filter(community::actor_id.eq(community_actor_id))
         .then_order_by(post_aggregates::stickied.desc());
     }
 
@@ -345,22 +392,32 @@ impl<'a> PostQueryBuilder<'a> {
       query = query.filter(post::creator_id.eq(creator_id));
     }
 
-    if !self.show_nsfw {
+    if !self.show_nsfw.unwrap_or(false) {
       query = query
         .filter(post::nsfw.eq(false))
         .filter(community::nsfw.eq(false));
     };
 
-    // TODO  These two might be wrong
-    if self.saved_only {
-      query = query.filter(post_saved::id.is_not_null());
+    if !self.show_bot_accounts.unwrap_or(true) {
+      query = query.filter(person::bot_account.eq(false));
     };
 
-    if self.unread_only {
-      query = query.filter(post_read::id.is_not_null());
-    };
+    if self.saved_only.unwrap_or(false) {
+      query = query.filter(post_saved::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.show_read_posts.unwrap_or(true) {
+      query = query.filter(post_read::id.is_null());
+    }
 
-    query = match self.sort {
+    // Don't show blocked communities or persons
+    if self.my_person_id.is_some() {
+      query = query.filter(community_block::person_id.is_null());
+      query = query.filter(person_block::person_id.is_null());
+    }
+
+    query = match self.sort.unwrap_or(SortType::Hot) {
       SortType::Active => query
         .then_order_by(
           hot_rank(
@@ -423,7 +480,8 @@ impl ViewToVec for PostView {
         subscribed: a.5.is_some(),
         saved: a.6.is_some(),
         read: a.7.is_some(),
-        my_vote: a.8,
+        creator_blocked: a.8.is_some(),
+        my_vote: a.9,
       })
       .collect::<Vec<Self>>()
   }
@@ -432,15 +490,20 @@ impl ViewToVec for PostView {
 #[cfg(test)]
 mod tests {
   use crate::post_view::{PostQueryBuilder, PostView};
-  use lemmy_db_queries::{
+  use lemmy_db_schema::{
     aggregates::post_aggregates::PostAggregates,
     establish_unpooled_connection,
-    Crud,
-    Likeable,
+    source::{
+      community::*,
+      community_block::{CommunityBlock, CommunityBlockForm},
+      person::*,
+      person_block::{PersonBlock, PersonBlockForm},
+      post::*,
+    },
+    traits::{Blockable, Crud, Likeable},
     ListingType,
     SortType,
   };
-  use lemmy_db_schema::source::{community::*, person::*, post::*};
   use serial_test::serial;
 
   #[test]
@@ -451,75 +514,75 @@ mod tests {
     let person_name = "tegan".to_string();
     let community_name = "test_community_3".to_string();
     let post_name = "test post 3".to_string();
+    let bot_post_name = "test bot post".to_string();
 
     let new_person = PersonForm {
       name: person_name.to_owned(),
-      preferred_username: None,
-      avatar: None,
-      banner: None,
-      banned: None,
-      deleted: None,
-      published: None,
-      updated: None,
-      actor_id: None,
-      bio: None,
-      local: None,
-      private_key: None,
-      public_key: None,
-      last_refreshed_at: None,
-      inbox_url: None,
-      shared_inbox_url: None,
+      ..PersonForm::default()
     };
 
     let inserted_person = Person::create(&conn, &new_person).unwrap();
 
+    let new_bot = PersonForm {
+      name: person_name.to_owned(),
+      bot_account: Some(true),
+      ..PersonForm::default()
+    };
+
+    let inserted_bot = Person::create(&conn, &new_bot).unwrap();
+
     let new_community = CommunityForm {
       name: community_name.to_owned(),
       title: "nada".to_owned(),
-      description: None,
-      creator_id: inserted_person.id,
-      removed: None,
-      deleted: None,
-      updated: None,
-      nsfw: false,
-      actor_id: None,
-      local: true,
-      private_key: None,
-      public_key: None,
-      last_refreshed_at: None,
-      published: None,
-      icon: None,
-      banner: None,
-      followers_url: None,
-      inbox_url: None,
-      shared_inbox_url: None,
+      ..CommunityForm::default()
     };
 
     let inserted_community = Community::create(&conn, &new_community).unwrap();
 
+    // Test a person block, make sure the post query doesn't include their post
+    let blocked_person = PersonForm {
+      name: person_name.to_owned(),
+      ..PersonForm::default()
+    };
+
+    let inserted_blocked_person = Person::create(&conn, &blocked_person).unwrap();
+
+    let post_from_blocked_person = PostForm {
+      name: "blocked_person_post".to_string(),
+      creator_id: inserted_blocked_person.id,
+      community_id: inserted_community.id,
+      ..PostForm::default()
+    };
+
+    Post::create(&conn, &post_from_blocked_person).unwrap();
+
+    // block that person
+    let person_block = PersonBlockForm {
+      person_id: inserted_person.id,
+      target_id: inserted_blocked_person.id,
+    };
+
+    PersonBlock::block(&conn, &person_block).unwrap();
+
+    // A sample post
     let new_post = PostForm {
       name: post_name.to_owned(),
-      url: None,
-      body: None,
       creator_id: inserted_person.id,
       community_id: inserted_community.id,
-      removed: None,
-      deleted: None,
-      locked: None,
-      stickied: None,
-      updated: None,
-      nsfw: false,
-      embed_title: None,
-      embed_description: None,
-      embed_html: None,
-      thumbnail_url: None,
-      ap_id: None,
-      local: true,
-      published: None,
+      ..PostForm::default()
     };
 
     let inserted_post = Post::create(&conn, &new_post).unwrap();
 
+    let new_bot_post = PostForm {
+      name: bot_post_name,
+      creator_id: inserted_bot.id,
+      community_id: inserted_community.id,
+      ..PostForm::default()
+    };
+
+    let _inserted_bot_post = Post::create(&conn, &new_bot_post).unwrap();
+
     let post_like_form = PostLikeForm {
       post_id: inserted_post.id,
       person_id: inserted_person.id,
@@ -537,16 +600,17 @@ mod tests {
     };
 
     let read_post_listings_with_person = PostQueryBuilder::create(&conn)
-      .listing_type(&ListingType::Community)
-      .sort(&SortType::New)
+      .listing_type(ListingType::Community)
+      .sort(SortType::New)
+      .show_bot_accounts(false)
       .community_id(inserted_community.id)
       .my_person_id(inserted_person.id)
       .list()
       .unwrap();
 
     let read_post_listings_no_person = PostQueryBuilder::create(&conn)
-      .listing_type(&ListingType::Community)
-      .sort(&SortType::New)
+      .listing_type(ListingType::Community)
+      .sort(SortType::New)
       .community_id(inserted_community.id)
       .list()
       .unwrap();
@@ -584,11 +648,13 @@ mod tests {
       creator: PersonSafe {
         id: inserted_person.id,
         name: person_name,
-        preferred_username: None,
+        display_name: None,
         published: inserted_person.published,
         avatar: None,
         actor_id: inserted_person.actor_id.to_owned(),
         local: true,
+        admin: false,
+        bot_account: false,
         banned: false,
         deleted: false,
         bio: None,
@@ -596,6 +662,8 @@ mod tests {
         updated: None,
         inbox_url: inserted_person.inbox_url.to_owned(),
         shared_inbox_url: None,
+        matrix_user_id: None,
+        ban_expires: None,
       },
       creator_banned_from_community: false,
       community: CommunitySafe {
@@ -609,7 +677,6 @@ mod tests {
         local: true,
         title: "nada".to_owned(),
         description: None,
-        creator_id: inserted_person.id,
         updated: None,
         banner: None,
         published: inserted_community.published,
@@ -629,7 +696,24 @@ mod tests {
       subscribed: false,
       read: false,
       saved: false,
+      creator_blocked: false,
+    };
+
+    // Test a community block
+    let community_block = CommunityBlockForm {
+      person_id: inserted_person.id,
+      community_id: inserted_community.id,
     };
+    CommunityBlock::block(&conn, &community_block).unwrap();
+
+    let read_post_listings_with_person_after_block = PostQueryBuilder::create(&conn)
+      .listing_type(ListingType::Community)
+      .sort(SortType::New)
+      .show_bot_accounts(false)
+      .community_id(inserted_community.id)
+      .my_person_id(inserted_person.id)
+      .list()
+      .unwrap();
 
     // TODO More needs to be added here
     let mut expected_post_listing_with_user = expected_post_listing_no_person.to_owned();
@@ -637,8 +721,12 @@ mod tests {
 
     let like_removed = PostLike::remove(&conn, inserted_person.id, inserted_post.id).unwrap();
     let num_deleted = Post::delete(&conn, inserted_post.id).unwrap();
+    PersonBlock::unblock(&conn, &person_block).unwrap();
+    CommunityBlock::unblock(&conn, &community_block).unwrap();
     Community::delete(&conn, inserted_community.id).unwrap();
     Person::delete(&conn, inserted_person.id).unwrap();
+    Person::delete(&conn, inserted_bot.id).unwrap();
+    Person::delete(&conn, inserted_blocked_person.id).unwrap();
 
     // The with user
     assert_eq!(
@@ -649,18 +737,23 @@ mod tests {
       expected_post_listing_with_user,
       read_post_listing_with_person
     );
+
+    // Should be only one person, IE the bot post, and blocked should be missing
     assert_eq!(1, read_post_listings_with_person.len());
 
     // Without the user
     assert_eq!(
       expected_post_listing_no_person,
-      read_post_listings_no_person[0]
+      read_post_listings_no_person[1]
     );
     assert_eq!(expected_post_listing_no_person, read_post_listing_no_person);
-    assert_eq!(1, read_post_listings_no_person.len());
 
-    // assert_eq!(expected_post, inserted_post);
-    // assert_eq!(expected_post, updated_post);
+    // Should be 2 posts, with the bot post, and the blocked
+    assert_eq!(3, read_post_listings_no_person.len());
+
+    // Should be 0 posts after the community block
+    assert_eq!(0, read_post_listings_with_person_after_block.len());
+
     assert_eq!(expected_post_like, inserted_post_like);
     assert_eq!(1, like_removed);
     assert_eq!(1, num_deleted);