use diesel_async::RunQueryDsl;
use lemmy_db_schema::{
aggregates::structs::PostAggregates,
- newtypes::{CommunityId, DbUrl, LocalUserId, PersonId, PostId},
+ newtypes::{CommunityId, LocalUserId, PersonId, PostId},
schema::{
community,
community_block,
post::{Post, PostRead, PostSaved},
},
traits::JoinView,
- utils::{functions::hot_rank, fuzzy_search, get_conn, limit_and_offset, DbPool},
+ utils::{fuzzy_search, get_conn, limit_and_offset, DbPool},
ListingType,
SortType,
};
impl PostView {
pub async fn read(
- pool: &DbPool,
+ pool: &mut DbPool<'_>,
post_id: PostId,
my_person_id: Option<PersonId>,
is_mod_or_admin: Option<bool>,
// The left join below will return None in this case
let person_id_join = my_person_id.unwrap_or(PersonId(-1));
- let person_alias_1 = diesel::alias!(person as person1);
let mut query = post::table
.find(post_id)
.inner_join(person::table)
community_person_ban::table.on(
post::community_id
.eq(community_person_ban::community_id)
- .and(community_person_ban::person_id.eq(post::creator_id))
- .and(
- community_person_ban::expires
- .is_null()
- .or(community_person_ban::expires.gt(now)),
- ),
+ .and(community_person_ban::person_id.eq(post::creator_id)),
),
)
.inner_join(post_aggregates::table)
.and(person_post_aggregates::person_id.eq(person_id_join)),
),
)
- // Used to check if you are the post creator
- .left_join(
- person_alias_1.on(
- post::creator_id
- .eq(person_alias_1.field(person::id))
- .and(person_alias_1.field(person::id).eq(person_id_join)),
- ),
- )
.select((
post::all_columns,
person::all_columns,
))
.into_boxed();
- // If you are not a moderator, exclude deleted or removed content
- if !is_mod_or_admin.unwrap_or(true) {
- // If you are not the creator, then remove the other fields.
+ // Hide deleted and removed for non-admins or mods
+ if !is_mod_or_admin.unwrap_or(false) {
query = query
- .filter(
- person_alias_1.field(person::id).is_null().and(
- post::removed
- .eq(false)
- .and(post::deleted.eq(false))
- .and(community::removed.eq(false))
- .and(community::deleted.eq(false)),
- ),
- )
- // If you are the creator, keep them
- .or_filter(person_alias_1.field(person::id).is_not_null())
+ .filter(community::removed.eq(false))
+ .filter(community::deleted.eq(false))
+ .filter(post::removed.eq(false))
+ .filter(post::deleted.eq(false));
}
let (
#[derive(TypedBuilder)]
#[builder(field_defaults(default))]
-pub struct PostQuery<'a> {
+pub struct PostQuery<'a, 'b: 'a> {
#[builder(!default)]
- pool: &'a DbPool,
+ pool: &'a mut DbPool<'b>,
listing_type: Option<ListingType>,
sort: Option<SortType>,
creator_id: Option<PersonId>,
community_id: Option<CommunityId>,
- community_actor_id: Option<DbUrl>,
local_user: Option<&'a LocalUser>,
search_term: Option<String>,
url_search: Option<String>,
limit: Option<i64>,
}
-impl<'a> PostQuery<'a> {
+impl<'a, 'b: 'a> PostQuery<'a, 'b> {
pub async fn list(self) -> Result<Vec<PostView>, Error> {
let conn = &mut get_conn(self.pool).await?;
// The left join below will return None in this case
let person_id_join = self.local_user.map(|l| l.person_id).unwrap_or(PersonId(-1));
let local_user_id_join = self.local_user.map(|l| l.id).unwrap_or(LocalUserId(-1));
- let person_alias_1 = diesel::alias!(person as person1);
let mut query = post::table
.inner_join(person::table)
community_person_ban::table.on(
post::community_id
.eq(community_person_ban::community_id)
- .and(community_person_ban::person_id.eq(post::creator_id))
- .and(
- community_person_ban::expires
- .is_null()
- .or(community_person_ban::expires.gt(now)),
- ),
+ .and(community_person_ban::person_id.eq(post::creator_id)),
),
)
.inner_join(post_aggregates::table)
)
.left_join(
community_block::table.on(
- community::id
+ post::community_id
.eq(community_block::community_id)
.and(community_block::person_id.eq(person_id_join)),
),
.and(local_user_language::local_user_id.eq(local_user_id_join)),
),
)
- // Used to check if you are the post creator
- .left_join(
- person_alias_1.on(
- post::creator_id
- .eq(person_alias_1.field(person::id))
- .and(person_alias_1.field(person::id).eq(person_id_join)),
- ),
- )
.select((
post::all_columns,
person::all_columns,
))
.into_boxed();
- // If you are not a moderator, exclude deleted or removed content
- if !self.is_mod_or_admin.unwrap_or(true) {
- // If you are not the creator, then remove the other fields.
+ // Hide deleted and removed for non-admins or mods
+ // TODO This eventually needs to show posts where you are the creator
+ if !self.is_mod_or_admin.unwrap_or(false) {
query = query
- .filter(
- person_alias_1.field(person::id).is_null().and(
- post::removed
- .eq(false)
- .and(post::deleted.eq(false))
- .and(community::removed.eq(false))
- .and(community::deleted.eq(false)),
- ),
- )
- // If you are the creator, keep them
- .or_filter(person_alias_1.field(person::id).is_not_null())
+ .filter(community::removed.eq(false))
+ .filter(community::deleted.eq(false))
+ .filter(post::removed.eq(false))
+ .filter(post::deleted.eq(false));
+ }
+
+ if self.community_id.is_none() {
+ query = query.then_order_by(post_aggregates::featured_local.desc());
+ } else if let Some(community_id) = self.community_id {
+ query = query
+ .filter(post::community_id.eq(community_id))
+ .then_order_by(post_aggregates::featured_community.desc());
+ }
+
+ if let Some(creator_id) = self.creator_id {
+ query = query.filter(post::creator_id.eq(creator_id));
}
if let Some(listing_type) = self.listing_type {
}
}
}
- if self.community_id.is_none() && self.community_actor_id.is_none() {
- query = query.then_order_by(post_aggregates::featured_local.desc());
- } else if let Some(community_id) = self.community_id {
- query = query
- .filter(post::community_id.eq(community_id))
- .then_order_by(post_aggregates::featured_community.desc());
- } else if let Some(community_actor_id) = self.community_actor_id {
- query = query
- .filter(community::actor_id.eq(community_actor_id))
- .then_order_by(post_aggregates::featured_community.desc());
- }
if let Some(url_search) = self.url_search {
query = query.filter(post::url.eq(url_search));
);
}
- if let Some(creator_id) = self.creator_id {
- query = query.filter(post::creator_id.eq(creator_id));
- }
-
if !self.local_user.map(|l| l.show_nsfw).unwrap_or(false) {
query = query
.filter(post::nsfw.eq(false))
}
query = match self.sort.unwrap_or(SortType::Hot) {
- SortType::Active => query
- .then_order_by(
- hot_rank(
- post_aggregates::score,
- post_aggregates::newest_comment_time_necro,
- )
- .desc(),
- )
- .then_order_by(post_aggregates::newest_comment_time_necro.desc()),
- SortType::Hot => query
- .then_order_by(hot_rank(post_aggregates::score, post_aggregates::published).desc())
- .then_order_by(post_aggregates::published.desc()),
+ SortType::Active => query.then_order_by(post_aggregates::hot_rank_active.desc()),
+ SortType::Hot => query.then_order_by(post_aggregates::hot_rank.desc()),
SortType::New => query.then_order_by(post_aggregates::published.desc()),
SortType::Old => query.then_order_by(post_aggregates::published.asc()),
SortType::NewComments => query.then_order_by(post_aggregates::newest_comment_time.desc()),
.filter(post_aggregates::published.gt(now - 1.days()))
.then_order_by(post_aggregates::score.desc())
.then_order_by(post_aggregates::published.desc()),
+ SortType::TopHour => query
+ .filter(post_aggregates::published.gt(now - 1.hours()))
+ .then_order_by(post_aggregates::score.desc())
+ .then_order_by(post_aggregates::published.desc()),
+ SortType::TopSixHour => query
+ .filter(post_aggregates::published.gt(now - 6.hours()))
+ .then_order_by(post_aggregates::score.desc())
+ .then_order_by(post_aggregates::published.desc()),
+ SortType::TopTwelveHour => query
+ .filter(post_aggregates::published.gt(now - 12.hours()))
+ .then_order_by(post_aggregates::score.desc())
+ .then_order_by(post_aggregates::published.desc()),
+ SortType::TopThreeMonths => query
+ .filter(post_aggregates::published.gt(now - 3.months()))
+ .then_order_by(post_aggregates::score.desc())
+ .then_order_by(post_aggregates::published.desc()),
+ SortType::TopSixMonths => query
+ .filter(post_aggregates::published.gt(now - 6.months()))
+ .then_order_by(post_aggregates::score.desc())
+ .then_order_by(post_aggregates::published.desc()),
+ SortType::TopNineMonths => query
+ .filter(post_aggregates::published.gt(now - 9.months()))
+ .then_order_by(post_aggregates::score.desc())
+ .then_order_by(post_aggregates::published.desc()),
};
let (limit, offset) = limit_and_offset(self.page, self.limit)?;
local_user::{LocalUser, LocalUserInsertForm, LocalUserUpdateForm},
person::{Person, PersonInsertForm},
person_block::{PersonBlock, PersonBlockForm},
- post::{Post, PostInsertForm, PostLike, PostLikeForm},
+ post::{Post, PostInsertForm, PostLike, PostLikeForm, PostUpdateForm},
},
traits::{Blockable, Crud, Likeable},
utils::{build_db_pool_for_tests, DbPool},
inserted_post: Post,
}
- async fn init_data(pool: &DbPool) -> Data {
+ async fn init_data(pool: &mut DbPool<'_>) -> Data {
let inserted_instance = Instance::read_or_create(pool, "my_domain.tld".to_string())
.await
.unwrap();
#[serial]
async fn post_listing_with_person() {
let pool = &build_db_pool_for_tests().await;
+ let pool = &mut pool.into();
let data = init_data(pool).await;
let local_user_form = LocalUserUpdateForm::builder()
#[serial]
async fn post_listing_no_person() {
let pool = &build_db_pool_for_tests().await;
+ let pool = &mut pool.into();
let data = init_data(pool).await;
let read_post_listing_multiple_no_person = PostQuery::builder()
#[serial]
async fn post_listing_block_community() {
let pool = &build_db_pool_for_tests().await;
+ let pool = &mut pool.into();
let data = init_data(pool).await;
let community_block = CommunityBlockForm {
#[serial]
async fn post_listing_like() {
let pool = &build_db_pool_for_tests().await;
+ let pool = &mut pool.into();
let data = init_data(pool).await;
let post_like_form = PostLikeForm {
};
assert_eq!(expected_post_like, inserted_post_like);
+ let post_listing_single_with_person = PostView::read(
+ pool,
+ data.inserted_post.id,
+ Some(data.inserted_person.id),
+ None,
+ )
+ .await
+ .unwrap();
+
+ let mut expected_post_with_upvote = expected_post_view(&data, pool).await;
+ expected_post_with_upvote.my_vote = Some(1);
+ expected_post_with_upvote.counts.score = 1;
+ expected_post_with_upvote.counts.upvotes = 1;
+ assert_eq!(expected_post_with_upvote, post_listing_single_with_person);
+
+ let local_user_form = LocalUserUpdateForm::builder()
+ .show_bot_accounts(Some(false))
+ .build();
+ let inserted_local_user =
+ LocalUser::update(pool, data.inserted_local_user.id, &local_user_form)
+ .await
+ .unwrap();
+
+ let read_post_listing = PostQuery::builder()
+ .pool(pool)
+ .sort(Some(SortType::New))
+ .community_id(Some(data.inserted_community.id))
+ .local_user(Some(&inserted_local_user))
+ .build()
+ .list()
+ .await
+ .unwrap();
+ assert_eq!(1, read_post_listing.len());
+
+ assert_eq!(expected_post_with_upvote, read_post_listing[0]);
+
let like_removed = PostLike::remove(pool, data.inserted_person.id, data.inserted_post.id)
.await
.unwrap();
#[serial]
async fn post_listing_person_language() {
let pool = &build_db_pool_for_tests().await;
+ let pool = &mut pool.into();
let data = init_data(pool).await;
let spanish_id = Language::read_id_from_code(pool, Some("es"))
.await
.unwrap();
- // only one french language post should be returned
- assert_eq!(1, post_listing_french.len());
- assert_eq!(french_id, post_listing_french[0].post.language_id);
+ // only one post in french and one undetermined should be returned
+ assert_eq!(2, post_listing_french.len());
+ assert!(post_listing_french
+ .iter()
+ .any(|p| p.post.language_id == french_id));
LocalUserLanguage::update(
pool,
cleanup(data, pool).await;
}
- async fn cleanup(data: Data, pool: &DbPool) {
+ #[tokio::test]
+ #[serial]
+ async fn post_listings_deleted() {
+ let pool = &build_db_pool_for_tests().await;
+ let pool = &mut pool.into();
+ let data = init_data(pool).await;
+
+ // Delete the post
+ Post::update(
+ pool,
+ data.inserted_post.id,
+ &PostUpdateForm::builder().deleted(Some(true)).build(),
+ )
+ .await
+ .unwrap();
+
+ // Make sure you don't see the deleted post in the results
+ let post_listings_no_admin = PostQuery::builder()
+ .pool(pool)
+ .sort(Some(SortType::New))
+ .local_user(Some(&data.inserted_local_user))
+ .is_mod_or_admin(Some(false))
+ .build()
+ .list()
+ .await
+ .unwrap();
+
+ assert_eq!(1, post_listings_no_admin.len());
+
+ // Make sure they see both
+ let post_listings_is_admin = PostQuery::builder()
+ .pool(pool)
+ .sort(Some(SortType::New))
+ .local_user(Some(&data.inserted_local_user))
+ .is_mod_or_admin(Some(true))
+ .build()
+ .list()
+ .await
+ .unwrap();
+
+ assert_eq!(2, post_listings_is_admin.len());
+
+ cleanup(data, pool).await;
+ }
+
+ async fn cleanup(data: Data, pool: &mut DbPool<'_>) {
let num_deleted = Post::delete(pool, data.inserted_post.id).await.unwrap();
Community::delete(pool, data.inserted_community.id)
.await
assert_eq!(1, num_deleted);
}
- async fn expected_post_view(data: &Data, pool: &DbPool) -> PostView {
+ async fn expected_post_view(data: &Data, pool: &mut DbPool<'_>) -> PostView {
let (inserted_person, inserted_community, inserted_post) = (
&data.inserted_person,
&data.inserted_community,
newest_comment_time: inserted_post.published,
featured_community: false,
featured_local: false,
+ hot_rank: 1728,
+ hot_rank_active: 1728,
},
subscribed: SubscribedType::NotSubscribed,
read: false,
projects / lemmy.git / blobdiff