mirror of
https://github.com/LemmyNet/lemmy.git
synced 2024-05-16 00:42:40 +00:00
8e2cbc9a0f
* post_saved * fmt * remove unique and not null * put person_id first in primary key and remove index * use post_saved.find * change captcha_answer * remove removal of not null * comment_aggregates * comment_like * comment_saved * aggregates * remove "\" * deduplicate site_aggregates * person_post_aggregates * community_moderator * community_block * community_person_ban * custom_emoji_keyword * federation allow/block list * federation_queue_state * instance_block * local_site_rate_limit, local_user_language, login_token * person_ban, person_block, person_follower, post_like, post_read, received_activity * community_follower, community_language, site_language * fmt * image_upload * remove unused newtypes * remove more indexes * use .find * merge * fix site_aggregates_site function * fmt * Primary keys dess (#17) * Also order reports by oldest first (ref #4123) (#4129) * Support signed fetch for federation (fixes #868) (#4125) * Support signed fetch for federation (fixes #868) * taplo * add federation queue state to get_federated_instances api (#4104) * add federation queue state to get_federated_instances api * feature gate * move retry sleep function * move stuff around * Add UI setting for collapsing bot comments. Fixes #3838 (#4098) * Add UI setting for collapsing bot comments. Fixes #3838 * Fixing clippy check. * Only keep sent and received activities for 7 days (fixes #4113, fixes #4110) (#4131) * Only check auth secure on release mode. (#4127) * Only check auth secure on release mode. * Fixing wrong js-client. * Adding is_debug_mode var. * Fixing the desktop image on the README. (#4135) * Delete dupes and add possibly missing unique constraint on person_aggregates. * Fixing clippy lints. --------- Co-authored-by: Nutomic <me@nutomic.com> Co-authored-by: phiresky <phireskyde+git@gmail.com> * fmt * Update community_block.rs * Update instance_block.rs * Update person_block.rs * Update person_block.rs --------- Co-authored-by: Dessalines <dessalines@users.noreply.github.com> Co-authored-by: Nutomic <me@nutomic.com> Co-authored-by: phiresky <phireskyde+git@gmail.com>
226 lines
6.6 KiB
Rust
226 lines
6.6 KiB
Rust
use crate::structs::PersonMentionView;
|
|
use diesel::{
|
|
dsl::now,
|
|
pg::Pg,
|
|
result::Error,
|
|
BoolExpressionMethods,
|
|
ExpressionMethods,
|
|
JoinOnDsl,
|
|
NullableExpressionMethods,
|
|
QueryDsl,
|
|
};
|
|
use diesel_async::RunQueryDsl;
|
|
use lemmy_db_schema::{
|
|
aliases,
|
|
newtypes::{PersonId, PersonMentionId},
|
|
schema::{
|
|
comment,
|
|
comment_aggregates,
|
|
comment_like,
|
|
comment_saved,
|
|
community,
|
|
community_follower,
|
|
community_moderator,
|
|
community_person_ban,
|
|
person,
|
|
person_block,
|
|
person_mention,
|
|
post,
|
|
},
|
|
source::community::CommunityFollower,
|
|
utils::{get_conn, limit_and_offset, DbConn, DbPool, ListFn, Queries, ReadFn},
|
|
CommentSortType,
|
|
};
|
|
|
|
fn queries<'a>() -> Queries<
|
|
impl ReadFn<'a, PersonMentionView, (PersonMentionId, Option<PersonId>)>,
|
|
impl ListFn<'a, PersonMentionView, PersonMentionQuery>,
|
|
> {
|
|
let all_joins = |query: person_mention::BoxedQuery<'a, Pg>, my_person_id: Option<PersonId>| {
|
|
// The left join below will return None in this case
|
|
let person_id_join = my_person_id.unwrap_or(PersonId(-1));
|
|
|
|
query
|
|
.inner_join(comment::table)
|
|
.inner_join(person::table.on(comment::creator_id.eq(person::id)))
|
|
.inner_join(post::table.on(comment::post_id.eq(post::id)))
|
|
.inner_join(community::table.on(post::community_id.eq(community::id)))
|
|
.inner_join(aliases::person1)
|
|
.inner_join(comment_aggregates::table.on(comment::id.eq(comment_aggregates::comment_id)))
|
|
.left_join(
|
|
community_follower::table.on(
|
|
post::community_id
|
|
.eq(community_follower::community_id)
|
|
.and(community_follower::person_id.eq(person_id_join)),
|
|
),
|
|
)
|
|
.left_join(
|
|
comment_saved::table.on(
|
|
comment::id
|
|
.eq(comment_saved::comment_id)
|
|
.and(comment_saved::person_id.eq(person_id_join)),
|
|
),
|
|
)
|
|
.left_join(
|
|
person_block::table.on(
|
|
comment::creator_id
|
|
.eq(person_block::target_id)
|
|
.and(person_block::person_id.eq(person_id_join)),
|
|
),
|
|
)
|
|
.left_join(
|
|
comment_like::table.on(
|
|
comment::id
|
|
.eq(comment_like::comment_id)
|
|
.and(comment_like::person_id.eq(person_id_join)),
|
|
),
|
|
)
|
|
};
|
|
|
|
let selection = (
|
|
person_mention::all_columns,
|
|
comment::all_columns,
|
|
person::all_columns,
|
|
post::all_columns,
|
|
community::all_columns,
|
|
aliases::person1.fields(person::all_columns),
|
|
comment_aggregates::all_columns,
|
|
community_person_ban::community_id.nullable().is_not_null(),
|
|
community_moderator::community_id.nullable().is_not_null(),
|
|
CommunityFollower::select_subscribed_type(),
|
|
comment_saved::comment_id.nullable().is_not_null(),
|
|
person_block::person_id.nullable().is_not_null(),
|
|
comment_like::score.nullable(),
|
|
);
|
|
|
|
let read =
|
|
move |mut conn: DbConn<'a>,
|
|
(person_mention_id, my_person_id): (PersonMentionId, Option<PersonId>)| async move {
|
|
all_joins(
|
|
person_mention::table.find(person_mention_id).into_boxed(),
|
|
my_person_id,
|
|
)
|
|
.left_join(
|
|
community_person_ban::table.on(
|
|
community::id
|
|
.eq(community_person_ban::community_id)
|
|
.and(community_person_ban::person_id.eq(comment::creator_id)),
|
|
),
|
|
)
|
|
.left_join(
|
|
community_moderator::table.on(
|
|
community::id
|
|
.eq(community_moderator::community_id)
|
|
.and(community_moderator::person_id.eq(comment::creator_id)),
|
|
),
|
|
)
|
|
.select(selection)
|
|
.first::<PersonMentionView>(&mut conn)
|
|
.await
|
|
};
|
|
|
|
let list = move |mut conn: DbConn<'a>, options: PersonMentionQuery| async move {
|
|
let mut query = all_joins(person_mention::table.into_boxed(), options.my_person_id)
|
|
.left_join(
|
|
community_person_ban::table.on(
|
|
community::id
|
|
.eq(community_person_ban::community_id)
|
|
.and(community_person_ban::person_id.eq(comment::creator_id))
|
|
.and(
|
|
community_person_ban::expires
|
|
.is_null()
|
|
.or(community_person_ban::expires.gt(now)),
|
|
),
|
|
),
|
|
)
|
|
.left_join(
|
|
community_moderator::table.on(
|
|
community::id
|
|
.eq(community_moderator::community_id)
|
|
.and(community_moderator::person_id.eq(comment::creator_id)),
|
|
),
|
|
)
|
|
.select(selection);
|
|
|
|
if let Some(recipient_id) = options.recipient_id {
|
|
query = query.filter(person_mention::recipient_id.eq(recipient_id));
|
|
}
|
|
|
|
if options.unread_only {
|
|
query = query.filter(person_mention::read.eq(false));
|
|
}
|
|
|
|
if !options.show_bot_accounts {
|
|
query = query.filter(person::bot_account.eq(false));
|
|
};
|
|
|
|
query = match options.sort.unwrap_or(CommentSortType::Hot) {
|
|
CommentSortType::Hot => query.then_order_by(comment_aggregates::hot_rank.desc()),
|
|
CommentSortType::Controversial => {
|
|
query.then_order_by(comment_aggregates::controversy_rank.desc())
|
|
}
|
|
CommentSortType::New => query.then_order_by(comment::published.desc()),
|
|
CommentSortType::Old => query.then_order_by(comment::published.asc()),
|
|
CommentSortType::Top => query.order_by(comment_aggregates::score.desc()),
|
|
};
|
|
|
|
let (limit, offset) = limit_and_offset(options.page, options.limit)?;
|
|
|
|
query
|
|
.limit(limit)
|
|
.offset(offset)
|
|
.load::<PersonMentionView>(&mut conn)
|
|
.await
|
|
};
|
|
|
|
Queries::new(read, list)
|
|
}
|
|
|
|
impl PersonMentionView {
|
|
pub async fn read(
|
|
pool: &mut DbPool<'_>,
|
|
person_mention_id: PersonMentionId,
|
|
my_person_id: Option<PersonId>,
|
|
) -> Result<Self, Error> {
|
|
queries()
|
|
.read(pool, (person_mention_id, my_person_id))
|
|
.await
|
|
}
|
|
|
|
/// Gets the number of unread mentions
|
|
pub async fn get_unread_mentions(
|
|
pool: &mut DbPool<'_>,
|
|
my_person_id: PersonId,
|
|
) -> Result<i64, Error> {
|
|
use diesel::dsl::count;
|
|
let conn = &mut get_conn(pool).await?;
|
|
|
|
person_mention::table
|
|
.inner_join(comment::table)
|
|
.filter(person_mention::recipient_id.eq(my_person_id))
|
|
.filter(person_mention::read.eq(false))
|
|
.filter(comment::deleted.eq(false))
|
|
.filter(comment::removed.eq(false))
|
|
.select(count(person_mention::id))
|
|
.first::<i64>(conn)
|
|
.await
|
|
}
|
|
}
|
|
|
|
#[derive(Default)]
|
|
pub struct PersonMentionQuery {
|
|
pub my_person_id: Option<PersonId>,
|
|
pub recipient_id: Option<PersonId>,
|
|
pub sort: Option<CommentSortType>,
|
|
pub unread_only: bool,
|
|
pub show_bot_accounts: bool,
|
|
pub page: Option<i64>,
|
|
pub limit: Option<i64>,
|
|
}
|
|
|
|
impl PersonMentionQuery {
|
|
pub async fn list(self, pool: &mut DbPool<'_>) -> Result<Vec<PersonMentionView>, Error> {
|
|
queries().list(pool, self).await
|
|
}
|
|
}
|