crates/db_views_actor/src/person_view.rs

   1 use crate::structs::PersonView;
   2 use diesel::{
   3   dsl::now,
   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   PersonSortType,
  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<PersonSortType>,
  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(PersonSortType::CommentScore) {
 105       PersonSortType::New => query.order_by(person::published.desc()),
 106       PersonSortType::Old => query.order_by(person::published.asc()),
 107       PersonSortType::MostComments => query.order_by(person_aggregates::comment_count.desc()),
 108       PersonSortType::CommentScore => query.order_by(person_aggregates::comment_score.desc()),
 109       PersonSortType::PostScore => query.order_by(person_aggregates::post_score.desc()),
 110       PersonSortType::PostCount => query.order_by(person_aggregates::post_count.desc()),
 111     };
 112
 113     let (limit, offset) = limit_and_offset(self.page, self.limit)?;
 114     query = query.limit(limit).offset(offset);
 115
 116     let res = query.load::<PersonViewTuple>(conn).await?;
 117
 118     Ok(res.into_iter().map(PersonView::from_tuple).collect())
 119   }
 120 }
 121
 122 impl JoinView for PersonView {
 123   type JoinTuple = PersonViewTuple;
 124   fn from_tuple(a: Self::JoinTuple) -> Self {
 125     Self {
 126       person: a.0,
 127       counts: a.1,
 128     }
 129   }
 130 }