Adding temporary bans. Fixes #1423 (#1999)

[lemmy.git] / crates / db_views_actor / src / person_view.rs

diff --git a/crates/db_views_actor/src/person_view.rs b/crates/db_views_actor/src/person_view.rs
index ff936d6de5d5e05afb94faf9f02f93d568e5e8fe..d4be058544cbe727eed6cee6ba346500423bdf5b 100644 (file)
--- a/crates/db_views_actor/src/person_view.rs
+++ b/crates/db_views_actor/src/person_view.rs
@@ -1,20 +1,17 @@
 use diesel::{dsl::*, result::Error, *};
-use lemmy_db_queries::{
+use lemmy_db_schema::{
   aggregates::person_aggregates::PersonAggregates,
   fuzzy_search,
   limit_and_offset,
-  MaybeOptional,
+  newtypes::PersonId,
+  schema::{person, person_aggregates},
+  source::person::{Person, PersonSafe},
+  traits::{MaybeOptional, ToSafe, ViewToVec},
   SortType,
-  ToSafe,
-  ViewToVec,
-};
-use lemmy_db_schema::{
-  schema::{person, person_aggregates, local_user},
-  source::person::{PersonSafe, Person},
 };
-use serde::Serialize;
+use serde::{Deserialize, Serialize};
 
-#[derive(Debug, Serialize, Clone)]
+#[derive(Debug, Serialize, Deserialize, Clone)]
 pub struct PersonViewSafe {
   pub person: PersonSafe,
   pub counts: PersonAggregates,
@@ -23,9 +20,9 @@ pub struct PersonViewSafe {
 type PersonViewSafeTuple = (PersonSafe, PersonAggregates);
 
 impl PersonViewSafe {
-  pub fn read(conn: &PgConnection, id: i32) -> Result<Self, Error> {
+  pub fn read(conn: &PgConnection, person_id: PersonId) -> Result<Self, Error> {
     let (person, counts) = person::table
-      .find(id)
+      .find(person_id)
       .inner_join(person_aggregates::table)
       .select((Person::safe_columns_tuple(), person_aggregates::all_columns))
       .first::<PersonViewSafeTuple>(conn)?;
@@ -35,9 +32,8 @@ impl PersonViewSafe {
   pub fn admins(conn: &PgConnection) -> Result<Vec<Self>, Error> {
     let admins = person::table
       .inner_join(person_aggregates::table)
-      .inner_join(local_user::table)
       .select((Person::safe_columns_tuple(), person_aggregates::all_columns))
-      .filter(local_user::admin.eq(true))
+      .filter(person::admin.eq(true))
       .order_by(person::published)
       .load::<PersonViewSafeTuple>(conn)?;
 
@@ -48,7 +44,13 @@ impl PersonViewSafe {
     let banned = person::table
       .inner_join(person_aggregates::table)
       .select((Person::safe_columns_tuple(), person_aggregates::all_columns))
-      .filter(person::banned.eq(true))
+      .filter(
+        person::banned.eq(true).and(
+          person::ban_expires
+            .is_null()
+            .or(person::ban_expires.gt(now)),
+        ),
+      )
       .load::<PersonViewSafeTuple>(conn)?;
 
     Ok(Self::from_tuple_to_vec(banned))
@@ -57,7 +59,7 @@ impl PersonViewSafe {
 
 pub struct PersonQueryBuilder<'a> {
   conn: &'a PgConnection,
-  sort: &'a SortType,
+  sort: Option<SortType>,
   search_term: Option<String>,
   page: Option<i64>,
   limit: Option<i64>,
@@ -68,14 +70,14 @@ impl<'a> PersonQueryBuilder<'a> {
     PersonQueryBuilder {
       conn,
       search_term: None,
-      sort: &SortType::Hot,
+      sort: None,
       page: None,
       limit: None,
     }
   }
 
-  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
   }
 
@@ -104,7 +106,7 @@ impl<'a> PersonQueryBuilder<'a> {
       query = query.filter(person::name.ilike(fuzzy_search(&search_term)));
     }
 
-    query = match self.sort {
+    query = match self.sort.unwrap_or(SortType::Hot) {
       SortType::Hot => query
         .order_by(person_aggregates::comment_score.desc())
         .then_order_by(person::published.desc()),