DEV: Update Category Experts & auto tags when topic is edited (#214)

* DEV: Update Category Experts & auto tags when topic is edited

* Combine query

* lint

* fix spec

* fix query

Author: rngus2344

lib/category_experts/post_handler.rb

@@ -122,6 +122,75 @@ def correct_topic_custom_fields_after_addition(new_post: false)
       add_auto_tag
     end
 
+    def handle_topic_category_change(old_category_id, new_category_id)
+      old_category = Category.find_by(id: old_category_id)
+      new_category = Category.find_by(id: new_category_id)
+
+      # Get all posts in the topic that have expert status
+      expert_posts =
+        Post
+          .includes(:user)
+          .joins(:_custom_fields)
+          .where(
+            topic_id: topic.id,
+            post_custom_fields: {
+              name: CategoryExperts::POST_APPROVED_GROUP_NAME,
+            },
+          )
+          .where.not(post_custom_fields: { value: nil })
+
+      # Re-evaluate each expert post
+      expert_posts.each do |expert_post|
+        post_author = expert_post.user
+        next if !post_author
+
+        # Check if the post author is an expert in the new category
+        author_expert_group_ids = post_author.expert_group_ids_for_category(new_category)
+
+        if author_expert_group_ids.empty?
+          # Author is no longer an expert - remove expert status
+          old_group_name = expert_post.custom_fields[CategoryExperts::POST_APPROVED_GROUP_NAME]
+          expert_post.custom_fields.delete(CategoryExperts::POST_APPROVED_GROUP_NAME)
+          expert_post.custom_fields.delete(CategoryExperts::POST_PENDING_EXPERT_APPROVAL)
+          expert_post.save!
+
+          # Update topic custom fields to reflect the removal
+          CategoryExperts::PostHandler.new(
+            post: expert_post,
+            topic: topic,
+          ).correct_topic_custom_fields_after_removal(group_name: old_group_name)
+        else
+          # Author is still an expert in the new category - update the group name
+          new_expert_group = Group.find_by(id: author_expert_group_ids.first)
+          old_group_name = expert_post.custom_fields[CategoryExperts::POST_APPROVED_GROUP_NAME]
+
+          if new_expert_group && new_expert_group.name != old_group_name
+            # Update post with new group name first
+            expert_post.custom_fields[
+              CategoryExperts::POST_APPROVED_GROUP_NAME
+            ] = new_expert_group.name
+            expert_post.save!
+
+            # Remove old group from topic custom fields (now that post is updated)
+            CategoryExperts::PostHandler.new(
+              post: expert_post,
+              topic: topic,
+            ).correct_topic_custom_fields_after_removal(group_name: old_group_name)
+
+            # Add new group to topic custom fields
+            CategoryExperts::PostHandler.new(
+              post: expert_post,
+              topic: topic,
+              user: post_author,
+            ).correct_topic_custom_fields_after_addition
+          end
+        end
+      end
+
+      # Handle auto-tag changes
+      handle_auto_tag_change(old_category, new_category)
+    end
+
     private
 
     def ensure_poster_is_category_expert
@@ -171,5 +240,29 @@ def auto_tag_for_category
       @auto_tag_for_category =
         @topic.category.custom_fields[CategoryExperts::CATEGORY_EXPERT_AUTO_TAG]
     end
+
+    def handle_auto_tag_change(old_category, new_category)
+      return if !SiteSetting.tagging_enabled
+
+      old_auto_tag = old_category&.custom_fields&.[](CategoryExperts::CATEGORY_EXPERT_AUTO_TAG)
+      new_auto_tag = new_category&.custom_fields&.[](CategoryExperts::CATEGORY_EXPERT_AUTO_TAG)
+
+      existing_tag_names = topic.tags.map(&:name)
+
+      # Determine what tags to add/remove
+      tags_to_remove = old_auto_tag.present? ? [old_auto_tag] : []
+      tags_to_add = new_auto_tag.present? ? [new_auto_tag] : []
+
+      # Only revise if there's actually a change needed
+      if (tags_to_remove.any? && existing_tag_names.include?(old_auto_tag)) ||
+           (tags_to_add.any? && !existing_tag_names.include?(new_auto_tag))
+        new_tag_names = (existing_tag_names - tags_to_remove + tags_to_add).uniq
+
+        PostRevisor.new(topic.ordered_posts.first).revise!(
+          Discourse.system_user,
+          { tags: new_tag_names },
+        )
+      end
+    end
   end
 end

plugin.rb

@@ -354,6 +354,20 @@ class Engine < ::Rails::Engine
     )
   end
 
+  on(:post_edited) do |post, topic_changed, revisor|
+    # Only handle when it's the first post (topic) and the category changed
+    next if !post.is_first_post?
+    next if !topic_changed
+    next if !revisor.topic_diff.has_key?("category_id")
+
+    old_category_id, new_category_id = revisor.topic_diff["category_id"]
+
+    CategoryExperts::PostHandler.new(topic: post.topic).handle_topic_category_change(
+      old_category_id,
+      new_category_id,
+    )
+  end
+
   add_to_class(:group, :category_expert_category_ids) do
     category_ids = []
 

spec/plugin_spec.rb

@@ -217,5 +217,151 @@
         end
       end
     end
+
+    describe "on 'post_edited' with category change" do
+      fab!(:category_b, :category)
+      fab!(:group_b, :group)
+
+      before do
+        category_b.custom_fields[CategoryExperts::CATEGORY_EXPERT_GROUP_IDS] = "#{group_b.id}"
+        category_b.save!
+      end
+
+      context "when topic is moved from category with experts to category without experts" do
+        it "clears all expert custom fields from posts and topic" do
+          expect(
+            original_topic.custom_fields[CategoryExperts::TOPIC_EXPERT_POST_GROUP_NAMES],
+          ).to eq(group.name)
+          expect(original_topic.custom_fields[CategoryExperts::TOPIC_FIRST_EXPERT_POST_ID]).to eq(
+            second_post.post_number,
+          )
+          expect(second_post.custom_fields[CategoryExperts::POST_APPROVED_GROUP_NAME]).to eq(
+            group.name,
+          )
+
+          category_without_experts = Fabricate(:category)
+
+          PostRevisor.new(original_topic.first_post).revise!(
+            admin,
+            category_id: category_without_experts.id,
+          )
+
+          original_topic.reload
+          second_post.reload
+
+          expect(
+            original_topic.custom_fields[CategoryExperts::TOPIC_EXPERT_POST_GROUP_NAMES],
+          ).to be_blank
+          expect(
+            original_topic.custom_fields[CategoryExperts::TOPIC_FIRST_EXPERT_POST_ID],
+          ).to be_blank
+          expect(second_post.custom_fields[CategoryExperts::POST_APPROVED_GROUP_NAME]).to be_blank
+        end
+      end
+
+      context "when topic is moved from one category with experts to another with different experts" do
+        it "updates expert custom fields appropriately when user is not expert in new category" do
+          expect(
+            original_topic.custom_fields[CategoryExperts::TOPIC_EXPERT_POST_GROUP_NAMES],
+          ).to eq(group.name)
+          expect(second_post.custom_fields[CategoryExperts::POST_APPROVED_GROUP_NAME]).to eq(
+            group.name,
+          )
+
+          PostRevisor.new(original_topic.first_post).revise!(admin, category_id: category_b.id)
+
+          original_topic.reload
+          second_post.reload
+
+          expect(
+            original_topic.custom_fields[CategoryExperts::TOPIC_EXPERT_POST_GROUP_NAMES],
+          ).to be_blank
+          expect(second_post.custom_fields[CategoryExperts::POST_APPROVED_GROUP_NAME]).to be_blank
+        end
+
+        it "updates expert group name when user is expert in both categories" do
+          group_b.add(expert)
+
+          expect(
+            original_topic.custom_fields[CategoryExperts::TOPIC_EXPERT_POST_GROUP_NAMES],
+          ).to eq(group.name)
+          expect(second_post.custom_fields[CategoryExperts::POST_APPROVED_GROUP_NAME]).to eq(
+            group.name,
+          )
+
+          PostRevisor.new(original_topic.first_post).revise!(admin, category_id: category_b.id)
+
+          original_topic.reload
+          second_post.reload
+
+          expect(
+            original_topic.custom_fields[CategoryExperts::TOPIC_EXPERT_POST_GROUP_NAMES],
+          ).to eq(group_b.name)
+          expect(second_post.custom_fields[CategoryExperts::POST_APPROVED_GROUP_NAME]).to eq(
+            group_b.name,
+          )
+        end
+
+        context "with multiple expert posts from different users" do
+          fab!(:expert_2) { Fabricate(:user, refresh_auto_groups: true) }
+          fab!(:third_post) { Fabricate(:post, topic: original_topic, user: expert_2) }
+
+          before do
+            group.add(expert_2)
+            CategoryExperts::PostHandler.new(post: third_post, user: expert_2).mark_post_as_approved
+          end
+
+          it "only keeps expert status for users who are experts in new category" do
+            group_b.add(expert)
+
+            expect(
+              original_topic.custom_fields[CategoryExperts::TOPIC_EXPERT_POST_GROUP_NAMES],
+            ).to eq(group.name)
+            expect(second_post.custom_fields[CategoryExperts::POST_APPROVED_GROUP_NAME]).to eq(
+              group.name,
+            )
+            expect(third_post.custom_fields[CategoryExperts::POST_APPROVED_GROUP_NAME]).to eq(
+              group.name,
+            )
+
+            PostRevisor.new(original_topic.first_post).revise!(admin, category_id: category_b.id)
+
+            original_topic.reload
+            second_post.reload
+            third_post.reload
+
+            expect(
+              original_topic.custom_fields[CategoryExperts::TOPIC_EXPERT_POST_GROUP_NAMES],
+            ).to eq(group_b.name)
+            expect(second_post.custom_fields[CategoryExperts::POST_APPROVED_GROUP_NAME]).to eq(
+              group_b.name,
+            )
+            expect(third_post.custom_fields[CategoryExperts::POST_APPROVED_GROUP_NAME]).to be_blank
+          end
+        end
+      end
+
+      context "when topic has auto-tag" do
+        fab!(:auto_tag_b, :tag)
+
+        before do
+          SiteSetting.tagging_enabled = true
+          category_b.custom_fields[CategoryExperts::CATEGORY_EXPERT_AUTO_TAG] = auto_tag_b.name
+          category_b.save!
+        end
+
+        it "removes old auto-tag and adds new auto-tag when category changes" do
+          expect(original_topic.tags.map(&:name)).to include(auto_tag.name)
+          expect(original_topic.tags.map(&:name)).not_to include(auto_tag_b.name)
+
+          PostRevisor.new(original_topic.first_post).revise!(admin, category_id: category_b.id)
+
+          original_topic.reload
+
+          expect(original_topic.tags.map(&:name)).not_to include(auto_tag.name)
+          expect(original_topic.tags.map(&:name)).to include(auto_tag_b.name)
+        end
+      end
+    end
   end
 end