A platform for community discussion. Free, open, simple.
FIX: Moderators can enable plugins when enable_category_type_setup SiteSetting is enabled (#40349)
Juan David Martínez Cubillos7a6c3fcf3f15
diff --git a/app/assets/stylesheets/admin/admin_new_category_setup.scss b/app/assets/stylesheets/admin/admin_new_category_setup.scssindex a7704507899..feeb123b458 100644--- a/app/assets/stylesheets/admin/admin_new_category_setup.scss+++ b/app/assets/stylesheets/admin/admin_new_category_setup.scss@@ -90,5 +90,45 @@border-radius: 0 calc(var(--d-border-radius) - 1px) 0var(--d-border-radius);}++ &__ask-admin-message {+ width: 100%;+ display: flex;+ flex-direction: row;+ justify-content: space-between;+ align-items: center;+ padding: var(--space-3) var(--space-6);+ background-color: var(--tertiary-very-low);+ color: var(--tertiary);+ border-radius: 0 0 var(--d-border-radius) var(--d-border-radius);+ gap: var(--space-6);++ .d-icon {+ color: currentcolor;+ }++ &:hover,+ &:focus-visible {+ background: var(--tertiary);+ color: var(--secondary);+ }++ &-text {+ display: flex;+ align-items: center;+ gap: var(--space-2);+ text-align: left;+ }++ &-link {+ display: flex;+ align-items: center;+ gap: var(--space-1);++ .d-icon {+ font-size: var(--font-down-1);+ }+ }+ }}}diff --git a/app/controllers/categories_controller.rb b/app/controllers/categories_controller.rbindex e8c803be49a..eb09b8d9572 100644--- a/app/controllers/categories_controller.rb+++ b/app/controllers/categories_controller.rb@@ -138,7 +138,7 @@ class CategoriesController < ApplicationControllerendrender json: {- types: Categories::TypeRegistry.list(only_visible: true),+ types: Categories::TypeRegistry.list(only_visible: true, guardian:),counts: counts_by_type,}end@@ -180,42 +180,43 @@ class CategoriesController < ApplicationControllerreturn render json: { errors: [e.message] }, status: :unprocessable_entityend- if @category.save- @category.move_to(position.to_i) if position-- if category_type.present?- type_class = Categories::TypeRegistry.get(category_type.to_sym)- allowed_setting_keys = type_class&.configuration_schema_keys(:category_settings) || []- type_settings = params[:category_type_settings]&.slice(*allowed_setting_keys)&.permit!-- Categories::Configure.call(- guardian:,- params: {- category_id: @category.id,- category_type:,- site_setting_configuration_values: params[:category_type_site_settings],- category_configuration_values: [- category_params[:custom_fields],- type_settings,- ].compact.reduce(:merge),- },- ) do |result|- on_failed_policy(:type_is_available) do- return(- render json: {- errors: [- I18n.t(- "category_types.not_available",- type_name: category_type.capitalize,- ),- ],- },- status: :unprocessable_entity- )+ configure_error = nil++ Category.transaction do+ if @category.save+ @category.move_to(position.to_i) if position++ if category_type.present?+ type_class = Categories::TypeRegistry.get(category_type.to_sym)+ allowed_setting_keys = type_class&.configuration_schema_keys(:category_settings) || []+ type_settings = params[:category_type_settings]&.slice(*allowed_setting_keys)&.permit!++ Categories::Configure.call(+ guardian:,+ params: {+ category_id: @category.id,+ category_type:,+ site_setting_configuration_values: params[:category_type_site_settings],+ category_configuration_values: [+ category_params[:custom_fields],+ type_settings,+ ].compact.reduce(:merge),+ },+ ) do+ on_failed_policy(:type_is_available) do+ configure_error = category_type_unavailable_error(category_type)+ raise ActiveRecord::Rollback+ endendendend+ end++ if configure_error+ return render json: { errors: [configure_error] }, status: :unprocessable_entity+ end+ if @category.persisted?Scheduler::Defer.later "Log staff action create category" do@staff_action_logger.log_category_creation(@category)end@@ -241,7 +242,7 @@ class CategoriesController < ApplicationController# Handles adding or removing category types registered by plugins# based on the multi-type selector in the General tab for categories.- manage_category_types(cat, pending_custom_fields || {})+ return nil unless manage_category_types(cat, pending_custom_fields || {})cat.reloadif params[:category_type_settings].present?@@ -253,6 +254,9 @@ class CategoriesController < ApplicationControllertype_class = Categories::TypeRegistry.get(type_id)next unless type_class+ # Skip plugin-enabling types for non-admins+ next if type_class.enables_plugin? && !guardian.is_admin?+type_values =params[:category_type_settings].slice(*type_class.configuration_schema_keys(:category_settings),@@ -553,6 +557,18 @@ class CategoriesController < ApplicationControllerendend+ def category_type_unavailable_error(category_type)+ type_id = category_type.to_sym+ type_class = Categories::TypeRegistry.get(type_id)++ if type_class&.enables_plugin?+ plugin_name = Categories::TypeRegistry.plugin_display_name(type_id)+ I18n.t("category_types.requires_plugin", type_name: category_type.to_s.humanize, plugin_name:)+ else+ I18n.t("category_types.not_available", type_name: category_type.to_s.humanize)+ end+ end+def manage_category_types(category, pending_custom_fields)# NOTE: The code in this block is pretty similar to what we are doing in# configure_site_settings in Categories::Types::Base, however here we@@ -591,6 +607,19 @@ class CategoriesController < ApplicationControllerremoved_category_types = current_category_types - new_category_typesadded_category_types = new_category_types - current_category_types+ # Preflight availability check for all added types before any mutations.+ # This prevents partial state changes if a type is unavailable.+ added_category_types.each do |category_type|+ type_class = Categories::TypeRegistry.get(category_type)+ unless type_class&.available_for?(guardian)+ render json: {+ errors: [category_type_unavailable_error(category_type)],+ },+ status: :unprocessable_entity+ return false+ end+ end+# Some category custom fields (like# DiscourseSolved::ENABLE_ACCEPTED_ANSWERS_CUSTOM_FIELD) control whether# the type is enabled or not, so we need to remove them from the pending@@ -613,29 +642,11 @@ class CategoriesController < ApplicationControllerendadded_category_types.each do |category_type|- Categories::Configure.call(- guardian:,- params: {- category_id: category.id,- category_type:,- },- ) do |result|- on_failed_policy(:type_is_available) do- return(- render json: {- errors: [- I18n.t(- "category_types.not_available",- type_name: category_type.capitalize,- ),- ],- },- status: :unprocessable_entity- )- end- end+ Categories::Configure.call(guardian:, params: { category_id: category.id, category_type: })endend++ trueenddef topics_per_pagediff --git a/app/models/concerns/roleable.rb b/app/models/concerns/roleable.rbindex 54a84092436..1ee464cbab3 100644--- a/app/models/concerns/roleable.rb+++ b/app/models/concerns/roleable.rb@@ -5,6 +5,7 @@ module Roleableincluded doscope :admins, -> { where(admin: true) }+ scope :active_admins, -> { real.admins.where(active: true) }scope :moderators, -> { where(moderator: true) }scope :staff, -> { where("moderator or admin ") }enddiff --git a/app/serializers/category_serializer.rb b/app/serializers/category_serializer.rbindex c57717288d6..296daeb10f3 100644--- a/app/serializers/category_serializer.rb+++ b/app/serializers/category_serializer.rb@@ -180,6 +180,6 @@ class CategorySerializer < SiteCategorySerializerenddef available_category_types- Categories::TypeRegistry.list(only_visible: true)+ Categories::TypeRegistry.list(only_visible: true, guardian: scope)endenddiff --git a/app/services/categories/configure.rb b/app/services/categories/configure.rbindex d4a7218cc07..bb3904aed49 100644--- a/app/services/categories/configure.rb+++ b/app/services/categories/configure.rb@@ -51,8 +51,8 @@ module CategoriesCategories::TypeRegistry.get(params.category_type)end- def type_is_available(type_class:)- type_class.available?+ def type_is_available(type_class:, guardian:)+ type_class.available_for?(guardian)enddef enable_plugin(type_class:)diff --git a/app/services/categories/type_registry.rb b/app/services/categories/type_registry.rbindex 5d214676463..4f83333ce8b 100644--- a/app/services/categories/type_registry.rb+++ b/app/services/categories/type_registry.rb@@ -31,14 +31,25 @@ module Categoriestypesend- def list(only_visible: false)- types.values.select { |type| only_visible ? type.visible? : true }.map(&:metadata)+ def list(only_visible: false, guardian: nil)+ types+ .values+ .select { |type| only_visible ? type.visible? : true }+ .map { |type| type.metadata(guardian:) }enddef valid?(id)types.key?(id.to_sym)end+ def owner(id)+ owners[id.to_sym]+ end++ def plugin_display_name(id)+ Discourse.plugins_by_name[owner(id)]&.humanized_name+ end+def reset!@types = nil@owners = nildiff --git a/app/services/categories/types/base.rb b/app/services/categories/types/base.rbindex 20ce60439b2..8cb5f8926ca 100644--- a/app/services/categories/types/base.rb+++ b/app/services/categories/types/base.rb@@ -152,6 +152,19 @@ module Categoriesdef enable_pluginend+ # Returns true if this type overrides enable_plugin with actual behavior.+ # Used to determine if admin privileges are required to configure this type.+ def enables_plugin?+ method(:enable_plugin).owner != Categories::Types::Base.singleton_class+ end++ # Returns true if the plugin required by this category type is already enabled.+ # This MUST be overridden by category types that define enable_plugin.+ def plugin_enabled?+ raise NotImplementedError if enables_plugin?+ true+ end+# Configure any category-specific settings or custom fields that are# specific to this category type, including whatever setting or custom# field values make this category type unique.@@ -296,6 +309,14 @@ module Categoriestrueend+ # Checks availability considering both the base available? check and+ # guardian permissions. Types that enable plugins require admin access+ # only when the plugin is not already enabled.+ def available_for?(guardian = nil)+ return false if enables_plugin? && !plugin_enabled? && guardian && !guardian.is_admin?+ available?+ end+# One level above available? to allow for more granular control over visibility.# For example, a category type may not be visible at all if a plugin isn't installed# or if a certain site setting is not enabled, whereas available? is more@@ -369,9 +390,9 @@ module Categoriesend# Used when serializing the category configuration schema to the client.- def metadata+ def metadata(guardian: nil)name = I18n.t("category_types.#{type_id}.name", default: type_id.to_s.titleize)- {+ result = {id: type_id,name: name,title: I18n.t("category_types.#{type_id}.title", default: name),@@ -380,7 +401,19 @@ module Categoriesavailable: available?,visible: visible?,configuration_schema: resolved_configuration_schema,- }.merge(additional_metadata)+ }+ if enables_plugin?+ result[:required_plugin] = Categories::TypeRegistry.plugin_display_name(type_id)+ result[:can_enable_plugin] = available_for?(guardian)+ if !result[:can_enable_plugin]+ result[:contact_admin_username] = most_recently_active_admin&.username+ end+ end+ result.merge(additional_metadata)+ end++ def most_recently_active_admin+ User.active_admins.order(last_seen_at: :desc).firstendprivatediff --git a/config/locales/client.en.yml b/config/locales/client.en.ymlindex 8c0caca17b0..1682ac5a0cc 100644--- a/config/locales/client.en.yml+++ b/config/locales/client.en.yml@@ -5104,7 +5104,9 @@ en:site_settings: "Site settings"choose_type:title: "Choose category type"- requires_plugin: "Requires plugin"+ requires_plugin: "Requires %{plugin_name} plugin"+ unavailable: "Unavailable"+ ask_admin_to_enable_plugin: "Ask an admin to enable the %{plugin_name} plugin"create_category: "Create category"save: "Save category"unsaved_changes: "You have unsaved changes"diff --git a/config/locales/server.en.yml b/config/locales/server.en.ymlindex 24672d0b6dc..63058c00e1f 100644--- a/config/locales/server.en.yml+++ b/config/locales/server.en.yml@@ -913,6 +913,7 @@ en:category_types:not_available: "Category type '%{type_name}' is not available"+ requires_plugin: "Category type '%{type_name}' requires the '%{plugin_name}' plugin to be enabled. Ask an administrator to enable it or create this category."discussion:name: "Discussion"title: "discussion"diff --git a/frontend/discourse/admin/components/upsert-category/general.gjs b/frontend/discourse/admin/components/upsert-category/general.gjsindex a9dc4f1a54e..f9253d84834 100644--- a/frontend/discourse/admin/components/upsert-category/general.gjs+++ b/frontend/discourse/admin/components/upsert-category/general.gjs@@ -15,6 +15,10 @@ import lazyHash from "discourse/helpers/lazy-hash";import { ajax } from "discourse/lib/ajax";import { popupAjaxError } from "discourse/lib/ajax-error";import { uniqueItemsFromArray } from "discourse/lib/array-tools";+import {+ availableCategoryType,+ unavailableBadgeText,+} from "discourse/lib/category-type-utils";import { AUTO_GROUPS, CATEGORY_TEXT_COLORS } from "discourse/lib/constants";import { bind } from "discourse/lib/decorators";import getURL from "discourse/lib/get-url";@@ -612,7 +616,7 @@ export default class UpsertCategoryGeneral extends Component {<divclass={{dConcatClass"category-type-selector__result"- (unless type.available "--unavailable")+ (unless (availableCategoryType type) "--unavailable")(concat "--category-type-" type.id)}}>@@ -623,12 +627,14 @@ export default class UpsertCategoryGeneral extends Component {{{type.name}}- {{#unless type.available}}+ {{#unless (availableCategoryType type)}}<span class="category-type-selector__result-badge"><PluginOutlet@name="category-type-selector-result-badge"@outletArgs={{lazyHash type=type}}- />+ >+ {{unavailableBadgeText type}}+ </PluginOutlet></span>{{/unless}}</div>diff --git a/frontend/discourse/app/components/category-type-cards.gjs b/frontend/discourse/app/components/category-type-cards.gjsindex b0476ff869b..50b8b42af07 100644--- a/frontend/discourse/app/components/category-type-cards.gjs+++ b/frontend/discourse/app/components/category-type-cards.gjs@@ -5,12 +5,19 @@ import { action } from "@ember/object";import { service } from "@ember/service";import PluginOutlet from "discourse/components/plugin-outlet";import lazyHash from "discourse/helpers/lazy-hash";+import {+ askAdminToEnablePluginText,+ availableCategoryType,+ showAskAdminMessage,+ unavailableBadgeText,+} from "discourse/lib/category-type-utils";import dConcatClass from "discourse/ui-kit/helpers/d-concat-class";import dEmoji from "discourse/ui-kit/helpers/d-emoji";-import { i18n } from "discourse-i18n";+import icon from "discourse/ui-kit/helpers/d-icon";export default class CategoryTypeCards extends Component {@service categoryTypeChooser;+ @service composer;@service router;@action@@ -19,20 +26,28 @@ export default class CategoryTypeCards extends Component {this.router.transitionTo("newCategory.tabs", "general");}+ @action+ messageAdmin(type) {+ this.composer.openNewMessage({+ recipients: type.contact_admin_username,+ topicTitle: type.required_plugin,+ });+ }+<template><div class="category-type-cards">{{#each @types as |type|}}<divclass={{dConcatClass"category-type-cards__card"- (unless type.available "--unavailable")+ (unless (availableCategoryType type) "--unavailable")(concat "--category-type-" type.id)}}><buttontype="button"class="category-type-cards__card-select"- disabled={{unless type.available true}}+ disabled={{unless (availableCategoryType type) true}}{{on "click" (fn this.selectType type)}}><span class="category-type-cards__card-icon">@@ -47,21 +62,38 @@ export default class CategoryTypeCards extends Component {</span>{{/if}}</button>- {{#unless type.available}}+ {{#unless (availableCategoryType type)}}<span class="category-type-cards__card-badge"><PluginOutlet@name="category-type-card-top-right-corner"@outletArgs={{lazyHash type=type}}>- {{i18n "category.choose_type.requires_plugin"}}+ {{unavailableBadgeText type}}</PluginOutlet></span>{{/unless}}<div class="category-type-cards__card-bottom">+<PluginOutlet@name="category-type-card-bottom"@outletArgs={{lazyHash type=type}}- />+ >+ {{#if (showAskAdminMessage type)}}+ <button+ type="button"+ class="btn category-type-cards__ask-admin-message"+ {{on "click" (fn this.messageAdmin type)}}+ >+ <span class="category-type-cards__ask-admin-message-text">+ {{icon "envelope"}}+ {{askAdminToEnablePluginText type}}+ </span>+ <span class="category-type-cards__ask-admin-message-link">+ {{icon "arrow-right"}}+ </span>+ </button>+ {{/if}}+ </PluginOutlet></div></div>{{/each}}diff --git a/frontend/discourse/app/lib/category-type-utils.js b/frontend/discourse/app/lib/category-type-utils.jsnew file mode 100644index 00000000000..1123ad0769b--- /dev/null+++ b/frontend/discourse/app/lib/category-type-utils.js@@ -0,0 +1,29 @@+import { i18n } from "discourse-i18n";++export function availableCategoryType(type) {+ if (!type.available) {+ return false;+ } else if (type.required_plugin && !type.can_enable_plugin) {+ return false;+ }+ return true;+}++export function unavailableBadgeText(type) {+ if (type.required_plugin) {+ return i18n("category.choose_type.requires_plugin", {+ plugin_name: type.required_plugin,+ });+ }+ return i18n("category.choose_type.unavailable");+}++export function showAskAdminMessage(type) {+ return type.required_plugin && !type.can_enable_plugin;+}++export function askAdminToEnablePluginText(type) {+ return i18n("category.choose_type.ask_admin_to_enable_plugin", {+ plugin_name: type.required_plugin,+ });+}diff --git a/plugins/discourse-calendar/app/services/discourse_calendar/categories/types/events.rb b/plugins/discourse-calendar/app/services/discourse_calendar/categories/types/events.rbindex 324ce7c29f5..0bda32dff32 100644--- a/plugins/discourse-calendar/app/services/discourse_calendar/categories/types/events.rb+++ b/plugins/discourse-calendar/app/services/discourse_calendar/categories/types/events.rb@@ -16,6 +16,10 @@ module DiscourseCalendarSiteSetting.discourse_post_event_enabled = trueend+ def plugin_enabled?+ SiteSetting.calendar_enabled && SiteSetting.discourse_post_event_enabled+ end+def category_matches?(category)events_calendar_category_ids.include?(category.id)enddiff --git a/plugins/discourse-solved/app/services/discourse_solved/categories/types/support.rb b/plugins/discourse-solved/app/services/discourse_solved/categories/types/support.rbindex 61549cf6c3e..5d0e7593a5d 100644--- a/plugins/discourse-solved/app/services/discourse_solved/categories/types/support.rb+++ b/plugins/discourse-solved/app/services/discourse_solved/categories/types/support.rb@@ -11,6 +11,10 @@ module DiscourseSolvedSiteSetting.solved_enabled = trueend+ def plugin_enabled?+ SiteSetting.solved_enabled+ end+def category_matches?(category)category.enable_accepted_answers?enddiff --git a/plugins/discourse-topic-voting/app/services/discourse_topic_voting/categories/types/ideas.rb b/plugins/discourse-topic-voting/app/services/discourse_topic_voting/categories/types/ideas.rbindex b37f06f0c87..7e1a2c72cf7 100644--- a/plugins/discourse-topic-voting/app/services/discourse_topic_voting/categories/types/ideas.rb+++ b/plugins/discourse-topic-voting/app/services/discourse_topic_voting/categories/types/ideas.rb@@ -15,6 +15,10 @@ module DiscourseTopicVotingSiteSetting.topic_voting_enabled = trueend+ def plugin_enabled?+ SiteSetting.topic_voting_enabled+ end+def category_matches?(category)return false if !SiteSetting.topic_voting_enableddiff --git a/spec/requests/categories_controller_spec.rb b/spec/requests/categories_controller_spec.rbindex e467829caed..18c898f0b8d 100644--- a/spec/requests/categories_controller_spec.rb+++ b/spec/requests/categories_controller_spec.rb@@ -1323,6 +1323,73 @@ RSpec.describe CategoriesController doexpect(response.status).to eq(200)expect(category.reload.locale).to be_nilend++ context "when adding category_types that enable plugins" do+ let(:test_type_class) do+ Class.new(Categories::Types::Base) do+ type_id :test_plugin_type++ def self.enable_plugin+ end++ def self.plugin_enabled?+ false+ end++ def self.category_matches?(category)+ false+ end++ def self.find_matches+ Category.none+ end++ def self.configure_category(category, guardian:, configuration_values: {})+ end++ def self.unconfigure_category(category, guardian:)+ end+ end+ end++ before do+ SiteSetting.enable_simplified_category_creation = true+ plugin = Plugin::Instance.new+ plugin.stubs(:humanized_name).returns("Test")+ Discourse.plugins_by_name["discourse-test-plugin"] = plugin+ Categories::TypeRegistry.register(+ test_type_class,+ plugin_identifier: "discourse-test-plugin",+ )+ end++ after do+ Discourse.plugins_by_name.delete("discourse-test-plugin")+ Categories::TypeRegistry.reset!+ end++ it "returns 422 when a moderator tries to add a plugin-enabling type" do+ sign_in(Fabricate(:moderator))+ SiteSetting.moderators_manage_categories = true++ put "/categories/#{category.id}.json", params: { category_types: %w[test_plugin_type] }++ expect(response.status).to eq(422)+ expect(response.parsed_body["errors"]).to include(+ I18n.t(+ "category_types.requires_plugin",+ type_name: "Test plugin type",+ plugin_name: "Test",+ ),+ )+ end++ it "allows an admin to add a plugin-enabling type" do+ put "/categories/#{category.id}.json", params: { category_types: %w[test_plugin_type] }++ expect(response.status).to eq(200)+ end+ endendenddiff --git a/spec/services/categories/configure_spec.rb b/spec/services/categories/configure_spec.rbindex 949ff83b1d2..4038dbf47d8 100644--- a/spec/services/categories/configure_spec.rb+++ b/spec/services/categories/configure_spec.rb@@ -15,6 +15,19 @@ RSpec.describe Categories::Configure dolet(:params) { { category_id: category.id, category_type: "discussion" } }let(:dependencies) { { guardian: admin.guardian } }+ def build_test_type(id, enables_plugin: false, plugin_enabled: true)+ Class.new(Categories::Types::Base) do+ type_id id++ define_singleton_method(:enable_plugin) {} if enables_plugin+ define_singleton_method(:plugin_enabled?) { plugin_enabled } if enables_plugin+ define_singleton_method(:category_matches?) { |_| false }+ define_singleton_method(:find_matches) { Category.none }+ define_singleton_method(:configure_category) { |_, guardian:, configuration_values: {}| }+ define_singleton_method(:unconfigure_category) { |_, guardian:| }+ end+ end+context "when params are invalid" dolet(:params) { { category_id: nil, category_type: nil } }@@ -46,10 +59,71 @@ RSpec.describe Categories::Configure doit { is_expected.to fail_a_policy(:type_is_available) }end+ context "when type does not enable a plugin (Discussion)" do+ context "when user is a moderator" do+ fab!(:moderator)++ let(:dependencies) { { guardian: moderator.guardian } }++ before { SiteSetting.moderators_manage_categories = true }++ it { is_expected.to run_successfully }+ end+ end++ context "when type enables a plugin that is not yet enabled" do+ let(:test_type_class) do+ build_test_type(:test_plugin_type, enables_plugin: true, plugin_enabled: false)+ end+ let(:params) { { category_id: category.id, category_type: "test_plugin_type" } }++ before { Categories::TypeRegistry.register(test_type_class) }+ after { Categories::TypeRegistry.reset! }++ context "when user is a moderator" do+ fab!(:moderator)++ let(:dependencies) { { guardian: moderator.guardian } }++ before { SiteSetting.moderators_manage_categories = true }++ it { is_expected.to fail_a_policy(:type_is_available) }+ end++ context "when user is an admin" do+ it { is_expected.to run_successfully }+ end+ end++ context "when type enables a plugin that is already enabled" do+ let(:test_type_class) do+ build_test_type(:test_plugin_type_enabled, enables_plugin: true, plugin_enabled: true)+ end+ let(:params) { { category_id: category.id, category_type: "test_plugin_type_enabled" } }++ before { Categories::TypeRegistry.register(test_type_class) }+ after { Categories::TypeRegistry.reset! }++ context "when user is a moderator" do+ fab!(:moderator)++ let(:dependencies) { { guardian: moderator.guardian } }++ before { SiteSetting.moderators_manage_categories = true }++ it { is_expected.to run_successfully }+ end++ context "when user is an admin" do+ it { is_expected.to run_successfully }+ end+ end+context "when everything's ok" doit { is_expected.to run_successfully }it "calls enable_plugin on the type class" do+ Categories::Types::Discussion.stubs(:plugin_enabled?).returns(true)Categories::Types::Discussion.expects(:enable_plugin).onceresultenddiff --git a/spec/services/categories/type_registry_spec.rb b/spec/services/categories/type_registry_spec.rbindex 4680e2c7ae1..56f97f4dfab 100644--- a/spec/services/categories/type_registry_spec.rb+++ b/spec/services/categories/type_registry_spec.rb@@ -47,6 +47,118 @@ RSpec.describe Categories::TypeRegistry doCategories::Types::Discussion.stubs(:visible?).returns(false)expect(described_class.list(only_visible: true)).to be_emptyend++ it "passes guardian to metadata when provided" do+ admin = Fabricate(:admin)+ discussion = described_class.list(guardian: admin.guardian).find { |t| t[:id] == :discussion }++ expect(discussion).to include(available: true)+ end++ context "with a plugin-enabling type" do+ let(:test_type) do+ Class.new(Categories::Types::Base) do+ type_id :test_plugin_list_type++ def self.enable_plugin+ end++ def self.plugin_enabled?+ false+ end++ def self.category_matches?(category)+ false+ end++ def self.find_matches+ Category.none+ end++ def self.configure_category(category, guardian:, configuration_values: {})+ end++ def self.unconfigure_category(category, guardian:)+ end+ end+ end++ before do+ plugin = Plugin::Instance.new+ plugin.stubs(:humanized_name).returns("Test")+ Discourse.plugins_by_name["discourse-test-plugin"] = plugin+ described_class.register(test_type, plugin_identifier: "discourse-test-plugin")+ end++ after do+ Discourse.plugins_by_name.delete("discourse-test-plugin")+ described_class.reset!+ end++ it "returns can_enable_plugin: false for moderators" do+ moderator = Fabricate(:moderator)+ type_metadata =+ described_class+ .list(guardian: moderator.guardian)+ .find { |t| t[:id] == :test_plugin_list_type }++ expect(type_metadata[:available]).to eq(true)+ expect(type_metadata[:can_enable_plugin]).to eq(false)+ expect(type_metadata[:required_plugin]).to eq("Test")+ end++ it "returns can_enable_plugin: true for admins" do+ admin = Fabricate(:admin)+ type_metadata =+ described_class+ .list(guardian: admin.guardian)+ .find { |t| t[:id] == :test_plugin_list_type }++ expect(type_metadata[:available]).to eq(true)+ expect(type_metadata[:can_enable_plugin]).to eq(true)+ expect(type_metadata[:required_plugin]).to eq("Test")+ end+ end+ end++ describe ".owner" do+ let(:test_type) { Class.new(Categories::Types::Base).tap { |t| t.type_id(:test_owner_type) } }++ after { described_class.all.delete(:test_owner_type) }++ it "returns nil for types without a plugin identifier" do+ described_class.register(test_type)+ expect(described_class.owner(:test_owner_type)).to be_nil+ end++ it "returns the plugin identifier for registered types" do+ described_class.register(test_type, plugin_identifier: "discourse-test")+ expect(described_class.owner(:test_owner_type)).to eq("discourse-test")+ end+ end++ describe ".plugin_display_name" do+ let(:test_type) do+ Class.new(Categories::Types::Base).tap { |t| t.type_id(:test_display_name_type) }+ end++ after { described_class.all.delete(:test_display_name_type) }++ it "returns nil for types without a plugin identifier" do+ described_class.register(test_type)+ expect(described_class.plugin_display_name(:test_display_name_type)).to be_nil+ end++ it "returns the plugin humanized name" do+ plugin = Plugin::Instance.new+ plugin.stubs(:humanized_name).returns("Solved")+ Discourse.plugins_by_name["discourse-solved-plugin"] = plugin++ described_class.register(test_type, plugin_identifier: "discourse-solved-plugin")+ expect(described_class.plugin_display_name(:test_display_name_type)).to eq("Solved")+ ensure+ Discourse.plugins_by_name.delete("discourse-solved-plugin")+ endenddescribe ".counts" dodiff --git a/spec/services/categories/types/base_spec.rb b/spec/services/categories/types/base_spec.rbindex 1d3c63a08c5..d815d30585d 100644--- a/spec/services/categories/types/base_spec.rb+++ b/spec/services/categories/types/base_spec.rb@@ -4,6 +4,34 @@ RSpec.describe Categories::Types::Base dofab!(:admin)fab!(:category)+ def build_test_type(id, **options)+ Class.new(described_class) do+ type_id id++ define_singleton_method(:enable_plugin) {} if options.key?(:enable_plugin)++ if options.key?(:plugin_enabled)+ define_singleton_method(:plugin_enabled?) { options[:plugin_enabled] }+ end++ define_singleton_method(:available?) { options[:available] } if options.key?(:available)++ if options.key?(:category_matches)+ define_singleton_method(:category_matches?) { |_| options[:category_matches] }+ end++ if options.key?(:configuration_schema)+ schema = options[:configuration_schema]+ define_singleton_method(:configuration_schema) { schema }+ end++ if options.key?(:additional_metadata)+ meta = options[:additional_metadata]+ define_singleton_method(:additional_metadata) { meta }+ end+ end+ end+describe ".type_id" doit "can be explicitly set" dotest_type = Class.new(described_class)@@ -13,6 +41,70 @@ RSpec.describe Categories::Types::Base doendend+ describe ".enables_plugin?" do+ it "returns false when enable_plugin is not overridden" do+ test_type = build_test_type(:no_plugin)++ expect(test_type.enables_plugin?).to eq(false)+ end++ it "returns true when enable_plugin is overridden" do+ test_type = build_test_type(:with_plugin, enable_plugin: true)++ expect(test_type.enables_plugin?).to eq(true)+ end+ end++ describe ".plugin_enabled?" do+ it "returns true when enable_plugin is not overridden" do+ test_type = build_test_type(:no_plugin)++ expect(test_type.plugin_enabled?).to eq(true)+ end++ it "raises NotImplementedError when enable_plugin is overridden but plugin_enabled? is not" do+ test_type = build_test_type(:with_plugin, enable_plugin: true)++ expect { test_type.plugin_enabled? }.to raise_error(NotImplementedError)+ end+ end++ describe ".available_for?" do+ fab!(:moderator)++ it "returns true for types that don't enable plugins regardless of guardian" do+ test_type = build_test_type(:no_plugin_type)++ expect(test_type.available_for?(admin.guardian)).to eq(true)+ expect(test_type.available_for?(moderator.guardian)).to eq(true)+ expect(test_type.available_for?).to eq(true)+ end++ it "returns true for plugin-enabling types when user is admin and plugin is not enabled" do+ test_type = build_test_type(:plugin_type, enable_plugin: true, plugin_enabled: false)++ expect(test_type.available_for?(admin.guardian)).to eq(true)+ end++ it "returns false for plugin-enabling types when user is not admin and plugin is not enabled" do+ test_type = build_test_type(:plugin_type_mod, enable_plugin: true, plugin_enabled: false)++ expect(test_type.available_for?(moderator.guardian)).to eq(false)+ end++ it "returns true for plugin-enabling types when user is not admin but plugin is already enabled" do+ test_type = build_test_type(:plugin_type_enabled, enable_plugin: true, plugin_enabled: true)++ expect(test_type.available_for?(moderator.guardian)).to eq(true)+ end++ it "respects the base available? method" do+ test_type = build_test_type(:unavailable_type, available: false)++ expect(test_type.available_for?(admin.guardian)).to eq(false)+ end+ end+describe ".metadata" doit "returns type information including configuration_schema" doexpect(described_class.metadata).to include(@@ -32,13 +124,7 @@ RSpec.describe Categories::Types::Base doit "is merged into metadata when overridden by a subclass" dotest_type =- Class.new(described_class) do- type_id :with_extra_metadata-- def self.additional_metadata- { feature_flags: %w[a b] }- end- end+ build_test_type(:with_extra_metadata, additional_metadata: { feature_flags: %w[a b] })expect(test_type.metadata).to include(feature_flags: %w[a b])end@@ -47,13 +133,14 @@ RSpec.describe Categories::Types::Base dodescribe ".configure_site_settings" doit "applies site settings from configuration_schema defaults" dotest_type =- Class.new(described_class) do- type_id :test_configure-- def self.configuration_schema- { site_settings: { title: "Configured Forum" } }- end- end+ build_test_type(+ :test_configure,+ configuration_schema: {+ site_settings: {+ title: "Configured Forum",+ },+ },+ )test_type.configure_site_settings(category, guardian: admin.guardian)expect(SiteSetting.title).to eq("Configured Forum")@@ -61,13 +148,14 @@ RSpec.describe Categories::Types::Base doit "prefers configuration_values over defaults" dotest_type =- Class.new(described_class) do- type_id :test_configure_override-- def self.configuration_schema- { site_settings: { title: "Default" } }- end- end+ build_test_type(+ :test_configure_override,+ configuration_schema: {+ site_settings: {+ title: "Default",+ },+ },+ )test_type.configure_site_settings(category,@@ -87,98 +175,98 @@ RSpec.describe Categories::Types::Base doit "accepts a valid schema with site_settings" dotest_type =- Class.new(described_class) do- def self.configuration_schema- { site_settings: { title: "My Forum" } }- end- end+ build_test_type(:test, configuration_schema: { site_settings: { title: "My Forum" } })expect { test_type.validate_schema! }.not_to raise_errorendit "accepts a valid schema with category_custom_fields" dotest_type =- Class.new(described_class) do- def self.configuration_schema- {- category_custom_fields: {- my_field: {- default: 42,- type: :integer,- label: "My Field",- },+ build_test_type(+ :test,+ configuration_schema: {+ category_custom_fields: {+ my_field: {+ default: 42,+ type: :integer,+ label: "My Field",},- }- end- end+ },+ },+ )expect { test_type.validate_schema! }.not_to raise_errorendit "accepts optional :description" dotest_type =- Class.new(described_class) do- def self.configuration_schema- {- category_custom_fields: {- my_field: {- default: nil,- type: :string,- label: "My Field",- description: "Details",- },+ build_test_type(+ :test,+ configuration_schema: {+ category_custom_fields: {+ my_field: {+ default: nil,+ type: :string,+ label: "My Field",+ description: "Details",},- }- end- end+ },+ },+ )expect { test_type.validate_schema! }.not_to raise_errorendit "accepts empty sub-hashes" do- test_type =- Class.new(described_class) do- def self.configuration_schema- { category_settings: {} }- end- end+ test_type = build_test_type(:test, configuration_schema: { category_settings: {} })expect { test_type.validate_schema! }.not_to raise_errorendit "raises on unknown top-level keys" do- test_type =- Class.new(described_class) do- def self.configuration_schema- { unknown_key: {} }- end- end+ test_type = build_test_type(:test, configuration_schema: { unknown_key: {} })expect { test_type.validate_schema! }.to raise_error(ArgumentError)endit "raises when site_settings references an unknown SiteSetting" dotest_type =- Class.new(described_class) do- def self.configuration_schema- { site_settings: { not_a_real_setting_xyzzy: true } }- end- end+ build_test_type(+ :test,+ configuration_schema: {+ site_settings: {+ not_a_real_setting_xyzzy: true,+ },+ },+ )expect { test_type.validate_schema! }.to raise_error(ArgumentError, /unknown SiteSetting/)endit "raises when a field config is missing :default" dotest_type =- Class.new(described_class) do- def self.configuration_schema- { category_custom_fields: { my_field: { type: :integer, label: "My Field" } } }- end- end+ build_test_type(+ :test,+ configuration_schema: {+ category_custom_fields: {+ my_field: {+ type: :integer,+ label: "My Field",+ },+ },+ },+ )expect { test_type.validate_schema! }.to raise_error(ArgumentError)endit "raises when a field config :label is empty" dotest_type =- Class.new(described_class) do- def self.configuration_schema- { category_custom_fields: { my_field: { default: 1, type: :integer, label: "" } } }- end- end+ build_test_type(+ :test,+ configuration_schema: {+ category_custom_fields: {+ my_field: {+ default: 1,+ type: :integer,+ label: "",+ },+ },+ },+ )expect { test_type.validate_schema! }.to raise_error(ArgumentError)end@@ -233,13 +321,14 @@ RSpec.describe Categories::Types::Base dodescribe ".resolved_configuration_schema" doit "resolves site setting metadata" dotest_type =- Class.new(described_class) do- type_id :test_site_settings-- def self.configuration_schema- { site_settings: { title: "My Forum" } }- end- end+ build_test_type(+ :test_site_settings,+ configuration_schema: {+ site_settings: {+ title: "My Forum",+ },+ },+ )schema = test_type.send(:resolved_configuration_schema)expect(schema.keys).to eq(@@ -261,13 +350,18 @@ RSpec.describe Categories::Types::Base doit "passes through category settings" dotest_type =- Class.new(described_class) do- type_id :test_category_settings-- def self.configuration_schema- { category_settings: { my_field: { default: 42, type: :integer, label: "My Field" } } }- end- end+ build_test_type(+ :test_category_settings,+ configuration_schema: {+ category_settings: {+ my_field: {+ default: 42,+ type: :integer,+ label: "My Field",+ },+ },+ },+ )schema = test_type.send(:resolved_configuration_schema)expect(schema.keys).to eq(@@ -294,13 +388,17 @@ RSpec.describe Categories::Types::Base doit "uses custom label from the hash config when present" dotest_type =- Class.new(described_class) do- type_id :test_labels-- def self.configuration_schema- { site_settings: { title: { default: "My Forum", label: "Custom title label" } } }- end- end+ build_test_type(+ :test_labels,+ configuration_schema: {+ site_settings: {+ title: {+ default: "My Forum",+ label: "Custom title label",+ },+ },+ },+ )schema = test_type.send(:resolved_configuration_schema)entry = schema[:site_settings].first@@ -309,13 +407,14 @@ RSpec.describe Categories::Types::Base doit "falls back to humanized_name when no label override exists" dotest_type =- Class.new(described_class) do- type_id :test_no_labels-- def self.configuration_schema- { site_settings: { title: "My Forum" } }- end- end+ build_test_type(+ :test_no_labels,+ configuration_schema: {+ site_settings: {+ title: "My Forum",+ },+ },+ )schema = test_type.send(:resolved_configuration_schema)entry = schema[:site_settings].first@@ -324,13 +423,14 @@ RSpec.describe Categories::Types::Base doit "includes min and max when present in site setting metadata" dotest_type =- Class.new(described_class) do- type_id :test_min_max-- def self.configuration_schema- { site_settings: { suggested_topics_unread_max_days_old: 7 } }- end- end+ build_test_type(+ :test_min_max,+ configuration_schema: {+ site_settings: {+ suggested_topics_unread_max_days_old: 7,+ },+ },+ )schema = test_type.send(:resolved_configuration_schema)entry = schema[:site_settings].find { |e| e[:key] == "suggested_topics_unread_max_days_old" }@@ -341,13 +441,14 @@ RSpec.describe Categories::Types::Base doit "does not include min or max when absent from site setting metadata" dotest_type =- Class.new(described_class) do- type_id :test_no_min_max-- def self.configuration_schema- { site_settings: { title: "My Forum" } }- end- end+ build_test_type(+ :test_no_min_max,+ configuration_schema: {+ site_settings: {+ title: "My Forum",+ },+ },+ )schema = test_type.send(:resolved_configuration_schema)entry = schema[:site_settings].find { |e| e[:key] == "title" }@@ -358,13 +459,15 @@ RSpec.describe Categories::Types::Base doit "infers depends_on from site setting metadata" dotest_type =- Class.new(described_class) do- type_id :test_depends_on-- def self.configuration_schema- { site_settings: { title: "My Forum", set_locale_from_accept_language_header: true } }- end- end+ build_test_type(+ :test_depends_on,+ configuration_schema: {+ site_settings: {+ title: "My Forum",+ set_locale_from_accept_language_header: true,+ },+ },+ )schema = test_type.send(:resolved_configuration_schema)title_entry = schema[:site_settings].find { |e| e[:key] == "title" }@@ -424,13 +527,16 @@ RSpec.describe Categories::Types::Base dodescribe ".configure_site_settings" doit "extracts default from hash config values" dotest_type =- Class.new(described_class) do- type_id :test_hash_config-- def self.configuration_schema- { site_settings: { title: { default: "Hash Default" } } }- end- end+ build_test_type(+ :test_hash_config,+ configuration_schema: {+ site_settings: {+ title: {+ default: "Hash Default",+ },+ },+ },+ )test_type.configure_site_settings(category, guardian: admin.guardian)expect(SiteSetting.title).to eq("Hash Default")@@ -439,13 +545,7 @@ RSpec.describe Categories::Types::Base dodescribe "category_type_site_setting_names with empty schema" doit "does not raise when a matched type has no configuration_schema" do- test_type =- Class.new(described_class) do- type_id :no_schema_test- def self.category_matches?(_category)- true- end- end+ test_type = build_test_type(:no_schema_test, category_matches: true)Categories::TypeRegistry.register(test_type, plugin_identifier: "test")@@ -454,4 +554,49 @@ RSpec.describe Categories::Types::Base doCategories::TypeRegistry.all.delete(:no_schema_test)endend++ describe ".most_recently_active_admin" do+ it "returns the most recently active admin" do+ admin.update!(last_seen_at: 1.week.ago)+ admin2 = Fabricate(:admin, last_seen_at: 1.hour.ago)++ expect(described_class.most_recently_active_admin).to eq(admin2)+ end++ it "excludes inactive admins" do+ Fabricate(:admin, last_seen_at: 1.minute.ago, active: false)+ admin.update!(last_seen_at: 1.day.ago)++ expect(described_class.most_recently_active_admin).to eq(admin)+ end+ end++ describe ".metadata contact_admin_username" do+ fab!(:moderator)++ it "includes contact_admin_username when user cannot enable plugin" do+ admin.update!(last_seen_at: 1.minute.ago)+ test_type = build_test_type(:plugin_contact, enable_plugin: true, plugin_enabled: false)+ Categories::TypeRegistry.register(test_type, plugin_identifier: "discourse-test-contact")++ metadata = test_type.metadata(guardian: moderator.guardian)++ expect(metadata[:can_enable_plugin]).to eq(false)+ expect(metadata[:contact_admin_username]).to eq(admin.username)+ ensure+ Categories::TypeRegistry.all.delete(:plugin_contact)+ end++ it "does not include contact_admin_username when user can enable plugin" do+ test_type = build_test_type(:plugin_admin, enable_plugin: true, plugin_enabled: false)+ Categories::TypeRegistry.register(test_type, plugin_identifier: "discourse-test-admin")++ metadata = test_type.metadata(guardian: admin.guardian)++ expect(metadata[:can_enable_plugin]).to eq(true)+ expect(metadata).not_to have_key(:contact_admin_username)+ ensure+ Categories::TypeRegistry.all.delete(:plugin_admin)+ end+ endend