1 use crate::structs::PersonView;
3 dsl::{now, IntervalDsl},
7 PgTextExpressionMethods,
10 use diesel_async::RunQueryDsl;
11 use lemmy_db_schema::{
12 aggregates::structs::PersonAggregates,
15 schema::{person, person_aggregates},
16 source::person::Person,
18 utils::{fuzzy_search, get_conn, limit_and_offset, DbPool},
21 use std::iter::Iterator;
22 use typed_builder::TypedBuilder;
24 type PersonViewTuple = (Person, PersonAggregates);
27 pub async fn read(pool: &mut DbPool<'_>, person_id: PersonId) -> Result<Self, Error> {
28 let conn = &mut get_conn(pool).await?;
29 let res = person::table
31 .inner_join(person_aggregates::table)
32 .select((person::all_columns, person_aggregates::all_columns))
33 .first::<PersonViewTuple>(conn)
35 Ok(Self::from_tuple(res))
38 pub async fn is_admin(pool: &mut DbPool<'_>, person_id: PersonId) -> Result<bool, Error> {
39 use schema::person::dsl::{admin, id, person};
40 let conn = &mut get_conn(pool).await?;
42 .filter(id.eq(person_id))
48 pub async fn admins(pool: &mut DbPool<'_>) -> Result<Vec<Self>, Error> {
49 let conn = &mut get_conn(pool).await?;
50 let admins = person::table
51 .inner_join(person_aggregates::table)
52 .select((person::all_columns, person_aggregates::all_columns))
53 .filter(person::admin.eq(true))
54 .filter(person::deleted.eq(false))
55 .order_by(person::published)
56 .load::<PersonViewTuple>(conn)
59 Ok(admins.into_iter().map(Self::from_tuple).collect())
62 pub async fn banned(pool: &mut DbPool<'_>) -> Result<Vec<Self>, Error> {
63 let conn = &mut get_conn(pool).await?;
64 let banned = person::table
65 .inner_join(person_aggregates::table)
66 .select((person::all_columns, person_aggregates::all_columns))
68 person::banned.eq(true).and(
71 .or(person::ban_expires.gt(now)),
74 .filter(person::deleted.eq(false))
75 .load::<PersonViewTuple>(conn)
78 Ok(banned.into_iter().map(Self::from_tuple).collect())
82 #[derive(TypedBuilder)]
83 #[builder(field_defaults(default))]
84 pub struct PersonQuery<'a, 'b: 'a> {
86 pool: &'a mut DbPool<'b>,
87 sort: Option<SortType>,
88 search_term: Option<String>,
93 impl<'a, 'b: 'a> PersonQuery<'a, 'b> {
94 pub async fn list(self) -> Result<Vec<PersonView>, Error> {
95 let conn = &mut get_conn(self.pool).await?;
96 let mut query = person::table
97 .inner_join(person_aggregates::table)
98 .select((person::all_columns, person_aggregates::all_columns))
101 if let Some(search_term) = self.search_term {
102 let searcher = fuzzy_search(&search_term);
104 .filter(person::name.ilike(searcher.clone()))
105 .or_filter(person::display_name.ilike(searcher));
108 query = match self.sort.unwrap_or(SortType::Hot) {
109 SortType::New | SortType::NewComments => query.order_by(person::published.desc()),
110 SortType::Old => query.order_by(person::published.asc()),
111 SortType::Hot | SortType::Active | SortType::TopAll => {
112 query.order_by(person_aggregates::comment_score.desc())
114 SortType::MostComments => query.order_by(person_aggregates::comment_count.desc()),
115 SortType::TopYear => query
116 .filter(person::published.gt(now - 1.years()))
117 .order_by(person_aggregates::comment_score.desc()),
118 SortType::TopMonth => query
119 .filter(person::published.gt(now - 1.months()))
120 .order_by(person_aggregates::comment_score.desc()),
121 SortType::TopWeek => query
122 .filter(person::published.gt(now - 1.weeks()))
123 .order_by(person_aggregates::comment_score.desc()),
124 SortType::TopDay => query
125 .filter(person::published.gt(now - 1.days()))
126 .order_by(person_aggregates::comment_score.desc()),
127 SortType::TopHour => query
128 .filter(person::published.gt(now - 1.hours()))
129 .order_by(person_aggregates::comment_score.desc()),
130 SortType::TopSixHour => query
131 .filter(person::published.gt(now - 6.hours()))
132 .order_by(person_aggregates::comment_score.desc()),
133 SortType::TopTwelveHour => query
134 .filter(person::published.gt(now - 12.hours()))
135 .order_by(person_aggregates::comment_score.desc()),
136 SortType::TopThreeMonths => query
137 .filter(person::published.gt(now - 3.months()))
138 .order_by(person_aggregates::comment_score.desc()),
139 SortType::TopSixMonths => query
140 .filter(person::published.gt(now - 6.months()))
141 .order_by(person_aggregates::comment_score.desc()),
142 SortType::TopNineMonths => query
143 .filter(person::published.gt(now - 9.months()))
144 .order_by(person_aggregates::comment_score.desc()),
147 let (limit, offset) = limit_and_offset(self.page, self.limit)?;
148 query = query.limit(limit).offset(offset);
150 let res = query.load::<PersonViewTuple>(conn).await?;
152 Ok(res.into_iter().map(PersonView::from_tuple).collect())
156 impl JoinView for PersonView {
157 type JoinTuple = PersonViewTuple;
158 fn from_tuple(a: Self::JoinTuple) -> Self {