crates/db_views_actor/src/person_view.rs

   1 use crate::structs::PersonView;
   2 use diesel::{
   3   dsl::{now, IntervalDsl},
   4   result::Error,
   5   BoolExpressionMethods,
   6   ExpressionMethods,
   7   PgTextExpressionMethods,
   8   QueryDsl,
   9 };
  10 use diesel_async::RunQueryDsl;
  11 use lemmy_db_schema::{
  12   aggregates::structs::PersonAggregates,
  13   newtypes::PersonId,
  14   schema,
  15   schema::{person, person_aggregates},
  16   source::person::Person,
  17   traits::JoinView,
  18   utils::{fuzzy_search, get_conn, limit_and_offset, DbPool},
  19   SortType,
  20 };
  21 use std::iter::Iterator;
  22
  23 type PersonViewTuple = (Person, PersonAggregates);
  24
  25 impl PersonView {
  26   pub async fn read(pool: &mut DbPool<'_>, person_id: PersonId) -> Result<Self, Error> {
  27     let conn = &mut get_conn(pool).await?;
  28     let res = person::table
  29       .find(person_id)
  30       .inner_join(person_aggregates::table)
  31       .select((person::all_columns, person_aggregates::all_columns))
  32       .first::<PersonViewTuple>(conn)
  33       .await?;
  34     Ok(Self::from_tuple(res))
  35   }
  36
  37   pub async fn is_admin(pool: &mut DbPool<'_>, person_id: PersonId) -> Result<bool, Error> {
  38     use schema::person::dsl::{admin, id, person};
  39     let conn = &mut get_conn(pool).await?;
  40     let is_admin = person
  41       .filter(id.eq(person_id))
  42       .select(admin)
  43       .first::<bool>(conn)
  44       .await?;
  45     Ok(is_admin)
  46   }
  47   pub async fn admins(pool: &mut DbPool<'_>) -> Result<Vec<Self>, Error> {
  48     let conn = &mut get_conn(pool).await?;
  49     let admins = person::table
  50       .inner_join(person_aggregates::table)
  51       .select((person::all_columns, person_aggregates::all_columns))
  52       .filter(person::admin.eq(true))
  53       .filter(person::deleted.eq(false))
  54       .order_by(person::published)
  55       .load::<PersonViewTuple>(conn)
  56       .await?;
  57
  58     Ok(admins.into_iter().map(Self::from_tuple).collect())
  59   }
  60
  61   pub async fn banned(pool: &mut DbPool<'_>) -> Result<Vec<Self>, Error> {
  62     let conn = &mut get_conn(pool).await?;
  63     let banned = person::table
  64       .inner_join(person_aggregates::table)
  65       .select((person::all_columns, person_aggregates::all_columns))
  66       .filter(
  67         person::banned.eq(true).and(
  68           person::ban_expires
  69             .is_null()
  70             .or(person::ban_expires.gt(now)),
  71         ),
  72       )
  73       .filter(person::deleted.eq(false))
  74       .load::<PersonViewTuple>(conn)
  75       .await?;
  76
  77     Ok(banned.into_iter().map(Self::from_tuple).collect())
  78   }
  79 }
  80
  81 #[derive(Default)]
  82 pub struct PersonQuery {
  83   pub sort: Option<SortType>,
  84   pub search_term: Option<String>,
  85   pub page: Option<i64>,
  86   pub limit: Option<i64>,
  87 }
  88
  89 impl PersonQuery {
  90   pub async fn list(self, pool: &mut DbPool<'_>) -> Result<Vec<PersonView>, Error> {
  91     let conn = &mut get_conn(pool).await?;
  92     let mut query = person::table
  93       .inner_join(person_aggregates::table)
  94       .select((person::all_columns, person_aggregates::all_columns))
  95       .into_boxed();
  96
  97     if let Some(search_term) = self.search_term {
  98       let searcher = fuzzy_search(&search_term);
  99       query = query
 100         .filter(person::name.ilike(searcher.clone()))
 101         .or_filter(person::display_name.ilike(searcher));
 102     }
 103
 104     query = match self.sort.unwrap_or(SortType::Hot) {
 105       SortType::New | SortType::NewComments => query.order_by(person::published.desc()),
 106       SortType::Old => query.order_by(person::published.asc()),
 107       SortType::Hot | SortType::Active | SortType::TopAll => {
 108         query.order_by(person_aggregates::comment_score.desc())
 109       }
 110       SortType::MostComments => query.order_by(person_aggregates::comment_count.desc()),
 111       SortType::TopYear => query
 112         .filter(person::published.gt(now - 1.years()))
 113         .order_by(person_aggregates::comment_score.desc()),
 114       SortType::TopMonth => query
 115         .filter(person::published.gt(now - 1.months()))
 116         .order_by(person_aggregates::comment_score.desc()),
 117       SortType::TopWeek => query
 118         .filter(person::published.gt(now - 1.weeks()))
 119         .order_by(person_aggregates::comment_score.desc()),
 120       SortType::TopDay => query
 121         .filter(person::published.gt(now - 1.days()))
 122         .order_by(person_aggregates::comment_score.desc()),
 123       SortType::TopHour => query
 124         .filter(person::published.gt(now - 1.hours()))
 125         .order_by(person_aggregates::comment_score.desc()),
 126       SortType::TopSixHour => query
 127         .filter(person::published.gt(now - 6.hours()))
 128         .order_by(person_aggregates::comment_score.desc()),
 129       SortType::TopTwelveHour => query
 130         .filter(person::published.gt(now - 12.hours()))
 131         .order_by(person_aggregates::comment_score.desc()),
 132       SortType::TopThreeMonths => query
 133         .filter(person::published.gt(now - 3.months()))
 134         .order_by(person_aggregates::comment_score.desc()),
 135       SortType::TopSixMonths => query
 136         .filter(person::published.gt(now - 6.months()))
 137         .order_by(person_aggregates::comment_score.desc()),
 138       SortType::TopNineMonths => query
 139         .filter(person::published.gt(now - 9.months()))
 140         .order_by(person_aggregates::comment_score.desc()),
 141     };
 142
 143     let (limit, offset) = limit_and_offset(self.page, self.limit)?;
 144     query = query.limit(limit).offset(offset);
 145
 146     let res = query.load::<PersonViewTuple>(conn).await?;
 147
 148     Ok(res.into_iter().map(PersonView::from_tuple).collect())
 149   }
 150 }
 151
 152 impl JoinView for PersonView {
 153   type JoinTuple = PersonViewTuple;
 154   fn from_tuple(a: Self::JoinTuple) -> Self {
 155     Self {
 156       person: a.0,
 157       counts: a.1,
 158     }
 159   }
 160 }