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::{ToSafe, ViewToVec},
   9   utils::{fuzzy_search, limit_and_offset},
  10   SortType,
  11 };
  12 use typed_builder::TypedBuilder;
  13
  14 type PersonViewSafeTuple = (PersonSafe, PersonAggregates);
  15
  16 impl PersonViewSafe {
  17   pub fn read(conn: &mut PgConnection, person_id: PersonId) -> Result<Self, Error> {
  18     let (person, counts) = person::table
  19       .find(person_id)
  20       .inner_join(person_aggregates::table)
  21       .select((Person::safe_columns_tuple(), person_aggregates::all_columns))
  22       .first::<PersonViewSafeTuple>(conn)?;
  23     Ok(Self { person, counts })
  24   }
  25
  26   pub fn admins(conn: &mut PgConnection) -> Result<Vec<Self>, Error> {
  27     let admins = person::table
  28       .inner_join(person_aggregates::table)
  29       .select((Person::safe_columns_tuple(), person_aggregates::all_columns))
  30       .filter(person::admin.eq(true))
  31       .filter(person::deleted.eq(false))
  32       .order_by(person::published)
  33       .load::<PersonViewSafeTuple>(conn)?;
  34
  35     Ok(Self::from_tuple_to_vec(admins))
  36   }
  37
  38   pub fn banned(conn: &mut PgConnection) -> Result<Vec<Self>, Error> {
  39     let banned = person::table
  40       .inner_join(person_aggregates::table)
  41       .select((Person::safe_columns_tuple(), person_aggregates::all_columns))
  42       .filter(
  43         person::banned.eq(true).and(
  44           person::ban_expires
  45             .is_null()
  46             .or(person::ban_expires.gt(now)),
  47         ),
  48       )
  49       .filter(person::deleted.eq(false))
  50       .load::<PersonViewSafeTuple>(conn)?;
  51
  52     Ok(Self::from_tuple_to_vec(banned))
  53   }
  54 }
  55
  56 #[derive(TypedBuilder)]
  57 #[builder(field_defaults(default))]
  58 pub struct PersonQuery<'a> {
  59   #[builder(!default)]
  60   conn: &'a mut PgConnection,
  61   sort: Option<SortType>,
  62   search_term: Option<String>,
  63   page: Option<i64>,
  64   limit: Option<i64>,
  65 }
  66
  67 impl<'a> PersonQuery<'a> {
  68   pub fn list(self) -> Result<Vec<PersonViewSafe>, Error> {
  69     let mut query = person::table
  70       .inner_join(person_aggregates::table)
  71       .select((Person::safe_columns_tuple(), person_aggregates::all_columns))
  72       .into_boxed();
  73
  74     if let Some(search_term) = self.search_term {
  75       let searcher = fuzzy_search(&search_term);
  76       query = query
  77         .filter(person::name.ilike(searcher.to_owned()))
  78         .or_filter(person::display_name.ilike(searcher));
  79     }
  80
  81     query = match self.sort.unwrap_or(SortType::Hot) {
  82       SortType::Hot => query
  83         .order_by(person_aggregates::comment_score.desc())
  84         .then_order_by(person::published.desc()),
  85       SortType::Active => query
  86         .order_by(person_aggregates::comment_score.desc())
  87         .then_order_by(person::published.desc()),
  88       SortType::New | SortType::MostComments | SortType::NewComments => {
  89         query.order_by(person::published.desc())
  90       }
  91       SortType::Old => query.order_by(person::published.asc()),
  92       SortType::TopAll => query.order_by(person_aggregates::comment_score.desc()),
  93       SortType::TopYear => query
  94         .filter(person::published.gt(now - 1.years()))
  95         .order_by(person_aggregates::comment_score.desc()),
  96       SortType::TopMonth => query
  97         .filter(person::published.gt(now - 1.months()))
  98         .order_by(person_aggregates::comment_score.desc()),
  99       SortType::TopWeek => query
 100         .filter(person::published.gt(now - 1.weeks()))
 101         .order_by(person_aggregates::comment_score.desc()),
 102       SortType::TopDay => query
 103         .filter(person::published.gt(now - 1.days()))
 104         .order_by(person_aggregates::comment_score.desc()),
 105     };
 106
 107     let (limit, offset) = limit_and_offset(self.page, self.limit)?;
 108     query = query.limit(limit).offset(offset);
 109
 110     let res = query.load::<PersonViewSafeTuple>(self.conn)?;
 111
 112     Ok(PersonViewSafe::from_tuple_to_vec(res))
 113   }
 114 }
 115
 116 impl ViewToVec for PersonViewSafe {
 117   type DbTuple = PersonViewSafeTuple;
 118   fn from_tuple_to_vec(items: Vec<Self::DbTuple>) -> Vec<Self> {
 119     items
 120       .into_iter()
 121       .map(|a| Self {
 122         person: a.0,
 123         counts: a.1,
 124       })
 125       .collect::<Vec<Self>>()
 126   }
 127 }