crates/db_views_actor/src/person_view.rs

   1 use crate::structs::PersonViewSafe;
   2 use diesel::{dsl::*, result::Error, *};
   3 use lemmy_db_schema::{
   4   aggregates::structs::PersonAggregates,
   5   newtypes::PersonId,
   6   schema::{person, person_aggregates},
   7   source::person::{Person, PersonSafe},
   8   traits::{MaybeOptional, ToSafe, ViewToVec},
   9   utils::{fuzzy_search, limit_and_offset},
  10   SortType,
  11 };
  12
  13 type PersonViewSafeTuple = (PersonSafe, PersonAggregates);
  14
  15 impl PersonViewSafe {
  16   pub fn read(conn: &PgConnection, person_id: PersonId) -> Result<Self, Error> {
  17     let (person, counts) = person::table
  18       .find(person_id)
  19       .inner_join(person_aggregates::table)
  20       .select((Person::safe_columns_tuple(), person_aggregates::all_columns))
  21       .first::<PersonViewSafeTuple>(conn)?;
  22     Ok(Self { person, counts })
  23   }
  24
  25   pub fn admins(conn: &PgConnection) -> Result<Vec<Self>, Error> {
  26     let admins = person::table
  27       .inner_join(person_aggregates::table)
  28       .select((Person::safe_columns_tuple(), person_aggregates::all_columns))
  29       .filter(person::admin.eq(true))
  30       .order_by(person::published)
  31       .load::<PersonViewSafeTuple>(conn)?;
  32
  33     Ok(Self::from_tuple_to_vec(admins))
  34   }
  35
  36   pub fn banned(conn: &PgConnection) -> Result<Vec<Self>, Error> {
  37     let banned = person::table
  38       .inner_join(person_aggregates::table)
  39       .select((Person::safe_columns_tuple(), person_aggregates::all_columns))
  40       .filter(
  41         person::banned.eq(true).and(
  42           person::ban_expires
  43             .is_null()
  44             .or(person::ban_expires.gt(now)),
  45         ),
  46       )
  47       .load::<PersonViewSafeTuple>(conn)?;
  48
  49     Ok(Self::from_tuple_to_vec(banned))
  50   }
  51 }
  52
  53 pub struct PersonQueryBuilder<'a> {
  54   conn: &'a PgConnection,
  55   sort: Option<SortType>,
  56   search_term: Option<String>,
  57   page: Option<i64>,
  58   limit: Option<i64>,
  59 }
  60
  61 impl<'a> PersonQueryBuilder<'a> {
  62   pub fn create(conn: &'a PgConnection) -> Self {
  63     PersonQueryBuilder {
  64       conn,
  65       search_term: None,
  66       sort: None,
  67       page: None,
  68       limit: None,
  69     }
  70   }
  71
  72   pub fn sort<T: MaybeOptional<SortType>>(mut self, sort: T) -> Self {
  73     self.sort = sort.get_optional();
  74     self
  75   }
  76
  77   pub fn search_term<T: MaybeOptional<String>>(mut self, search_term: T) -> Self {
  78     self.search_term = search_term.get_optional();
  79     self
  80   }
  81
  82   pub fn page<T: MaybeOptional<i64>>(mut self, page: T) -> Self {
  83     self.page = page.get_optional();
  84     self
  85   }
  86
  87   pub fn limit<T: MaybeOptional<i64>>(mut self, limit: T) -> Self {
  88     self.limit = limit.get_optional();
  89     self
  90   }
  91
  92   pub fn list(self) -> Result<Vec<PersonViewSafe>, Error> {
  93     let mut query = person::table
  94       .inner_join(person_aggregates::table)
  95       .select((Person::safe_columns_tuple(), person_aggregates::all_columns))
  96       .into_boxed();
  97
  98     if let Some(search_term) = self.search_term {
  99       query = query.filter(person::name.ilike(fuzzy_search(&search_term)));
 100     }
 101
 102     query = match self.sort.unwrap_or(SortType::Hot) {
 103       SortType::Hot => query
 104         .order_by(person_aggregates::comment_score.desc())
 105         .then_order_by(person::published.desc()),
 106       SortType::Active => query
 107         .order_by(person_aggregates::comment_score.desc())
 108         .then_order_by(person::published.desc()),
 109       SortType::New | SortType::MostComments | SortType::NewComments => {
 110         query.order_by(person::published.desc())
 111       }
 112       SortType::TopAll => query.order_by(person_aggregates::comment_score.desc()),
 113       SortType::TopYear => query
 114         .filter(person::published.gt(now - 1.years()))
 115         .order_by(person_aggregates::comment_score.desc()),
 116       SortType::TopMonth => query
 117         .filter(person::published.gt(now - 1.months()))
 118         .order_by(person_aggregates::comment_score.desc()),
 119       SortType::TopWeek => query
 120         .filter(person::published.gt(now - 1.weeks()))
 121         .order_by(person_aggregates::comment_score.desc()),
 122       SortType::TopDay => query
 123         .filter(person::published.gt(now - 1.days()))
 124         .order_by(person_aggregates::comment_score.desc()),
 125     };
 126
 127     let (limit, offset) = limit_and_offset(self.page, self.limit)?;
 128     query = query.limit(limit).offset(offset);
 129
 130     let res = query.load::<PersonViewSafeTuple>(self.conn)?;
 131
 132     Ok(PersonViewSafe::from_tuple_to_vec(res))
 133   }
 134 }
 135
 136 impl ViewToVec for PersonViewSafe {
 137   type DbTuple = PersonViewSafeTuple;
 138   fn from_tuple_to_vec(items: Vec<Self::DbTuple>) -> Vec<Self> {
 139     items
 140       .iter()
 141       .map(|a| Self {
 142         person: a.0.to_owned(),
 143         counts: a.1.to_owned(),
 144       })
 145       .collect::<Vec<Self>>()
 146   }
 147 }