A platform for community discussion. Free, open, simple.
UX: Ignored users reactions/likes should not show up (#39672)
Gabriel Grubbab5f7d4884015
diff --git a/app/controllers/post_action_users_controller.rb b/app/controllers/post_action_users_controller.rbindex 029266a11b0..2d7cd719a7f 100644--- a/app/controllers/post_action_users_controller.rb+++ b/app/controllers/post_action_users_controller.rb@@ -16,9 +16,11 @@ class PostActionUsersController < ApplicationControllerguardian.ensure_can_see!(post)post_actions =- post- .post_actions- .where(post_action_type_id: post_action_type_id)+ filter_ignored_users(post.post_actions.where(post_action_type_id: post_action_type_id))+ filtered_total = post_actions.count if current_user&.ignored_user_ids&.any?++ post_actions =+ post_actions.includes(:user).offset(page * page_size).order("post_actions.created_at ASC")@@ -35,7 +37,7 @@ class PostActionUsersController < ApplicationControllerendaction_type = PostActionType.types.key(post_action_type_id)- total_count = post["#{action_type}_count"].to_i+ total_count = filtered_total || post["#{action_type}_count"].to_ipost_actions = post_actions.to_adata = {post_action_users:@@ -53,6 +55,19 @@ class PostActionUsersController < ApplicationControllerprivate+ def filter_ignored_users(scope)+ return scope if current_user.blank?++ scope.where(<<~SQL, current_user_id: current_user.id)+ NOT EXISTS (+ SELECT 1 FROM ignored_users ig+ WHERE ig.user_id = :current_user_id+ AND ig.ignored_user_id = post_actions.user_id+ AND ig.ignored_user_id <> :current_user_id+ )+ SQL+ end+def current_user_muting_or_ignoring_users(user_ids)return [] if current_user.blank?UserCommScreener.new(diff --git a/app/controllers/posts_controller.rb b/app/controllers/posts_controller.rbindex cc211ed256d..fd2d954f939 100644--- a/app/controllers/posts_controller.rb+++ b/app/controllers/posts_controller.rb@@ -114,6 +114,7 @@ class PostsController < ApplicationControlleradd_excerpt: true,add_title: true,all_post_actions: counts,+ ignored_user_like_counts: PostAction.ignored_user_like_counts_for(posts, current_user),),)end@@ -149,7 +150,15 @@ class PostsController < ApplicationControllerendformat.json do- render_json_dump(serialize_data(posts, PostSerializer, scope: guardian, add_excerpt: true))+ render_json_dump(+ serialize_data(+ posts,+ PostSerializer,+ scope: guardian,+ add_excerpt: true,+ ignored_user_like_counts: PostAction.ignored_user_like_counts_for(posts, current_user),+ ),+ )endendenddiff --git a/app/models/post_action.rb b/app/models/post_action.rbindex 977d85620f9..b01dc81ce05 100644--- a/app/models/post_action.rb+++ b/app/models/post_action.rb@@ -37,6 +37,23 @@ class PostAction < ActiveRecord::Baseuser_actionsend+ def self.ignored_user_like_counts_for(posts, user)+ return {} if posts.blank? || user.blank?++ ignored_ids = user.ignored_user_ids+ return {} if ignored_ids.empty?++ PostAction+ .where(+ post_id: posts.map(&:id),+ user_id: ignored_ids,+ post_action_type_id: PostActionType::LIKE_POST_ACTION_ID,+ deleted_at: nil,+ )+ .group(:post_id)+ .count+ end+def self.lookup_for(user, topics, post_action_type_id)return if topics.blank?# in critical path 2x faster than ARdiff --git a/app/serializers/post_serializer.rb b/app/serializers/post_serializer.rbindex ce875989308..cd764d6e1a7 100644--- a/app/serializers/post_serializer.rb+++ b/app/serializers/post_serializer.rb@@ -12,6 +12,7 @@ class PostSerializer < BasicPostSerializerall_post_actionsadd_excerptnotice_created_by_users+ ignored_user_like_counts]INSTANCE_VARS.each { |v| self.public_send(:attr_accessor, v) }@@ -335,11 +336,13 @@ class PostSerializer < BasicPostSerializer@topic_view ? @topic_view.post_action_type_view : PostActionTypeView.newpublic_flag_types = @post_action_type_view.public_types+ ignored_like_count = ignored_like_count_for_viewer@post_action_type_view.types.each do |sym, id|count_col = "#{sym}_count".to_symcount = object.public_send(count_col) if object.respond_to?(count_col)+ count = [count.to_i - ignored_like_count, 0].max if count && sym == :likesummary = { id: id, count: count }if scope.post_can_act?(@@ -389,6 +392,22 @@ class PostSerializer < BasicPostSerializerresultend+ def ignored_like_count_for_viewer+ return 0 if scope.user.blank?+ return @topic_view.ignored_user_like_counts[object.id].to_i if @topic_view+ return @ignored_user_like_counts[object.id].to_i if @ignored_user_like_counts++ ignored_ids = scope.user.ignored_user_ids+ return 0 if ignored_ids.empty?++ PostAction.where(+ post_id: object.id,+ user_id: ignored_ids,+ post_action_type_id: PostActionType::LIKE_POST_ACTION_ID,+ deleted_at: nil,+ ).count+ end+def include_draft_sequence?@draft_sequence.present?enddiff --git a/lib/topic_view.rb b/lib/topic_view.rbindex 9bd38d1ccca..58c55d24958 100644--- a/lib/topic_view.rb+++ b/lib/topic_view.rb@@ -7,6 +7,7 @@ class TopicViewinclude PostDependentCachememoize_for_posts :all_post_actions+ memoize_for_posts :ignored_user_like_countsmemoize_for_posts :reviewable_countsmemoize_for_posts :post_custom_fieldsmemoize_for_posts :user_custom_fields@@ -682,6 +683,10 @@ class TopicView@links ||= TopicLink.topic_map(@guardian, @topic.id)end+ def ignored_user_like_counts+ PostAction.ignored_user_like_counts_for(@posts, @user)+ end+def reviewable_counts@reviewable_counts ||=begindiff --git a/plugins/discourse-reactions/app/controllers/discourse_reactions/custom_reactions_controller.rb b/plugins/discourse-reactions/app/controllers/discourse_reactions/custom_reactions_controller.rbindex d1bb3952346..82413e5d22e 100644--- a/plugins/discourse-reactions/app/controllers/discourse_reactions/custom_reactions_controller.rb+++ b/plugins/discourse-reactions/app/controllers/discourse_reactions/custom_reactions_controller.rb@@ -96,6 +96,12 @@ class DiscourseReactions::CustomReactionsController < ApplicationController.joins(:reaction).where(post_id: post_ids).where.not(discourse_reactions_reactions: { reaction_users_count: nil })+ reaction_users =+ DiscourseReactions::PostReactionsQuery.apply_ignored_users_filter(+ reaction_users,+ user_column: "discourse_reactions_reaction_users.user_id",+ current_user_id: current_user.id,+ )# Guarantee backwards compatibility if someone was calling this endpoint with the old param.# TODO(roman): Remove after the 2.9 release.@@ -135,6 +141,12 @@ class DiscourseReactions::CustomReactionsController < ApplicationController.where("discourse_reactions_reaction_users.id IS NULL").order(created_at: :desc).limit(PAGE_SIZE)+ likes =+ DiscourseReactions::PostReactionsQuery.apply_ignored_users_filter(+ likes,+ user_column: "post_actions.user_id",+ current_user_id: current_user.id,+ )if params[:before_like_id]likes = likes.where("post_actions.id < ?", params[:before_like_id].to_i)@@ -162,6 +174,7 @@ class DiscourseReactions::CustomReactionsController < ApplicationControllerreaction_filter: params[:reaction_value],limit: limit,offset: page * limit,+ current_user_id: current_user&.id,)users =@@ -186,8 +199,10 @@ class DiscourseReactions::CustomReactionsController < ApplicationControllerraise Discourse::InvalidParameters if !postreaction_users = []+ main_reaction_id = DiscourseReactions::Reaction.main_reaction_id+ main_reaction = nil- if !reaction_value || reaction_value == DiscourseReactions::Reaction.main_reaction_id+ if !reaction_value || reaction_value == main_reaction_id# We only want to get likes that don't have an associated ReactionUser# record, which count as a like or there will be double ups for main_reaction_id.likes =@@ -214,14 +229,36 @@ class DiscourseReactions::CustomReactionsController < ApplicationController)likes = likes.where.not(id: historical_reaction_likes.select(:id))+ likes =+ DiscourseReactions::PostReactionsQuery.apply_ignored_users_filter(+ likes,+ user_column: "post_actions.user_id",+ current_user_id: current_user&.id,+ )++ main_reaction =+ DiscourseReactions::Reaction.find_by(reaction_value: main_reaction_id, post_id: post.id)end+ reactions =+ if !reaction_value+ post.reactions.select do |reaction|+ reaction[:reaction_users_count] && reaction[:reaction_value] != main_reaction_id+ end+ elsif reaction_value != main_reaction_id+ post+ .reactions+ .where(reaction_value: reaction_value)+ .select { |reaction| reaction[:reaction_users_count] }+ else+ []+ end++ reactions_for_counts = reactions.dup+ reactions_for_counts << main_reaction if main_reaction&.[](:reaction_users_count)+ reaction_user_counts = filtered_reaction_users_counts(reactions_for_counts)+if likes.present?- main_reaction =- DiscourseReactions::Reaction.find_by(- reaction_value: DiscourseReactions::Reaction.main_reaction_id,- post_id: post.id,- )count = likes.lengthusers = format_likes_users(likes)@@ -231,30 +268,18 @@ class DiscourseReactions::CustomReactionsController < ApplicationControllerif main_reaction && main_reaction[:reaction_users_count](users << get_users(main_reaction)).flatten!users.sort_by! { |user| user[:created_at] }- count += main_reaction.reaction_users_count.to_i+ count += reaction_user_counts[main_reaction.id].to_iendreaction_users << {- id: DiscourseReactions::Reaction.main_reaction_id,+ id: main_reaction_id,count: count,users: users.reverse.slice(0, MAX_USERS_COUNT + 1),}end- if !reaction_value- post- .reactions- .select do |reaction|- reaction[:reaction_users_count] &&- reaction[:reaction_value] != DiscourseReactions::Reaction.main_reaction_id- end- .each { |reaction| reaction_users << format_reaction_user(reaction) }- elsif reaction_value != DiscourseReactions::Reaction.main_reaction_id- post- .reactions- .where(reaction_value: reaction_value)- .select { |reaction| reaction[:reaction_users_count] }- .each { |reaction| reaction_users << format_reaction_user(reaction) }+ reactions.each do |reaction|+ reaction_users << format_reaction_user(reaction, count: reaction_user_counts[reaction.id])endrender_json_dump(reaction_users: reaction_users)@@ -263,8 +288,12 @@ class DiscourseReactions::CustomReactionsController < ApplicationControllerprivatedef get_users(reaction)- reaction- .reaction_users+ DiscourseReactions::PostReactionsQuery+ .apply_ignored_users_filter(+ reaction.reaction_users,+ user_column: "discourse_reactions_reaction_users.user_id",+ current_user_id: current_user&.id,+ ).includes(:user).order("discourse_reactions_reaction_users.created_at desc").limit(MAX_USERS_COUNT + 1)@@ -279,12 +308,30 @@ class DiscourseReactions::CustomReactionsController < ApplicationControllerendend- def format_reaction_user(reaction)- {- id: reaction.reaction_value,- count: reaction.reaction_users_count.to_i,- users: get_users(reaction),- }+ def format_reaction_user(reaction, count:)+ { id: reaction.reaction_value, count: count.to_i, users: get_users(reaction) }+ end++ def filtered_reaction_users_counts(reactions)+ reactions = reactions.compact+ return {} if reactions.blank?++ if current_user.blank? || current_user.ignored_user_ids.empty?+ return(+ reactions.each_with_object({}) do |reaction, counts|+ counts[reaction.id] = reaction.reaction_users_count.to_i+ end+ )+ end++ DiscourseReactions::PostReactionsQuery+ .apply_ignored_users_filter(+ DiscourseReactions::ReactionUser.where(reaction_id: reactions.map(&:id)),+ user_column: "discourse_reactions_reaction_users.user_id",+ current_user_id: current_user.id,+ )+ .group(:reaction_id)+ .countenddef format_like_user(like)diff --git a/plugins/discourse-reactions/lib/discourse_reactions/post_reactions_query.rb b/plugins/discourse-reactions/lib/discourse_reactions/post_reactions_query.rbindex 372a5d61eca..4f7bda1d328 100644--- a/plugins/discourse-reactions/lib/discourse_reactions/post_reactions_query.rb+++ b/plugins/discourse-reactions/lib/discourse_reactions/post_reactions_query.rb@@ -2,16 +2,37 @@module DiscourseReactionsclass PostReactionsQuery- def self.call(post:, reaction_filter: nil, limit: 30, offset: 0)- query = new(post: post, reaction_filter: reaction_filter, limit: limit, offset: offset)+ def self.call(post:, reaction_filter: nil, limit: 30, offset: 0, current_user_id: nil)+ query =+ new(+ post: post,+ reaction_filter: reaction_filter,+ limit: limit,+ offset: offset,+ current_user_id: current_user_id,+ )[query.rows, query.total]end- def initialize(post:, reaction_filter: nil, limit: 30, offset: 0)+ def self.apply_ignored_users_filter(scope, user_column:, current_user_id:)+ return scope if current_user_id.blank?++ scope.where(<<~SQL, current_user_id: current_user_id)+ NOT EXISTS (+ SELECT 1 FROM ignored_users ig+ WHERE ig.user_id = :current_user_id+ AND ig.ignored_user_id = #{user_column}+ AND ig.ignored_user_id <> :current_user_id+ )+ SQL+ end++ def initialize(post:, reaction_filter: nil, limit: 30, offset: 0, current_user_id: nil)@post = post@reaction_filter = reaction_filter@limit = limit@offset = offset+ @current_user_id = current_user_idenddef rows@@ -45,25 +66,28 @@ module DiscourseReactionsdef total@total ||=if specific_reaction?- ReactionUser- .joins(:reaction)- .where(+ filter_ignored_users(+ ReactionUser.joins(:reaction).where(post_id: post.id,discourse_reactions_reactions: {reaction_value: reaction_filter,},- )- .count+ ),+ user_column: "discourse_reactions_reaction_users.user_id",+ ).countelsif main_reaction_filter?plain_likes_scope.countelse- ReactionUser.where(post_id: post.id).count + plain_likes_scope.count+ filter_ignored_users(+ ReactionUser.where(post_id: post.id),+ user_column: "discourse_reactions_reaction_users.user_id",+ ).count + plain_likes_scope.countendendprivate- attr_reader :post, :reaction_filter, :limit, :offset+ attr_reader :post, :reaction_filter, :limit, :offset, :current_user_iddef main_reaction@main_reaction ||= Reaction.main_reaction_id@@ -92,11 +116,13 @@ module DiscourseReactionsmain_reaction: main_reaction,limit: limit,offset: offset,+ current_user_id: current_user_id,}enddef plain_likes_scope- PostAction.where(post_id: post.id).where(shadow_like_filter, like: like_type)+ scope = PostAction.where(post_id: post.id).where(shadow_like_filter, like: like_type)+ filter_ignored_users(scope, user_column: "post_actions.user_id")enddef reactions_select_sql@@ -107,6 +133,7 @@ module DiscourseReactionsINNER JOIN discourse_reactions_reactions dr ON dr.id = drru.reaction_idINNER JOIN users u ON u.id = drru.user_idWHERE drru.post_id = :post_id+ #{ignored_users_filter_sql("drru.user_id")}SQLend@@ -118,7 +145,29 @@ module DiscourseReactionsINNER JOIN users u ON u.id = post_actions.user_idWHERE post_actions.post_id = :post_idAND (#{shadow_like_filter})+ #{ignored_users_filter_sql("post_actions.user_id")}SQLend++ def ignored_users_filter_sql(user_column)+ return "" if current_user_id.blank?++ <<~SQL+ AND NOT EXISTS (+ SELECT 1 FROM ignored_users ig+ WHERE ig.user_id = :current_user_id+ AND ig.ignored_user_id = #{user_column}+ AND ig.ignored_user_id <> :current_user_id+ )+ SQL+ end++ def filter_ignored_users(scope, user_column:)+ self.class.apply_ignored_users_filter(+ scope,+ user_column: user_column,+ current_user_id: current_user_id,+ )+ endendenddiff --git a/plugins/discourse-reactions/lib/discourse_reactions/posts_reaction_loader.rb b/plugins/discourse-reactions/lib/discourse_reactions/posts_reaction_loader.rbindex 39cae78f951..b7a765ca45b 100644--- a/plugins/discourse-reactions/lib/discourse_reactions/posts_reaction_loader.rb+++ b/plugins/discourse-reactions/lib/discourse_reactions/posts_reaction_loader.rb@@ -6,22 +6,8 @@ module DiscourseReactions::PostsReactionLoaderreturn if object.preloaded_post_data(:reactions)posts = object.posts-- ActiveRecord::Associations::Preloader.new(- records: posts,- associations: [:post_actions, { reactions: { reaction_users: :user } }],- ).call-- post_ids = posts.map(&:id).uniq- posts_reaction_users_count = TopicViewSerializer.posts_reaction_users_count(post_ids)- post_actions_with_reaction_users =- DiscourseReactions::TopicViewSerializerExtension.load_post_action_reaction_users_for_posts(- post_ids,- )- posts.each do |post|- post.reaction_users_count = posts_reaction_users_count[post.id].to_i- post.post_actions_with_reaction_users = post_actions_with_reaction_users[post.id] || {}- end+ user = object.respond_to?(:guardian) ? object.guardian.user : nil+ ::ReactionsSerializerHelpers.preload_post_reactions(posts, user)endendenddiff --git a/plugins/discourse-reactions/lib/discourse_reactions/topic_view_serializer_extension.rb b/plugins/discourse-reactions/lib/discourse_reactions/topic_view_serializer_extension.rbindex 0dd9517a2b9..26b6377ee39 100644--- a/plugins/discourse-reactions/lib/discourse_reactions/topic_view_serializer_extension.rb+++ b/plugins/discourse-reactions/lib/discourse_reactions/topic_view_serializer_extension.rb@@ -28,7 +28,20 @@ module DiscourseReactions::TopicViewSerializerExtensionenddef self.prepended(base)- def base.posts_reaction_users_count(post_ids)+ def base.posts_reaction_users_count(post_ids, ignored_user_ids: [])+ ignored_filter =+ if ignored_user_ids.present?+ "AND user_id NOT IN (:ignored_user_ids)"+ else+ ""+ end+ reaction_users_ignored_filter =+ if ignored_user_ids.present?+ "AND discourse_reactions_reaction_users.user_id NOT IN (:ignored_user_ids)"+ else+ ""+ end+posts_reaction_users_count_query =DB.query(<<~SQL,@@ -37,15 +50,18 @@ module DiscourseReactions::TopicViewSerializerExtensionWHERE post_id IN (:post_ids)AND post_action_type_id = :like_idAND deleted_at IS NULL+ #{ignored_filter}UNION ALLSELECT discourse_reactions_reaction_users.user_id, posts.id from postsLEFT JOIN discourse_reactions_reactions ON discourse_reactions_reactions.post_id = posts.idLEFT JOIN discourse_reactions_reaction_users ON discourse_reactions_reaction_users.reaction_id = discourse_reactions_reactions.idWHERE posts.id IN (:post_ids)+ #{reaction_users_ignored_filter}) AS union_subquery WHERE union_subquery.post_ID IS NOT NULL GROUP BY union_subquery.post_idSQLpost_ids: Array.wrap(post_ids),like_id: PostActionType::LIKE_POST_ACTION_ID,+ ignored_user_ids: ignored_user_ids,)posts_reaction_users_count_query.each_with_object({}) do |row, hash|diff --git a/plugins/discourse-reactions/plugin.rb b/plugins/discourse-reactions/plugin.rbindex 3fed861d898..b8118f0fa1a 100644--- a/plugins/discourse-reactions/plugin.rb+++ b/plugins/discourse-reactions/plugin.rb@@ -63,48 +63,49 @@ after_initialize doDiscourse::Application.routes.append { mount DiscourseReactions::Engine, at: "/" }- TopicView.on_preload do |topic_view|- next unless SiteSetting.discourse_reactions_enabled-- posts = topic_view.posts- next if posts.blank?-- ActiveRecord::Associations::Preloader.new(- records: posts,- associations: [:post_actions, { reactions: { reaction_users: :user } }],- ).call-- post_ids = posts.map(&:id).uniq-- reaction_users_count_map = TopicViewSerializer.posts_reaction_users_count(post_ids)- post_actions_with_reaction_users =- DiscourseReactions::TopicViewSerializerExtension.load_post_action_reaction_users_for_posts(- post_ids,- )+ module ReactionsSerializerHelpers+ def self.preload_post_reactions(posts, user)+ posts = Array(posts).compact+ return { reactions: {}, reaction_users_count: {} } if posts.blank?++ ActiveRecord::Associations::Preloader.new(+ records: posts,+ associations: [:post_actions, { reactions: { reaction_users: :user } }],+ ).call++ post_ids = posts.map(&:id).uniq+ ignored_user_ids = user&.ignored_user_ids || []+ ignored_user_ids_set = ignored_user_ids.to_set++ reaction_users_count_map =+ TopicViewSerializer.posts_reaction_users_count(post_ids, ignored_user_ids: ignored_user_ids)+ post_actions_with_reaction_users =+ DiscourseReactions::TopicViewSerializerExtension.load_post_action_reaction_users_for_posts(+ post_ids,+ )- main_reaction = DiscourseReactions::Reaction.main_reaction_id- excluded = DiscourseReactions::Reaction.reactions_excluded_from_like+ main_reaction = DiscourseReactions::Reaction.main_reaction_id+ excluded = DiscourseReactions::Reaction.reactions_excluded_from_like- excluded_filter =- if excluded.present?- "AND dr.reaction_value NOT IN (:excluded)"- else- ""- end+ excluded_filter = excluded.present? ? "AND dr.reaction_value NOT IN (:excluded)" : ""+ ignored_users_filter =+ ignored_user_ids.present? ? "AND pa.user_id NOT IN (:ignored_user_ids)" : ""- sql_params = {- post_ids: post_ids,- like_type: PostActionType::LIKE_POST_ACTION_ID,- main_reaction: main_reaction,- }- sql_params[:excluded] = excluded if excluded.present?+ sql_params = {+ post_ids: post_ids,+ like_type: PostActionType::LIKE_POST_ACTION_ID,+ main_reaction: main_reaction,+ }+ sql_params[:excluded] = excluded if excluded.present?+ sql_params[:ignored_user_ids] = ignored_user_ids if ignored_user_ids.present?- likes_rows = DB.query(<<~SQL, **sql_params)+ likes_rows = DB.query(<<~SQL, **sql_params)SELECT pa.post_id, COUNT(*) as likes_countFROM post_actions paWHERE pa.deleted_at IS NULLAND pa.post_id IN (:post_ids)AND pa.post_action_type_id = :like_type+ #{ignored_users_filter}AND NOT EXISTS (SELECT 1 FROM discourse_reactions_reaction_users druJOIN discourse_reactions_reactions dr ON dr.id = dru.reaction_id@@ -123,46 +124,96 @@ after_initialize doGROUP BY pa.post_idSQL- likes_map = likes_rows.each_with_object({}) { |row, h| h[row.post_id] = row.likes_count }-- precomputed_reactions_map = {}-- posts.each do |post|- post.reaction_users_count = reaction_users_count_map[post.id].to_i- post.post_actions_with_reaction_users = post_actions_with_reaction_users[post.id] || {}+ likes_map =+ likes_rows.each_with_object({}) { |row, hash| hash[row.post_id] = row.likes_count }+ precomputed_reactions_map = {}++ posts.each do |post|+ post.reaction_users_count = reaction_users_count_map[post.id].to_i+ post.post_actions_with_reaction_users = post_actions_with_reaction_users[post.id] || {}++ reactions =+ post+ .emoji_reactions+ .select { |reaction| reaction.reaction_users_count.to_i > 0 }+ .filter_map do |reaction|+ count =+ if ignored_user_ids_set.present?+ reaction.reaction_users.count { |ru| !ignored_user_ids_set.include?(ru.user_id) }+ else+ reaction.reaction_users_count+ end++ next if count.to_i.zero?++ { id: reaction.reaction_value, type: reaction.reaction_type.to_sym, count: count }+ end- emoji_reactions = post.emoji_reactions.select { |r| r.reaction_users_count.to_i > 0 }+ likes = likes_map[post.id] || 0- reactions =- emoji_reactions.map do |reaction|- {- id: reaction.reaction_value,- type: reaction.reaction_type.to_sym,- count: reaction.reaction_users_count,+ if likes > 0+ reaction_likes, reactions =+ reactions.partition { |reaction| reaction[:id] == main_reaction }+ reactions << {+ id: main_reaction,+ type: :emoji,+ count: likes + reaction_likes.sum { |reaction| reaction[:count] },}end- likes = likes_map[post.id] || 0-- if likes > 0- reaction_likes, reactions = reactions.partition { |r| r[:id] == main_reaction }- reactions << {- id: main_reaction,- type: :emoji,- count: likes + reaction_likes.sum { |r| r[:count] },- }+ precomputed_reactions_map[post.id] = reactions.sort_by do |reaction|+ [-reaction[:count].to_i, reaction[:id]]+ end+ post.precomputed_reactions = precomputed_reactions_map[post.id]end- precomputed_reactions_map[post.id] = reactions.sort_by { |r| [-r[:count].to_i, r[:id]] }+ { reactions: precomputed_reactions_map, reaction_users_count: reaction_users_count_map }end+ end- topic_view.set_preloaded_post_data(:reactions, precomputed_reactions_map)- topic_view.set_preloaded_post_data(:reaction_users_count, reaction_users_count_map)+ TopicView.on_preload do |topic_view|+ next unless SiteSetting.discourse_reactions_enabled++ posts = topic_view.posts+ next if posts.blank?++ preloaded = ReactionsSerializerHelpers.preload_post_reactions(posts, topic_view.guardian.user)++ topic_view.set_preloaded_post_data(:reactions, preloaded[:reactions])+ topic_view.set_preloaded_post_data(:reaction_users_count, preloaded[:reaction_users_count])+ end++ TopicList.on_preload do |topics, topic_list|+ next unless SiteSetting.discourse_reactions_enabled+ next if topics.blank?++ should_preload =+ if topic_list.filter == :suggested+ DiscoursePluginRegistry.apply_modifier(+ :include_discourse_reactions_data_on_suggested_topics,+ false,+ topic_list.current_user,+ )+ else+ DiscoursePluginRegistry.apply_modifier(+ :include_discourse_reactions_data_on_topic_list,+ false,+ topic_list.current_user,+ )+ end++ next unless should_preload++ posts = topics.filter_map { |topic| topic.first_post if topic.association(:first_post).loaded? }+ ReactionsSerializerHelpers.preload_post_reactions(posts, topic_list.current_user)end# Helper module for shared reactions serialization logicmodule ReactionsSerializerHelpers- def self.reactions_for_post(post)+ def self.reactions_for_post(post, scope = nil)+ return post.precomputed_reactions unless post.precomputed_reactions.nil?++ ignored_ids = scope&.user&.ignored_user_ids || []reactions = []reaction_users_counting_as_like = Set.new@@ -170,10 +221,17 @@ after_initialize do.emoji_reactions.select { |reaction| reaction[:reaction_users_count] }.each do |reaction|+ count =+ if ignored_ids.any?+ reaction.reaction_users.count { |ru| !ignored_ids.include?(ru.user_id) }+ else+ reaction.reaction_users_count+ end+ next if count.to_i.zero?reactions << {id: reaction.reaction_value,type: reaction.reaction_type.to_sym,- count: reaction.reaction_users_count,+ count: count,}# NOTE: It does not matter if the reaction is currently an enabled one,@@ -188,6 +246,8 @@ after_initialize dolikes_query =post.post_actions.where(post_action_type_id: PostActionType::LIKE_POST_ACTION_ID)+ likes_query = likes_query.where.not(user_id: ignored_ids) if ignored_ids.any?+# Get rid of any PostAction records that match up to a ReactionUser# that is NOT main_reaction_id and is NOT excluded, otherwise we double# up on the count/reaction shown in the UI.@@ -275,9 +335,46 @@ after_initialize do}end- def self.reaction_users_count_for_post(post)+ def self.reaction_users_count_for_post(post, scope = nil)return post.reaction_users_count unless post.reaction_users_count.nil?- TopicViewSerializer.posts_reaction_users_count(post.id)[post.id]++ ignored_ids = scope&.user&.ignored_user_ids || []++ return TopicViewSerializer.posts_reaction_users_count(post.id)[post.id] if ignored_ids.empty?++ DB.query_single(+ <<~SQL,+ SELECT COUNT(DISTINCT user_id) FROM (+ SELECT user_id FROM post_actions+ WHERE post_id = :post_id AND post_action_type_id = :like_id+ AND deleted_at IS NULL AND user_id NOT IN (:ignored_ids)+ UNION+ SELECT drru.user_id FROM discourse_reactions_reaction_users drru+ INNER JOIN discourse_reactions_reactions dr ON dr.id = drru.reaction_id+ WHERE dr.post_id = :post_id AND drru.user_id NOT IN (:ignored_ids)+ ) sub+ SQL+ post_id: post.id,+ ignored_ids: ignored_ids,+ like_id: PostActionType::LIKE_POST_ACTION_ID,+ ).first+ end++ def self.like_action_for_post(post, scope)+ return nil if scope.user.blank?++ if !post.precomputed_reactions.nil? && post.association(:post_actions).loaded?+ post.post_actions.find do |post_action|+ post_action.post_action_type_id == PostActionType.types[:like] &&+ post_action.user_id == scope.user.id && !post_action.trashed?+ end+ else+ PostAction.find_by(+ user_id: scope.user.id,+ post_id: post.id,+ post_action_type_id: PostActionType.types[:like],+ )+ endenddef self.current_user_used_main_reaction_for_post(post, scope)@@ -310,27 +407,16 @@ after_initialize doreturn nil unless topic.first_postpost = topic.first_post- like_action =- (- if scope.user- PostAction.find_by(- user_id: scope.user.id,- post_id: post.id,- post_action_type_id: PostActionType.types[:like],- )- else- nil- end- )+ like_action = like_action_for_post(post, scope){id: post.id,user_id: post.user_id,yours: post.user_id == scope.current_user&.id,- reactions: reactions_for_post(post),+ reactions: reactions_for_post(post, scope),current_user_reaction: current_user_reaction_for_post(post, scope),current_user_used_main_reaction: current_user_used_main_reaction_for_post(post, scope),- reaction_users_count: reaction_users_count_for_post(post) || 0,+ reaction_users_count: reaction_users_count_for_post(post, scope) || 0,likeAction: {canToggle: like_action ? scope.can_delete_post_action?(like_action) : true,},@@ -343,7 +429,7 @@ after_initialize doif map && map.key?(object.id)map[object.id]else- ReactionsSerializerHelpers.reactions_for_post(object)+ ReactionsSerializerHelpers.reactions_for_post(object, scope)endend@@ -356,7 +442,7 @@ after_initialize doif map && map.key?(object.id)map[object.id].to_ielse- ReactionsSerializerHelpers.reaction_users_count_for_post(object)+ ReactionsSerializerHelpers.reaction_users_count_for_post(object, scope).to_iendenddiff --git a/plugins/discourse-reactions/spec/requests/custom_reactions_controller_spec.rb b/plugins/discourse-reactions/spec/requests/custom_reactions_controller_spec.rbindex c5d451f0265..fe5186627d4 100644--- a/plugins/discourse-reactions/spec/requests/custom_reactions_controller_spec.rb+++ b/plugins/discourse-reactions/spec/requests/custom_reactions_controller_spec.rb@@ -456,6 +456,22 @@ describe DiscourseReactions::CustomReactionsController doexpect(parsed[0]["post"]["user"]["id"]).to eq(user_1.id)expect(parsed[0]["reaction"]["id"]).to eq(like.id)end++ it "does not include reactions or likes from ignored users" do+ sign_in(user_1)+ Fabricate(:ignored_user, user: user_1, ignored_user: user_3)+ Fabricate(:ignored_user, user: user_1, ignored_user: user_5)++ get "/discourse-reactions/posts/reactions-received.json",+ params: {+ username: user_1.username,+ include_likes: true,+ }++ usernames = response.parsed_body.map { |reaction| reaction["user"]["username"] }+ expect(usernames).not_to include(user_3.username, user_5.username)+ expect(usernames).to include(user_2.username, user_4.username)+ endenddescribe "#reactions_users_list" do@@ -502,6 +518,32 @@ describe DiscourseReactions::CustomReactionsController doexpect(user_4_rows.size).to eq(1)expect(user_4_rows.first["reaction"]).to eq("hugs")end++ context "with ignored users" do+ it "hides reactions and likes from users the current user has ignored" do+ sign_in(user_1)+ Fabricate(:ignored_user, user: user_1, ignored_user: user_3)+ Fabricate(:ignored_user, user: user_1, ignored_user: user_5)++ get "/discourse-reactions/posts/#{post_2.id}/reactions-users-list.json"++ expect(response.status).to eq(200)+ usernames = response.parsed_body["users"].map { |u| u["username"] }+ expect(usernames).not_to include(user_3.username, user_5.username)+ expect(usernames).to include(user_2.username, user_4.username)+ expect(response.parsed_body["total_rows"]).to eq(usernames.size)+ end++ it "still shows reactions to anonymous viewers" do+ Fabricate(:ignored_user, user: user_1, ignored_user: user_3)++ get "/discourse-reactions/posts/#{post_2.id}/reactions-users-list.json"++ expect(response.status).to eq(200)+ usernames = response.parsed_body["users"].map { |u| u["username"] }+ expect(usernames).to include(user_3.username)+ end+ endenddescribe "#post_reactions_users" do@@ -566,6 +608,64 @@ describe DiscourseReactions::CustomReactionsController doexpect(response.status).to eq(200)end+ context "with ignored users" do+ it "hides ignored users from reactions and likes" do+ sign_in(user_1)+ Fabricate(:ignored_user, user: user_1, ignored_user: user_2)+ Fabricate(:ignored_user, user: user_1, ignored_user: user_5)++ get "/discourse-reactions/posts/#{post_2.id}/reactions-users.json"++ expect(response.status).to eq(200)+ usernames =+ response.parsed_body["reaction_users"].flat_map do |entry|+ entry["users"].map { |u| u["username"] }+ end+ expect(usernames).not_to include(user_2.username, user_5.username)+ expect(usernames).to include(user_1.username, user_3.username, user_4.username)+ end++ it "hides ignored users when filtering by main_reaction (heart)" do+ sign_in(user_1)+ Fabricate(:ignored_user, user: user_1, ignored_user: user_5)++ get "/discourse-reactions/posts/#{post_2.id}/reactions-users.json?reaction_value=#{DiscourseReactions::Reaction.main_reaction_id}"++ expect(response.status).to eq(200)+ usernames =+ response.parsed_body["reaction_users"].flat_map do |entry|+ entry["users"].map { |u| u["username"] }+ end+ expect(usernames).not_to include(user_5.username)+ end++ it "still shows reactions to anonymous viewers" do+ Fabricate(:ignored_user, user: user_1, ignored_user: user_5)++ get "/discourse-reactions/posts/#{post_2.id}/reactions-users.json"++ expect(response.status).to eq(200)+ usernames =+ response.parsed_body["reaction_users"].flat_map do |entry|+ entry["users"].map { |u| u["username"] }+ end+ expect(usernames).to include(user_5.username)+ end++ it "keeps reaction count consistent with the filtered users list" do+ sign_in(user_1)+ Fabricate(:ignored_user, user: user_1, ignored_user: user_2)++ get "/discourse-reactions/posts/#{post_2.id}/reactions-users.json"++ expect(response.status).to eq(200)+ response.parsed_body["reaction_users"].each do |entry|+ expect(entry["users"].length).to eq(entry["count"]),+ "expected count #{entry["count"]} to match #{entry["users"].length} users for #{entry["id"]}"+ end+ end+ end+it "does not double up reactions which also count as likes if the reaction is no longer enabled" dopost_for_enabled_reactions = Fabricate(:post, user: user_2)new_reaction_1 =diff --git a/plugins/discourse-reactions/spec/requests/topics_controller_spec.rb b/plugins/discourse-reactions/spec/requests/topics_controller_spec.rbindex d26bf86721d..965b403b8b8 100644--- a/plugins/discourse-reactions/spec/requests/topics_controller_spec.rb+++ b/plugins/discourse-reactions/spec/requests/topics_controller_spec.rb@@ -71,5 +71,23 @@ describe TopicsController doqueries = track_sql_queries { get "/t/#{post.topic_id}.json" }expect(queries.filter { |q| q.include?("reactions") }.size).to eq(count)end++ it "does not generate N+1 queries when the viewer has ignored users" do+ sign_in(user_1)+ Fabricate(:ignored_user, user: user_1, ignored_user: user_2)++ Fabricate(:reaction_user, reaction: laughing_reaction, user: user_2, post: post)+ Fabricate(:reaction_user, reaction: hugs_reaction, user: user_3, post: post)++ queries = track_sql_queries { get "/t/#{post.topic_id}.json" }+ count = queries.filter { |q| q.include?("reactions") }.size++ Fabricate(:reaction_user, reaction: open_mouth_reaction, user: user_4, post: post)+ Fabricate(:reaction_user, reaction: hugs_reaction, user: Fabricate(:user), post: post)+ Fabricate(:reaction_user, reaction: laughing_reaction, user: Fabricate(:user), post: post)++ queries = track_sql_queries { get "/t/#{post.topic_id}.json" }+ expect(queries.filter { |q| q.include?("reactions") }.size).to eq(count)+ endendenddiff --git a/plugins/discourse-reactions/spec/serializers/op_reactions_data_serializer_spec.rb b/plugins/discourse-reactions/spec/serializers/op_reactions_data_serializer_spec.rbindex 730b116de0f..20a8e954aa8 100644--- a/plugins/discourse-reactions/spec/serializers/op_reactions_data_serializer_spec.rb+++ b/plugins/discourse-reactions/spec/serializers/op_reactions_data_serializer_spec.rb@@ -330,6 +330,32 @@ RSpec.shared_examples "op_reactions_data serializer" do |serializer_class, modifendendend++ context "when serialized through a topic list preload" do+ let(:topic_list_filter) do+ serializer_class == SuggestedTopicSerializer ? :suggested : :latest+ end++ before do+ Fabricate(:ignored_user, user: user_1, ignored_user: user_2)+ reaction = Fabricate(:reaction, reaction_value: "otter", post: first_post)+ Fabricate(:reaction_user, reaction: reaction, user: user_2, post: first_post)+ Fabricate(:reaction_user, reaction: reaction, user: user_3, post: first_post)+ end++ it "uses viewer-specific preloaded reaction counts" do+ topic.allowed_user_ids = []+ topic.allowed_group_ids = []+ preloaded_topic = TopicList.new(topic_list_filter, user_1, [topic]).topics.first+ json =+ serializer_class.new(preloaded_topic, scope: Guardian.new(user_1), root: false).as_json++ expect(json[:op_reactions_data][:reactions]).to contain_exactly(+ { id: "otter", type: :emoji, count: 1 },+ )+ expect(json[:op_reactions_data][:reaction_users_count]).to eq(1)+ end+ endendenddiff --git a/plugins/discourse-reactions/spec/serializers/post_serializer_spec.rb b/plugins/discourse-reactions/spec/serializers/post_serializer_spec.rbindex 43515dabe50..ca22575e9e7 100644--- a/plugins/discourse-reactions/spec/serializers/post_serializer_spec.rb+++ b/plugins/discourse-reactions/spec/serializers/post_serializer_spec.rb@@ -67,6 +67,29 @@ describe PostSerializer doexpect(json[:reaction_users_count]).to eq(4)end+ it "subtracts ignored users' reactions and likes from reactions and reaction_users_count" do+ Fabricate(:ignored_user, user: user_2, ignored_user: user_4)+ Fabricate(:ignored_user, user: user_2, ignored_user: user_3)++ json = PostSerializer.new(post_1, scope: Guardian.new(user_2), root: false).as_json++ expect(json[:reactions]).to contain_exactly({ id: "otter", type: :emoji, count: 2 })+ expect(json[:reaction_users_count]).to eq(2)+ end++ it "does not subtract for anonymous viewers" do+ Fabricate(:ignored_user, user: user_2, ignored_user: user_4)++ json = PostSerializer.new(post_1, scope: Guardian.new, root: false).as_json++ expect(json[:reactions]).to contain_exactly(+ { id: "+1", type: :emoji, count: 1 },+ { id: "heart", type: :emoji, count: 1 },+ { id: "otter", type: :emoji, count: 2 },+ )+ expect(json[:reaction_users_count]).to eq(4)+ end+it "renders custom reactions sorted alphabetically if count is equal" dojson = PostSerializer.new(post_1, scope: Guardian.new(user_1), root: false).as_jsondiff --git a/plugins/discourse-reactions/spec/serializers/topic_view_serializer_spec.rb b/plugins/discourse-reactions/spec/serializers/topic_view_serializer_spec.rbindex ee6e2361fae..3b64ff9c601 100644--- a/plugins/discourse-reactions/spec/serializers/topic_view_serializer_spec.rb+++ b/plugins/discourse-reactions/spec/serializers/topic_view_serializer_spec.rb@@ -85,6 +85,95 @@ describe TopicViewSerializer doendend+ context "with ignored users" do+ fab!(:viewer, :user)+ fab!(:other_user, :user)+ fab!(:ignored, :user)+ fab!(:another_ignored, :user)+ fab!(:post_1, :post)+ fab!(:post_2) { Fabricate(:post, topic: post_1.topic) }+ fab!(:otter) { Fabricate(:reaction, post: post_1, reaction_value: "otter") }+ fab!(:heart) { Fabricate(:reaction, post: post_1, reaction_value: "heart") }+ fab!(:reaction_user_other) { Fabricate(:reaction_user, reaction: otter, user: other_user) }+ fab!(:reaction_user_ignored) { Fabricate(:reaction_user, reaction: otter, user: ignored) }+ fab!(:reaction_user_heart_ignored) do+ Fabricate(:reaction_user, reaction: heart, user: another_ignored)+ end+ fab!(:like_other_post_2) do+ Fabricate(+ :post_action,+ post: post_2,+ user: other_user,+ post_action_type_id: PostActionType::LIKE_POST_ACTION_ID,+ )+ end+ fab!(:like_ignored_post_2) do+ Fabricate(+ :post_action,+ post: post_2,+ user: ignored,+ post_action_type_id: PostActionType::LIKE_POST_ACTION_ID,+ )+ end++ let(:topic) { post_1.topic }++ before do+ SiteSetting.discourse_reactions_like_icon = "heart"+ SiteSetting.discourse_reactions_enabled_reactions = "otter|heart"+ Fabricate(:ignored_user, user: viewer, ignored_user: ignored)+ Fabricate(:ignored_user, user: viewer, ignored_user: another_ignored)+ end++ def serialize_for(user)+ TopicViewSerializer.new(+ TopicView.new(topic, user),+ scope: Guardian.new(user),+ root: false,+ ).as_json+ end++ it "excludes ignored users from preloaded :reactions" do+ json = serialize_for(viewer)++ posts = json[:post_stream][:posts]+ expect(posts[0][:reactions]).to contain_exactly({ id: "otter", type: :emoji, count: 1 })+ expect(posts[1][:reactions]).to contain_exactly({ id: "heart", type: :emoji, count: 1 })+ end++ it "excludes ignored users from preloaded :reaction_users_count" do+ json = serialize_for(viewer)++ posts = json[:post_stream][:posts]+ expect(posts[0][:reaction_users_count]).to eq(1)+ expect(posts[1][:reaction_users_count]).to eq(1)+ end++ it "still shows global counts for anonymous viewers" do+ json = TopicViewSerializer.new(TopicView.new(topic), scope: Guardian.new, root: false).as_json++ posts = json[:post_stream][:posts]+ expect(posts[0][:reactions]).to contain_exactly(+ { id: "otter", type: :emoji, count: 2 },+ { id: "heart", type: :emoji, count: 1 },+ )+ expect(posts[0][:reaction_users_count]).to eq(3)+ expect(posts[1][:reaction_users_count]).to eq(2)+ end++ it "still shows global counts for viewers with no ignored users" do+ json = serialize_for(other_user)++ posts = json[:post_stream][:posts]+ expect(posts[0][:reactions]).to contain_exactly(+ { id: "otter", type: :emoji, count: 2 },+ { id: "heart", type: :emoji, count: 1 },+ )+ expect(posts[0][:reaction_users_count]).to eq(3)+ expect(posts[1][:reaction_users_count]).to eq(2)+ end+ end+describe "only shadow like" dofab!(:user_1, :user)fab!(:post_1) { Fabricate(:post, user: user_1) }diff --git a/spec/requests/post_action_users_controller_spec.rb b/spec/requests/post_action_users_controller_spec.rbindex c6258e06acb..3a298e4a500 100644--- a/spec/requests/post_action_users_controller_spec.rb+++ b/spec/requests/post_action_users_controller_spec.rb@@ -127,6 +127,24 @@ RSpec.describe PostActionUsersController doendit "will return an unknown attribute for muted users" do+ muted_user = Fabricate(:user)+ PostActionCreator.like(muted_user, post)+ regular_user = Fabricate(:user)+ PostActionCreator.like(regular_user, post)+ Fabricate(:muted_user, user: user, muted_user: muted_user)++ get "/post_action_users.json",+ params: {+ id: post.id,+ post_action_type_id: PostActionType.types[:like],+ }+ expect(response.status).to eq(200)+ json_users = response.parsed_body["post_action_users"]+ expect(json_users.find { |u| u["id"] == regular_user.id }["unknown"]).to be_blank+ expect(json_users.find { |u| u["id"] == muted_user.id }["unknown"]).to eq(true)+ end++ it "filters out ignored users from the post action user list" doignored_user = Fabricate(:user)PostActionCreator.like(ignored_user, post)regular_user = Fabricate(:user)@@ -139,9 +157,43 @@ RSpec.describe PostActionUsersController dopost_action_type_id: PostActionType.types[:like],}expect(response.status).to eq(200)- json_users = response.parsed_body["post_action_users"]- expect(json_users.find { |u| u["id"] == regular_user.id }["unknown"]).to be_blank- expect(json_users.find { |u| u["id"] == ignored_user.id }["unknown"]).to eq(true)+ user_ids = response.parsed_body["post_action_users"].map { |u| u["id"] }+ expect(user_ids).to include(regular_user.id)+ expect(user_ids).not_to include(ignored_user.id)+ end++ it "still shows ignored users to anonymous viewers" do+ ignorer = Fabricate(:user)+ ignored_user = Fabricate(:user)+ PostActionCreator.like(ignored_user, post)+ Fabricate(:ignored_user, user: ignorer, ignored_user: ignored_user)++ get "/post_action_users.json",+ params: {+ id: post.id,+ post_action_type_id: PostActionType.types[:like],+ }+ expect(response.status).to eq(200)+ user_ids = response.parsed_body["post_action_users"].map { |u| u["id"] }+ expect(user_ids).to include(ignored_user.id)+ end++ it "reports the filtered total in total_rows_post_action_users" do+ stub_const(described_class, "INDEX_LIMIT", 2) do+ ignored_user = Fabricate(:user)+ PostActionCreator.like(ignored_user, post)+ 3.times { PostActionCreator.like(Fabricate(:user), post) }+ Fabricate(:ignored_user, user: user, ignored_user: ignored_user)++ get "/post_action_users.json",+ params: {+ id: post.id,+ post_action_type_id: PostActionType.types[:like],+ limit: 2,+ }+ expect(response.status).to eq(200)+ expect(response.parsed_body["total_rows_post_action_users"]).to eq(3)+ endendit "does not hide users from the like list when they are not in the actor's PM allowlist" dodiff --git a/spec/requests/posts_controller_spec.rb b/spec/requests/posts_controller_spec.rbindex cc8650b79ee..9703dea5fb1 100644--- a/spec/requests/posts_controller_spec.rb+++ b/spec/requests/posts_controller_spec.rb@@ -3384,6 +3384,23 @@ RSpec.describe PostsController doexpect(body).to include(public_post.topic.slug)end+ it "excludes ignored users' likes from JSON like counts" do+ viewer = Fabricate(:user, refresh_auto_groups: true)+ ignored_liker = Fabricate(:user, refresh_auto_groups: true)+ regular_liker = Fabricate(:user, refresh_auto_groups: true)+ PostActionCreator.like(ignored_liker, public_post)+ PostActionCreator.like(regular_liker, public_post)+ Fabricate(:ignored_user, user: viewer, ignored_user: ignored_liker)+ sign_in(viewer)++ get "/u/#{user.username}/activity.json"++ post_json = response.parsed_body.find { |post| post["id"] == public_post.id }+ like_summary =+ post_json["actions_summary"].find { |action| action["id"] == PostActionType.types[:like] }+ expect(like_summary["count"]).to eq(1)+ end+it "returns 404 if `hide_profile` user option is checked" douser.user_option.update_columns(hide_profile: true)@@ -3565,6 +3582,24 @@ RSpec.describe PostsController doexpect(post_ids).to_not include private_post.idexpect(post_ids).to_not include topicless_post.idend++ it "excludes ignored users' likes from json like counts" do+ viewer = Fabricate(:user, refresh_auto_groups: true)+ ignored_liker = Fabricate(:user, refresh_auto_groups: true)+ regular_liker = Fabricate(:user, refresh_auto_groups: true)+ PostActionCreator.like(ignored_liker, public_post)+ PostActionCreator.like(regular_liker, public_post)+ Fabricate(:ignored_user, user: viewer, ignored_user: ignored_liker)+ sign_in(viewer)++ get "/posts.json"++ post_json =+ response.parsed_body["latest_posts"].find { |post| post["id"] == public_post.id }+ like_summary =+ post_json["actions_summary"].find { |action| action["id"] == PostActionType.types[:like] }+ expect(like_summary["count"]).to eq(1)+ endendenddiff --git a/spec/serializers/post_serializer_spec.rb b/spec/serializers/post_serializer_spec.rbindex 1abefd6cd66..99f553d8425 100644--- a/spec/serializers/post_serializer_spec.rb+++ b/spec/serializers/post_serializer_spec.rb@@ -34,6 +34,82 @@ RSpec.describe PostSerializer doexpect(visible_actions_for(admin).sort).to eq(%i[like notify_user spam])end+ it "subtracts likes from ignored users from the like count" do+ ignored_liker = Fabricate(:user, refresh_auto_groups: true)+ regular_liker = Fabricate(:user, refresh_auto_groups: true)+ PostActionCreator.like(ignored_liker, post)+ PostActionCreator.like(regular_liker, post)+ Fabricate(:ignored_user, user: actor, ignored_user: ignored_liker)+ post.reload++ serializer = PostSerializer.new(post, scope: Guardian.new(actor), root: false)+ like_summary = serializer.actions_summary.find { |a| a[:id] == PostActionType.types[:like] }++ expect(post.like_count).to eq(3)+ expect(like_summary[:count]).to eq(2)+ end++ it "does not adjust the like count for anonymous viewers" do+ ignorer = Fabricate(:user, refresh_auto_groups: true)+ ignored_liker = Fabricate(:user, refresh_auto_groups: true)+ PostActionCreator.like(ignored_liker, post)+ Fabricate(:ignored_user, user: ignorer, ignored_user: ignored_liker)+ post.reload++ serializer = PostSerializer.new(post, scope: Guardian.new, root: false)+ like_summary = serializer.actions_summary.find { |a| a[:id] == PostActionType.types[:like] }++ expect(like_summary[:count]).to eq(post.like_count)+ end++ it "batches ignored-like counts across posts in a topic view" do+ other_post = Fabricate(:post, topic: post.topic)+ ignored_liker = Fabricate(:user, refresh_auto_groups: true)+ PostActionCreator.like(ignored_liker, post)+ PostActionCreator.like(ignored_liker, other_post)+ Fabricate(:ignored_user, user: actor, ignored_user: ignored_liker)++ topic_view = TopicView.new(post.topic, actor)+ queries =+ track_sql_queries do+ topic_view.posts.each do |p|+ serializer = PostSerializer.new(p, scope: Guardian.new(actor), root: false)+ serializer.topic_view = topic_view+ serializer.actions_summary+ end+ end++ per_post_count_queries =+ queries.count { |sql| sql =~ /COUNT.*FROM "post_actions".*post_id" = \d/m }+ expect(per_post_count_queries).to eq(0)+ end++ it "uses preloaded ignored-like counts outside a topic view" do+ other_post = Fabricate(:post, topic: post.topic)+ ignored_liker = Fabricate(:user, refresh_auto_groups: true)+ PostActionCreator.like(ignored_liker, post)+ PostActionCreator.like(ignored_liker, other_post)+ Fabricate(:ignored_user, user: actor, ignored_user: ignored_liker)++ ignored_user_like_counts = PostAction.ignored_user_like_counts_for([post, other_post], actor)++ queries =+ track_sql_queries do+ [post, other_post].each do |p|+ PostSerializer.new(+ p,+ scope: Guardian.new(actor),+ root: false,+ ignored_user_like_counts: ignored_user_like_counts,+ ).actions_summary+ end+ end++ per_post_count_queries =+ queries.count { |sql| sql =~ /COUNT.*FROM "post_actions".*post_id" = \d/m }+ expect(per_post_count_queries).to eq(0)+ end+it "can't flag your own post to notify yourself" doserializer = PostSerializer.new(post, scope: Guardian.new(post.user), root: false)notify_user_action =