mirrors/lemmy
1
0
Fork 0
mirror of https://github.com/LemmyNet/lemmy.git synced 2025-02-08 15:12:50 +00:00
Code Issues Projects Releases Wiki Activity

Fixing mark all as read route, changing mark read to SuccessResponse.

Browse source
This commit is contained in:
Dessalines 2025-01-14 17:58:10 -05:00
parent ee4cc5925a
commit 8f39568760
12 changed files with 16 additions and 761 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

19
crates/api/src/local_user/notifications/mark_comment_mention_read.rs
View file

@ -1,14 +1,14 @@
use actix_web::web::{Data, Json};
use lemmy_api_common::{
context::LemmyContext,
person::{MarkPersonCommentMentionAsRead, PersonCommentMentionResponse},
person::MarkPersonCommentMentionAsRead,
SuccessResponse,
};
use lemmy_db_schema::{
source::person_comment_mention::{PersonCommentMention, PersonCommentMentionUpdateForm},
traits::Crud,
};
use lemmy_db_views::structs::LocalUserView;
use lemmy_db_views_actor::structs::PersonCommentMentionView;
use lemmy_utils::error::{LemmyErrorExt, LemmyErrorType, LemmyResult};
#[tracing::instrument(skip(context))]
@ -16,7 +16,7 @@ pub async fn mark_comment_mention_as_read(
data: Json<MarkPersonCommentMentionAsRead>,
context: Data<LemmyContext>,
local_user_view: LocalUserView,
) -> LemmyResult<Json<PersonCommentMentionResponse>> {
) -> LemmyResult<Json<SuccessResponse>> {
let person_comment_mention_id = data.person_comment_mention_id;
let read_person_comment_mention =
PersonCommentMention::read(&mut context.pool(), person_comment_mention_id).await?;
@ -35,16 +35,5 @@ pub async fn mark_comment_mention_as_read(
.await
.with_lemmy_type(LemmyErrorType::CouldntUpdateComment)?;
let person_comment_mention_id = read_person_comment_mention.id;
let person_id = local_user_view.person.id;
let person_comment_mention_view = PersonCommentMentionView::read(
&mut context.pool(),
person_comment_mention_id,
Some(person_id),
)
.await?;
Ok(Json(PersonCommentMentionResponse {
person_comment_mention_view,
}))
Ok(Json(SuccessResponse::default()))
}

16
crates/api/src/local_user/notifications/mark_post_mention_read.rs
View file

@ -1,14 +1,14 @@
use actix_web::web::{Data, Json};
use lemmy_api_common::{
context::LemmyContext,
person::{MarkPersonPostMentionAsRead, PersonPostMentionResponse},
person::MarkPersonPostMentionAsRead,
SuccessResponse,
};
use lemmy_db_schema::{
source::person_post_mention::{PersonPostMention, PersonPostMentionUpdateForm},
traits::Crud,
};
use lemmy_db_views::structs::LocalUserView;
use lemmy_db_views_actor::structs::PersonPostMentionView;
use lemmy_utils::error::{LemmyErrorExt, LemmyErrorType, LemmyResult};
#[tracing::instrument(skip(context))]
@ -16,7 +16,7 @@ pub async fn mark_post_mention_as_read(
data: Json<MarkPersonPostMentionAsRead>,
context: Data<LemmyContext>,
local_user_view: LocalUserView,
) -> LemmyResult<Json<PersonPostMentionResponse>> {
) -> LemmyResult<Json<SuccessResponse>> {
let person_post_mention_id = data.person_post_mention_id;
let read_person_post_mention =
PersonPostMention::read(&mut context.pool(), person_post_mention_id).await?;
@ -35,13 +35,5 @@ pub async fn mark_post_mention_as_read(
.await
.with_lemmy_type(LemmyErrorType::CouldntUpdatePost)?;
let person_post_mention_id = read_person_post_mention.id;
let person_id = local_user_view.person.id;
let person_post_mention_view =
PersonPostMentionView::read(&mut context.pool(), person_post_mention_id, Some(person_id))
.await?;
Ok(Json(PersonPostMentionResponse {
person_post_mention_view,
}))
Ok(Json(SuccessResponse::default()))
}

15
crates/api/src/local_user/notifications/mark_reply_read.rs
View file

@ -1,14 +1,10 @@
use actix_web::web::{Data, Json};
use lemmy_api_common::{
context::LemmyContext,
person::{CommentReplyResponse, MarkCommentReplyAsRead},
};
use lemmy_api_common::{context::LemmyContext, person::MarkCommentReplyAsRead, SuccessResponse};
use lemmy_db_schema::{
source::comment_reply::{CommentReply, CommentReplyUpdateForm},
traits::Crud,
};
use lemmy_db_views::structs::LocalUserView;
use lemmy_db_views_actor::structs::CommentReplyView;
use lemmy_utils::error::{LemmyErrorExt, LemmyErrorType, LemmyResult};
#[tracing::instrument(skip(context))]
@ -16,7 +12,7 @@ pub async fn mark_reply_as_read(
data: Json<MarkCommentReplyAsRead>,
context: Data<LemmyContext>,
local_user_view: LocalUserView,
) -> LemmyResult<Json<CommentReplyResponse>> {
) -> LemmyResult<Json<SuccessResponse>> {
let comment_reply_id = data.comment_reply_id;
let read_comment_reply = CommentReply::read(&mut context.pool(), comment_reply_id).await?;
@ -35,10 +31,5 @@ pub async fn mark_reply_as_read(
.await
.with_lemmy_type(LemmyErrorType::CouldntUpdateComment)?;
let comment_reply_id = read_comment_reply.id;
let person_id = local_user_view.person.id;
let comment_reply_view =
CommentReplyView::read(&mut context.pool(), comment_reply_id, Some(person_id)).await?;
Ok(Json(CommentReplyResponse { comment_reply_view }))
Ok(Json(SuccessResponse::default()))
}

11
crates/api/src/private_message/mark_read.rs
View file

@ -1,14 +1,14 @@
use actix_web::web::{Data, Json};
use lemmy_api_common::{
context::LemmyContext,
private_message::{MarkPrivateMessageAsRead, PrivateMessageResponse},
private_message::MarkPrivateMessageAsRead,
SuccessResponse,
};
use lemmy_db_schema::{
source::private_message::{PrivateMessage, PrivateMessageUpdateForm},
traits::Crud,
};
use lemmy_db_views::structs::LocalUserView;
use lemmy_db_views_actor::structs::PrivateMessageView;
use lemmy_utils::error::{LemmyErrorExt, LemmyErrorType, LemmyResult};
#[tracing::instrument(skip(context))]
@ -16,7 +16,7 @@ pub async fn mark_pm_as_read(
data: Json<MarkPrivateMessageAsRead>,
context: Data<LemmyContext>,
local_user_view: LocalUserView,
) -> LemmyResult<Json<PrivateMessageResponse>> {
) -> LemmyResult<Json<SuccessResponse>> {
// Checking permissions
let private_message_id = data.private_message_id;
let orig_private_message = PrivateMessage::read(&mut context.pool(), private_message_id).await?;
@ -38,8 +38,5 @@ pub async fn mark_pm_as_read(
.await
.with_lemmy_type(LemmyErrorType::CouldntUpdatePrivateMessage)?;
let view = PrivateMessageView::read(&mut context.pool(), private_message_id).await?;
Ok(Json(PrivateMessageResponse {
private_message_view: view,
}))
Ok(Json(SuccessResponse::default()))
}

27
crates/api_common/src/person.rs
View file

@ -23,12 +23,9 @@ use lemmy_db_views::structs::{
PersonSavedCombinedPaginationCursor,
};
use lemmy_db_views_actor::structs::{
CommentReplyView,
CommunityModeratorView,
InboxCombinedPaginationCursor,
InboxCombinedView,
PersonCommentMentionView,
PersonPostMentionView,
PersonView,
};
use serde::{Deserialize, Serialize};
@ -407,14 +404,6 @@ pub struct MarkPersonCommentMentionAsRead {
pub read: bool,
}
#[derive(Debug, Serialize, Deserialize, Clone)]
#[cfg_attr(feature = "full", derive(TS))]
#[cfg_attr(feature = "full", ts(export))]
/// The response for a person mention action.
pub struct PersonCommentMentionResponse {
pub person_comment_mention_view: PersonCommentMentionView,
}
#[derive(Debug, Serialize, Deserialize, Clone, Copy, Default, PartialEq, Eq, Hash)]
#[cfg_attr(feature = "full", derive(TS))]
#[cfg_attr(feature = "full", ts(export))]
@ -424,14 +413,6 @@ pub struct MarkPersonPostMentionAsRead {
pub read: bool,
}
#[derive(Debug, Serialize, Deserialize, Clone)]
#[cfg_attr(feature = "full", derive(TS))]
#[cfg_attr(feature = "full", ts(export))]
/// The response for a person mention action.
pub struct PersonPostMentionResponse {
pub person_post_mention_view: PersonPostMentionView,
}
#[derive(Debug, Serialize, Deserialize, Clone, Copy, Default, PartialEq, Eq, Hash)]
#[cfg_attr(feature = "full", derive(TS))]
#[cfg_attr(feature = "full", ts(export))]
@ -441,14 +422,6 @@ pub struct MarkCommentReplyAsRead {
pub read: bool,
}
#[derive(Debug, Serialize, Deserialize, Clone)]
#[cfg_attr(feature = "full", derive(TS))]
#[cfg_attr(feature = "full", ts(export))]
/// The response for a comment reply action.
pub struct CommentReplyResponse {
pub comment_reply_view: CommentReplyView,
}
#[derive(Debug, Serialize, Deserialize, Clone, Default, PartialEq, Eq, Hash)]
#[cfg_attr(feature = "full", derive(TS))]
#[cfg_attr(feature = "full", ts(export))]

97
crates/db_views_actor/src/comment_reply_view.rs
View file

@ -1,97 +0,0 @@
use crate::structs::CommentReplyView;
use diesel::{
dsl::exists,
result::Error,
BoolExpressionMethods,
ExpressionMethods,
JoinOnDsl,
NullableExpressionMethods,
QueryDsl,
};
use diesel_async::RunQueryDsl;
use lemmy_db_schema::{
aliases::{self, creator_community_actions},
newtypes::{CommentReplyId, PersonId},
schema::{
comment,
comment_actions,
comment_aggregates,
comment_reply,
community,
community_actions,
local_user,
person,
person_actions,
post,
},
source::community::CommunityFollower,
utils::{actions, actions_alias, get_conn, DbPool},
};
impl CommentReplyView {
pub async fn read(
pool: &mut DbPool<'_>,
comment_reply_id: CommentReplyId,
my_person_id: Option<PersonId>,
) -> Result<Self, Error> {
let conn = &mut get_conn(pool).await?;
let creator_is_admin = exists(
local_user::table.filter(
comment::creator_id
.eq(local_user::person_id)
.and(local_user::admin.eq(true)),
),
);
comment_reply::table
.find(comment_reply_id)
.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(actions(comment_actions::table, my_person_id, comment::id))
.left_join(actions(
community_actions::table,
my_person_id,
post::community_id,
))
.left_join(actions(
person_actions::table,
my_person_id,
comment::creator_id,
))
.left_join(actions_alias(
creator_community_actions,
comment::creator_id,
post::community_id,
))
.select((
comment_reply::all_columns,
comment::all_columns,
person::all_columns,
post::all_columns,
community::all_columns,
aliases::person1.fields(person::all_columns),
comment_aggregates::all_columns,
creator_community_actions
.field(community_actions::received_ban)
.nullable()
.is_not_null(),
community_actions::received_ban.nullable().is_not_null(),
creator_community_actions
.field(community_actions::became_moderator)
.nullable()
.is_not_null(),
creator_is_admin,
CommunityFollower::select_subscribed_type(),
comment_actions::saved.nullable().is_not_null(),
person_actions::blocked.nullable().is_not_null(),
comment_actions::like_score.nullable(),
))
.first(conn)
.await
}
}

1
crates/db_views_actor/src/inbox_combined_view.rs
View file

@ -249,7 +249,6 @@ impl InboxCombinedQuery {
.left_join(person_comment_mention::table)
.left_join(person_post_mention::table)
.left_join(private_message::table.on(private_message_join))
// .left_join(private_message::table)
.left_join(comment::table.on(comment_join))
.left_join(post::table.on(post_join))
.left_join(community::table.on(community_join))

6
crates/db_views_actor/src/lib.rs
View file

@ -1,6 +1,4 @@
#[cfg(feature = "full")]
pub mod comment_reply_view;
#[cfg(feature = "full")]
pub mod community_follower_view;
#[cfg(feature = "full")]
pub mod community_moderator_view;
@ -11,10 +9,6 @@ pub mod community_view;
#[cfg(feature = "full")]
pub mod inbox_combined_view;
#[cfg(feature = "full")]
pub mod person_comment_mention_view;
#[cfg(feature = "full")]
pub mod person_post_mention_view;
#[cfg(feature = "full")]
pub mod person_view;
#[cfg(feature = "full")]
pub mod private_message_view;

97
crates/db_views_actor/src/person_comment_mention_view.rs
View file

@ -1,97 +0,0 @@
use crate::structs::PersonCommentMentionView;
use diesel::{
dsl::exists,
result::Error,
BoolExpressionMethods,
ExpressionMethods,
JoinOnDsl,
NullableExpressionMethods,
QueryDsl,
};
use diesel_async::RunQueryDsl;
use lemmy_db_schema::{
aliases::{self, creator_community_actions},
newtypes::{PersonCommentMentionId, PersonId},
schema::{
comment,
comment_actions,
comment_aggregates,
community,
community_actions,
local_user,
person,
person_actions,
person_comment_mention,
post,
},
source::community::CommunityFollower,
utils::{actions, actions_alias, get_conn, DbPool},
};
impl PersonCommentMentionView {
pub async fn read(
pool: &mut DbPool<'_>,
person_comment_mention_id: PersonCommentMentionId,
my_person_id: Option<PersonId>,
) -> Result<Self, Error> {
let conn = &mut get_conn(pool).await?;
let creator_is_admin = exists(
local_user::table.filter(
comment::creator_id
.eq(local_user::person_id)
.and(local_user::admin.eq(true)),
),
);
person_comment_mention::table
.find(person_comment_mention_id)
.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(actions(
community_actions::table,
my_person_id,
post::community_id,
))
.left_join(actions(comment_actions::table, my_person_id, comment::id))
.left_join(actions(
person_actions::table,
my_person_id,
comment::creator_id,
))
.left_join(actions_alias(
creator_community_actions,
comment::creator_id,
post::community_id,
))
.select((
person_comment_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,
creator_community_actions
.field(community_actions::received_ban)
.nullable()
.is_not_null(),
community_actions::received_ban.nullable().is_not_null(),
creator_community_actions
.field(community_actions::became_moderator)
.nullable()
.is_not_null(),
creator_is_admin,
CommunityFollower::select_subscribed_type(),
comment_actions::saved.nullable().is_not_null(),
person_actions::blocked.nullable().is_not_null(),
comment_actions::like_score.nullable(),
))
.first(conn)
.await
}
}

383
crates/db_views_actor/src/person_mention_view.rs
View file

@ -1,383 +0,0 @@
use crate::structs::PersonMentionView;
use diesel::{
dsl::{exists, not},
pg::Pg,
result::Error,
BoolExpressionMethods,
ExpressionMethods,
JoinOnDsl,
NullableExpressionMethods,
QueryDsl,
};
use diesel_async::RunQueryDsl;
use lemmy_db_schema::{
aliases::{self, creator_community_actions},
newtypes::{PersonId, PersonMentionId},
schema::{
comment,
comment_actions,
comment_aggregates,
community,
community_actions,
local_user,
person,
person_actions,
person_mention,
post,
},
source::{community::CommunityFollower, local_user::LocalUser},
utils::{
actions,
actions_alias,
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 creator_is_admin = exists(
local_user::table.filter(
comment::creator_id
.eq(local_user::person_id)
.and(local_user::admin.eq(true)),
),
);
let all_joins = move |query: person_mention::BoxedQuery<'a, Pg>,
my_person_id: Option<PersonId>| {
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(actions(
community_actions::table,
my_person_id,
post::community_id,
))
.left_join(actions(comment_actions::table, my_person_id, comment::id))
.left_join(actions(
person_actions::table,
my_person_id,
comment::creator_id,
))
.left_join(actions_alias(
creator_community_actions,
comment::creator_id,
post::community_id,
))
.select((
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,
creator_community_actions
.field(community_actions::received_ban)
.nullable()
.is_not_null(),
community_actions::received_ban.nullable().is_not_null(),
creator_community_actions
.field(community_actions::became_moderator)
.nullable()
.is_not_null(),
creator_is_admin,
CommunityFollower::select_subscribed_type(),
comment_actions::saved.nullable().is_not_null(),
person_actions::blocked.nullable().is_not_null(),
comment_actions::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,
)
.first(&mut conn)
.await
};
let list = move |mut conn: DbConn<'a>, o: PersonMentionQuery| async move {
// These filters need to be kept in sync with the filters in
// PersonMentionView::get_unread_mentions()
let mut query = all_joins(person_mention::table.into_boxed(), o.my_person_id);
if let Some(recipient_id) = o.recipient_id {
query = query.filter(person_mention::recipient_id.eq(recipient_id));
}
if o.unread_only {
query = query.filter(person_mention::read.eq(false));
}
if !o.show_bot_accounts {
query = query.filter(not(person::bot_account));
};
query = match o.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()),
};
// Don't show mentions from blocked persons
query = query.filter(person_actions::blocked.is_null());
let (limit, offset) = limit_and_offset(o.page, o.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<'_>,
local_user: &LocalUser,
) -> Result<i64, Error> {
use diesel::dsl::count;
let conn = &mut get_conn(pool).await?;
let mut query = person_mention::table
.inner_join(comment::table)
.left_join(actions(
person_actions::table,
Some(local_user.person_id),
comment::creator_id,
))
.inner_join(person::table.on(comment::creator_id.eq(person::id)))
.into_boxed();
// These filters need to be kept in sync with the filters in queries().list()
if !local_user.show_bot_accounts {
query = query.filter(not(person::bot_account));
}
query
// Don't count replies from blocked users
.filter(person_actions::blocked.is_null())
.filter(person_mention::recipient_id.eq(local_user.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, Clone)]
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
}
}
#[cfg(test)]
mod tests {
use crate::{person_mention_view::PersonMentionQuery, structs::PersonMentionView};
use lemmy_db_schema::{
source::{
comment::{Comment, CommentInsertForm},
community::{Community, CommunityInsertForm},
instance::Instance,
local_user::{LocalUser, LocalUserInsertForm, LocalUserUpdateForm},
person::{Person, PersonInsertForm, PersonUpdateForm},
person_block::{PersonBlock, PersonBlockForm},
person_mention::{PersonMention, PersonMentionInsertForm, PersonMentionUpdateForm},
post::{Post, PostInsertForm},
},
traits::{Blockable, Crud},
utils::build_db_pool_for_tests,
};
use lemmy_db_views::structs::LocalUserView;
use lemmy_utils::error::LemmyResult;
use pretty_assertions::assert_eq;
use serial_test::serial;
#[tokio::test]
#[serial]
async fn test_crud() -> LemmyResult<()> {
let pool = &build_db_pool_for_tests();
let pool = &mut pool.into();
let inserted_instance = Instance::read_or_create(pool, "my_domain.tld".to_string()).await?;
let new_person = PersonInsertForm::test_form(inserted_instance.id, "terrylake");
let inserted_person = Person::create(pool, &new_person).await?;
let recipient_form = PersonInsertForm::test_form(inserted_instance.id, "terrylakes recipient");
let inserted_recipient = Person::create(pool, &recipient_form).await?;
let recipient_id = inserted_recipient.id;
let recipient_local_user =
LocalUser::create(pool, &LocalUserInsertForm::test_form(recipient_id), vec![]).await?;
let new_community = CommunityInsertForm::new(
inserted_instance.id,
"test community lake".to_string(),
"nada".to_owned(),
"pubkey".to_string(),
);
let inserted_community = Community::create(pool, &new_community).await?;
let new_post = PostInsertForm::new(
"A test post".into(),
inserted_person.id,
inserted_community.id,
);
let inserted_post = Post::create(pool, &new_post).await?;
let comment_form = CommentInsertForm::new(
inserted_person.id,
inserted_post.id,
"A test comment".into(),
);
let inserted_comment = Comment::create(pool, &comment_form, None).await?;
let person_mention_form = PersonMentionInsertForm {
recipient_id: inserted_recipient.id,
comment_id: inserted_comment.id,
read: None,
};
let inserted_mention = PersonMention::create(pool, &person_mention_form).await?;
let expected_mention = PersonMention {
id: inserted_mention.id,
recipient_id: inserted_mention.recipient_id,
comment_id: inserted_mention.comment_id,
read: false,
published: inserted_mention.published,
};
let read_mention = PersonMention::read(pool, inserted_mention.id).await?;
let person_mention_update_form = PersonMentionUpdateForm { read: Some(false) };
let updated_mention =
PersonMention::update(pool, inserted_mention.id, &person_mention_update_form).await?;
// Test to make sure counts and blocks work correctly
let unread_mentions =
PersonMentionView::get_unread_mentions(pool, &recipient_local_user).await?;
let query = PersonMentionQuery {
recipient_id: Some(recipient_id),
my_person_id: Some(recipient_id),
sort: None,
unread_only: false,
show_bot_accounts: true,
page: None,
limit: None,
};
let mentions = query.clone().list(pool).await?;
assert_eq!(1, unread_mentions);
assert_eq!(1, mentions.len());
// Block the person, and make sure these counts are now empty
let block_form = PersonBlockForm {
person_id: recipient_id,
target_id: inserted_person.id,
};
PersonBlock::block(pool, &block_form).await?;
let unread_mentions_after_block =
PersonMentionView::get_unread_mentions(pool, &recipient_local_user).await?;
let mentions_after_block = query.clone().list(pool).await?;
assert_eq!(0, unread_mentions_after_block);
assert_eq!(0, mentions_after_block.len());
// Unblock user so we can reuse the same person
PersonBlock::unblock(pool, &block_form).await?;
// Turn Terry into a bot account
let person_update_form = PersonUpdateForm {
bot_account: Some(true),
..Default::default()
};
Person::update(pool, inserted_person.id, &person_update_form).await?;
let recipient_local_user_update_form = LocalUserUpdateForm {
show_bot_accounts: Some(false),
..Default::default()
};
LocalUser::update(
pool,
recipient_local_user.id,
&recipient_local_user_update_form,
)
.await?;
let recipient_local_user_view = LocalUserView::read(pool, recipient_local_user.id).await?;
let unread_mentions_after_hide_bots =
PersonMentionView::get_unread_mentions(pool, &recipient_local_user_view.local_user).await?;
let mut query_without_bots = query.clone();
query_without_bots.show_bot_accounts = false;
let replies_after_hide_bots = query_without_bots.list(pool).await?;
assert_eq!(0, unread_mentions_after_hide_bots);
assert_eq!(0, replies_after_hide_bots.len());
Comment::delete(pool, inserted_comment.id).await?;
Post::delete(pool, inserted_post.id).await?;
Community::delete(pool, inserted_community.id).await?;
Person::delete(pool, inserted_person.id).await?;
Person::delete(pool, inserted_recipient.id).await?;
Instance::delete(pool, inserted_instance.id).await?;
assert_eq!(expected_mention, read_mention);
assert_eq!(expected_mention, inserted_mention);
assert_eq!(expected_mention, updated_mention);
Ok(())
}
}

103
crates/db_views_actor/src/person_post_mention_view.rs
View file

@ -1,103 +0,0 @@
use crate::structs::PersonPostMentionView;
use diesel::{
dsl::exists,
result::Error,
BoolExpressionMethods,
ExpressionMethods,
JoinOnDsl,
NullableExpressionMethods,
QueryDsl,
};
use diesel_async::RunQueryDsl;
use lemmy_db_schema::{
aliases::{self, creator_community_actions},
newtypes::{PersonId, PersonPostMentionId},
schema::{
community,
community_actions,
image_details,
local_user,
person,
person_actions,
person_post_mention,
post,
post_actions,
post_aggregates,
},
source::community::CommunityFollower,
utils::{actions, actions_alias, functions::coalesce, get_conn, DbPool},
};
impl PersonPostMentionView {
pub async fn read(
pool: &mut DbPool<'_>,
person_post_mention_id: PersonPostMentionId,
my_person_id: Option<PersonId>,
) -> Result<Self, Error> {
let conn = &mut get_conn(pool).await?;
let creator_is_admin = exists(
local_user::table.filter(
post::creator_id
.eq(local_user::person_id)
.and(local_user::admin.eq(true)),
),
);
person_post_mention::table
.find(person_post_mention_id)
.inner_join(post::table)
.inner_join(person::table.on(post::creator_id.eq(person::id)))
.inner_join(community::table.on(post::community_id.eq(community::id)))
.inner_join(aliases::person1)
.inner_join(post_aggregates::table.on(post::id.eq(post_aggregates::post_id)))
.left_join(image_details::table.on(post::thumbnail_url.eq(image_details::link.nullable())))
.left_join(actions(
community_actions::table,
my_person_id,
post::community_id,
))
.left_join(actions(post_actions::table, my_person_id, post::id))
.left_join(actions(
person_actions::table,
my_person_id,
post::creator_id,
))
.left_join(actions_alias(
creator_community_actions,
post::creator_id,
post::community_id,
))
.select((
person_post_mention::all_columns,
post::all_columns,
person::all_columns,
community::all_columns,
image_details::all_columns.nullable(),
aliases::person1.fields(person::all_columns),
post_aggregates::all_columns,
creator_community_actions
.field(community_actions::received_ban)
.nullable()
.is_not_null(),
community_actions::received_ban.nullable().is_not_null(),
creator_community_actions
.field(community_actions::became_moderator)
.nullable()
.is_not_null(),
creator_is_admin,
CommunityFollower::select_subscribed_type(),
post_actions::saved.nullable().is_not_null(),
post_actions::read.nullable().is_not_null(),
post_actions::hidden.nullable().is_not_null(),
person_actions::blocked.nullable().is_not_null(),
post_actions::like_score.nullable(),
coalesce(
post_aggregates::comments.nullable() - post_actions::read_comments_amount.nullable(),
post_aggregates::comments,
),
))
.first(conn)
.await
}
}

2
src/api_routes_v4.rs
View file

@ -334,7 +334,7 @@ pub fn config(cfg: &mut ServiceConfig, rate_limit: &RateLimitCell) {
post().to(mark_post_mention_as_read),
)
.route(
"/mention/mark_as_read/all",
"/mark_as_read/all",
post().to(mark_all_notifications_read),
)
.route("/report_count", get().to(report_count))