From 8f3956876059cd28accbebd746dd487d3821df3f Mon Sep 17 00:00:00 2001 From: Dessalines Date: Tue, 14 Jan 2025 17:58:10 -0500 Subject: [PATCH] Fixing mark all as read route, changing mark read to SuccessResponse. --- .../mark_comment_mention_read.rs | 19 +- .../notifications/mark_post_mention_read.rs | 16 +- .../notifications/mark_reply_read.rs | 15 +- crates/api/src/private_message/mark_read.rs | 11 +- crates/api_common/src/person.rs | 27 -- .../db_views_actor/src/comment_reply_view.rs | 97 ----- .../db_views_actor/src/inbox_combined_view.rs | 1 - crates/db_views_actor/src/lib.rs | 6 - .../src/person_comment_mention_view.rs | 97 ----- .../db_views_actor/src/person_mention_view.rs | 383 ------------------ .../src/person_post_mention_view.rs | 103 ----- src/api_routes_v4.rs | 2 +- 12 files changed, 16 insertions(+), 761 deletions(-) delete mode 100644 crates/db_views_actor/src/comment_reply_view.rs delete mode 100644 crates/db_views_actor/src/person_comment_mention_view.rs delete mode 100644 crates/db_views_actor/src/person_mention_view.rs delete mode 100644 crates/db_views_actor/src/person_post_mention_view.rs diff --git a/crates/api/src/local_user/notifications/mark_comment_mention_read.rs b/crates/api/src/local_user/notifications/mark_comment_mention_read.rs index 4a9c40092..e7091549e 100644 --- a/crates/api/src/local_user/notifications/mark_comment_mention_read.rs +++ b/crates/api/src/local_user/notifications/mark_comment_mention_read.rs @@ -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, context: Data, local_user_view: LocalUserView, -) -> LemmyResult> { +) -> LemmyResult> { 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())) } diff --git a/crates/api/src/local_user/notifications/mark_post_mention_read.rs b/crates/api/src/local_user/notifications/mark_post_mention_read.rs index 35a12c65c..954435cb7 100644 --- a/crates/api/src/local_user/notifications/mark_post_mention_read.rs +++ b/crates/api/src/local_user/notifications/mark_post_mention_read.rs @@ -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, context: Data, local_user_view: LocalUserView, -) -> LemmyResult> { +) -> LemmyResult> { 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())) } diff --git a/crates/api/src/local_user/notifications/mark_reply_read.rs b/crates/api/src/local_user/notifications/mark_reply_read.rs index 5b263145f..4a1017ce1 100644 --- a/crates/api/src/local_user/notifications/mark_reply_read.rs +++ b/crates/api/src/local_user/notifications/mark_reply_read.rs @@ -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, context: Data, local_user_view: LocalUserView, -) -> LemmyResult> { +) -> LemmyResult> { 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())) } diff --git a/crates/api/src/private_message/mark_read.rs b/crates/api/src/private_message/mark_read.rs index 26655caef..128228d6d 100644 --- a/crates/api/src/private_message/mark_read.rs +++ b/crates/api/src/private_message/mark_read.rs @@ -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, context: Data, local_user_view: LocalUserView, -) -> LemmyResult> { +) -> LemmyResult> { // 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())) } diff --git a/crates/api_common/src/person.rs b/crates/api_common/src/person.rs index 036304770..b4a294bf5 100644 --- a/crates/api_common/src/person.rs +++ b/crates/api_common/src/person.rs @@ -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))] diff --git a/crates/db_views_actor/src/comment_reply_view.rs b/crates/db_views_actor/src/comment_reply_view.rs deleted file mode 100644 index 43b527eb6..000000000 --- a/crates/db_views_actor/src/comment_reply_view.rs +++ /dev/null @@ -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, - ) -> Result { - 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 - } -} diff --git a/crates/db_views_actor/src/inbox_combined_view.rs b/crates/db_views_actor/src/inbox_combined_view.rs index 4ecc729d7..5c0405742 100644 --- a/crates/db_views_actor/src/inbox_combined_view.rs +++ b/crates/db_views_actor/src/inbox_combined_view.rs @@ -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)) diff --git a/crates/db_views_actor/src/lib.rs b/crates/db_views_actor/src/lib.rs index d982c4a1f..3f3991734 100644 --- a/crates/db_views_actor/src/lib.rs +++ b/crates/db_views_actor/src/lib.rs @@ -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; diff --git a/crates/db_views_actor/src/person_comment_mention_view.rs b/crates/db_views_actor/src/person_comment_mention_view.rs deleted file mode 100644 index e260e8908..000000000 --- a/crates/db_views_actor/src/person_comment_mention_view.rs +++ /dev/null @@ -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, - ) -> Result { - 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 - } -} diff --git a/crates/db_views_actor/src/person_mention_view.rs b/crates/db_views_actor/src/person_mention_view.rs deleted file mode 100644 index b3d6235d4..000000000 --- a/crates/db_views_actor/src/person_mention_view.rs +++ /dev/null @@ -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)>, - 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| { - 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)| 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::(&mut conn) - .await - }; - - Queries::new(read, list) -} - -impl PersonMentionView { - pub async fn read( - pool: &mut DbPool<'_>, - person_mention_id: PersonMentionId, - my_person_id: Option, - ) -> Result { - 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 { - 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::(conn) - .await - } -} - -#[derive(Default, Clone)] -pub struct PersonMentionQuery { - pub my_person_id: Option, - pub recipient_id: Option, - pub sort: Option, - pub unread_only: bool, - pub show_bot_accounts: bool, - pub page: Option, - pub limit: Option, -} - -impl PersonMentionQuery { - pub async fn list(self, pool: &mut DbPool<'_>) -> Result, 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(()) - } -} diff --git a/crates/db_views_actor/src/person_post_mention_view.rs b/crates/db_views_actor/src/person_post_mention_view.rs deleted file mode 100644 index fd16a0619..000000000 --- a/crates/db_views_actor/src/person_post_mention_view.rs +++ /dev/null @@ -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, - ) -> Result { - 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 - } -} diff --git a/src/api_routes_v4.rs b/src/api_routes_v4.rs index 20691f59e..396320608 100644 --- a/src/api_routes_v4.rs +++ b/src/api_routes_v4.rs @@ -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))