lemmy/lemmy_db/src/views/user_view.rs

213 lines
5.7 KiB
Rust
Raw Normal View History

2020-12-03 03:39:31 +00:00
use crate::{
2020-12-03 18:39:56 +00:00
aggregates::user_aggregates::UserAggregates,
2020-12-04 00:47:58 +00:00
fuzzy_search,
limit_and_offset,
2020-12-03 18:39:56 +00:00
schema::{user_, user_aggregates},
source::user::{UserSafe, User_},
2020-12-11 01:39:42 +00:00
views::ViewToVec,
2020-12-04 00:47:58 +00:00
MaybeOptional,
SortType,
2020-12-05 04:18:30 +00:00
ToSafe,
2020-12-03 03:39:31 +00:00
};
2020-12-04 00:47:58 +00:00
use diesel::{dsl::*, result::Error, *};
2020-12-03 03:39:31 +00:00
use serde::Serialize;
#[derive(Debug, Serialize, Clone)]
pub struct UserViewSafe {
pub user: UserSafe,
2020-12-03 18:39:56 +00:00
pub counts: UserAggregates,
2020-12-03 03:39:31 +00:00
}
2020-12-11 01:39:42 +00:00
type UserViewSafeTuple = (UserSafe, UserAggregates);
2020-12-03 18:39:56 +00:00
#[derive(Debug, Serialize, Clone)]
2020-12-03 03:39:31 +00:00
pub struct UserViewDangerous {
pub user: User_,
2020-12-03 18:39:56 +00:00
pub counts: UserAggregates,
2020-12-03 03:39:31 +00:00
}
2020-12-11 01:39:42 +00:00
type UserViewDangerousTuple = (User_, UserAggregates);
2020-12-03 03:39:31 +00:00
impl UserViewDangerous {
pub fn read(conn: &PgConnection, id: i32) -> Result<Self, Error> {
2020-12-03 18:39:56 +00:00
let (user, counts) = user_::table
.find(id)
.inner_join(user_aggregates::table)
2020-12-11 01:39:42 +00:00
.first::<UserViewDangerousTuple>(conn)?;
2020-12-03 18:39:56 +00:00
Ok(Self { user, counts })
2020-12-03 03:39:31 +00:00
}
}
impl UserViewSafe {
pub fn read(conn: &PgConnection, id: i32) -> Result<Self, Error> {
2020-12-03 18:39:56 +00:00
let (user, counts) = user_::table
.find(id)
.inner_join(user_aggregates::table)
2020-12-05 04:18:30 +00:00
.select((User_::safe_columns_tuple(), user_aggregates::all_columns))
2020-12-11 01:39:42 +00:00
.first::<UserViewSafeTuple>(conn)?;
2020-12-05 04:18:30 +00:00
Ok(Self { user, counts })
2020-12-03 03:39:31 +00:00
}
pub fn admins(conn: &PgConnection) -> Result<Vec<Self>, Error> {
let admins = user_::table
2020-12-03 18:39:56 +00:00
.inner_join(user_aggregates::table)
2020-12-05 04:18:30 +00:00
.select((User_::safe_columns_tuple(), user_aggregates::all_columns))
2020-12-03 03:39:31 +00:00
.filter(user_::admin.eq(true))
.order_by(user_::published)
2020-12-11 01:39:42 +00:00
.load::<UserViewSafeTuple>(conn)?;
2020-12-03 03:39:31 +00:00
2020-12-11 01:39:42 +00:00
Ok(Self::to_vec(admins))
2020-12-03 03:39:31 +00:00
}
pub fn banned(conn: &PgConnection) -> Result<Vec<Self>, Error> {
let banned = user_::table
2020-12-03 18:39:56 +00:00
.inner_join(user_aggregates::table)
2020-12-05 04:18:30 +00:00
.select((User_::safe_columns_tuple(), user_aggregates::all_columns))
2020-12-03 03:39:31 +00:00
.filter(user_::banned.eq(true))
2020-12-11 01:39:42 +00:00
.load::<UserViewSafeTuple>(conn)?;
2020-12-03 03:39:31 +00:00
2020-12-11 01:39:42 +00:00
Ok(Self::to_vec(banned))
2020-12-03 03:39:31 +00:00
}
}
2020-12-16 16:09:21 +00:00
// TODO can get rid of this by not boxing the query before the list()
2020-12-04 00:47:58 +00:00
mod join_types {
use crate::schema::{user_, user_aggregates};
use diesel::{
pg::Pg,
query_builder::BoxedSelectStatement,
query_source::joins::{Inner, Join, JoinOn},
sql_types::*,
};
/// TODO awful, but necessary because of the boxed join
pub(super) type BoxedUserJoin<'a> = BoxedSelectStatement<
'a,
(
2020-12-05 04:18:30 +00:00
// UserSafe column types
2020-12-04 00:47:58 +00:00
(
Integer,
Text,
Nullable<Text>,
Nullable<Text>,
2020-12-05 04:18:30 +00:00
Bool,
2020-12-04 00:47:58 +00:00
Bool,
Timestamp,
Nullable<Timestamp>,
Nullable<Text>,
Text,
Nullable<Text>,
Bool,
Nullable<Text>,
Bool,
),
2020-12-05 04:18:30 +00:00
// UserAggregates column types
2020-12-04 00:47:58 +00:00
(Integer, Integer, BigInt, BigInt, BigInt, BigInt),
),
JoinOn<
Join<user_::table, user_aggregates::table, Inner>,
diesel::expression::operators::Eq<
diesel::expression::nullable::Nullable<user_aggregates::columns::user_id>,
diesel::expression::nullable::Nullable<user_::columns::id>,
>,
>,
Pg,
>;
}
pub struct UserQueryBuilder<'a> {
conn: &'a PgConnection,
query: join_types::BoxedUserJoin<'a>,
sort: &'a SortType,
page: Option<i64>,
limit: Option<i64>,
}
impl<'a> UserQueryBuilder<'a> {
pub fn create(conn: &'a PgConnection) -> Self {
2020-12-05 04:18:30 +00:00
let query = user_::table
.inner_join(user_aggregates::table)
.select((User_::safe_columns_tuple(), user_aggregates::all_columns))
.into_boxed();
2020-12-04 00:47:58 +00:00
UserQueryBuilder {
conn,
query,
sort: &SortType::Hot,
page: None,
limit: None,
}
}
pub fn sort(mut self, sort: &'a SortType) -> Self {
self.sort = sort;
self
}
pub fn search_term<T: MaybeOptional<String>>(mut self, search_term: T) -> Self {
if let Some(search_term) = search_term.get_optional() {
self.query = self
.query
.filter(user_::name.ilike(fuzzy_search(&search_term)));
}
self
}
pub fn page<T: MaybeOptional<i64>>(mut self, page: T) -> Self {
self.page = page.get_optional();
self
}
pub fn limit<T: MaybeOptional<i64>>(mut self, limit: T) -> Self {
self.limit = limit.get_optional();
self
}
pub fn list(self) -> Result<Vec<UserViewSafe>, Error> {
let mut query = self.query;
query = match self.sort {
SortType::Hot => query
.order_by(user_aggregates::comment_score.desc())
.then_order_by(user_::published.desc()),
SortType::Active => query
.order_by(user_aggregates::comment_score.desc())
.then_order_by(user_::published.desc()),
SortType::New => query.order_by(user_::published.desc()),
SortType::TopAll => query.order_by(user_aggregates::comment_score.desc()),
SortType::TopYear => query
.filter(user_::published.gt(now - 1.years()))
.order_by(user_aggregates::comment_score.desc()),
SortType::TopMonth => query
.filter(user_::published.gt(now - 1.months()))
.order_by(user_aggregates::comment_score.desc()),
SortType::TopWeek => query
.filter(user_::published.gt(now - 1.weeks()))
.order_by(user_aggregates::comment_score.desc()),
SortType::TopDay => query
.filter(user_::published.gt(now - 1.days()))
.order_by(user_aggregates::comment_score.desc()),
};
let (limit, offset) = limit_and_offset(self.page, self.limit);
query = query.limit(limit).offset(offset);
2020-12-11 01:39:42 +00:00
let res = query.load::<UserViewSafeTuple>(self.conn)?;
2020-12-04 00:47:58 +00:00
2020-12-11 01:39:42 +00:00
Ok(UserViewSafe::to_vec(res))
2020-12-04 00:47:58 +00:00
}
}
2020-12-11 01:39:42 +00:00
impl ViewToVec for UserViewSafe {
type DbTuple = UserViewSafeTuple;
fn to_vec(users: Vec<Self::DbTuple>) -> Vec<Self> {
users
.iter()
.map(|a| Self {
user: a.0.to_owned(),
counts: a.1.to_owned(),
})
.collect::<Vec<Self>>()
}
2020-12-03 03:39:31 +00:00
}