A platform for community discussion. Free, open, simple.
FIX: Allow using logged_in_users for category permissions (#45211)
Martin Brennan3b8049039282
diff --git a/app/models/category.rb b/app/models/category.rbindex a777943c8d1..cef61cc7e9b 100644--- a/app/models/category.rb+++ b/app/models/category.rb@@ -123,6 +123,7 @@ class Category < ActiveRecord::Basevalidate :email_in_validatorvalidate :ensure_slugvalidate :permissions_compatibility_validator+ validate :pseudogroup_permissions_validatorvalidate :special_category_permissions_validator, on: :updatevalidate :posting_review_groups_validator@@ -514,12 +515,15 @@ class Category < ActiveRecord::BaseSELECT category_idFROM category_groupsWHERE permission_type IN (:permissions)- AND (group_id = :everyone OR group_id IN (SELECT group_id FROM group_users WHERE user_id = :user_id))+ AND (group_id = :everyone+ OR group_id = :logged_in_users+ OR group_id IN (SELECT group_id FROM group_users WHERE user_id = :user_id)))",staged: guardian.is_staged?,permissions: permissions,user_id: guardian.user.id,everyone: Group::AUTO_GROUPS[:everyone],+ logged_in_users: Group::AUTO_GROUPS[:logged_in_users],)endend@@ -1227,6 +1231,16 @@ class Category < ActiveRecord::Baseendend+ def pseudogroup_permissions_validator+ return if !@permissions++ if @permissions.any? { |group_id, _permission|+ group_id == Group::AUTO_GROUPS[:anonymous_users]+ }+ errors.add(:base, I18n.t("category.errors.anonymous_permissions_not_supported"))+ end+ end+def permissions_compatibility_validator# when saving subcategoriesif (@permissions || parent_category_id_changed?) && parent_category_id.present?@@ -1461,6 +1475,10 @@ class Category < ActiveRecord::Basereturn if parent_groups.include?(Group[:everyone].id)child_groups = child_permissions.map(&:first)+ if parent_groups.include?(Group::AUTO_GROUPS[:logged_in_users])+ child_groups &= Group::AUTO_GROUPS.values_at(:everyone, :anonymous_users)+ end+only_subcategory_groups = child_groups - parent_groupsif only_subcategory_groups.present?diff --git a/app/models/topic_tracking_state.rb b/app/models/topic_tracking_state.rbindex d98c12cf77c..1cd331191c2 100644--- a/app/models/topic_tracking_state.rb+++ b/app/models/topic_tracking_state.rb@@ -142,7 +142,7 @@ class TopicTrackingStatepost.topic.category && post.topic.category.secure_group_idsend- if group_ids.present?+ if group_ids.present? && !group_ids.include?(Group::AUTO_GROUPS[:logged_in_users])scope =scope.joins("INNER JOIN group_users gu ON gu.user_id = topic_users.user_id").where("gu.group_id IN (?)",@@ -315,6 +315,7 @@ class TopicTrackingStatemin_new_topic_date: Time.at(SiteSetting.min_new_topics_time).to_datetime,max_topics: TopicTrackingState::MAX_TOPICS,user_first_unread_at: user.user_stat.first_unread_at,+ logged_in_users: Group::AUTO_GROUPS[:logged_in_users],}.merge(treat_as_new_topic_params),)@@ -445,8 +446,10 @@ class TopicTrackingStateNOT c.read_restricted #{append} OR c.id IN (SELECT c2.id FROM categories c2JOIN category_groups cg ON cg.category_id = c2.id- JOIN group_users gu ON gu.user_id = :user_id AND cg.group_id = gu.group_id- WHERE c2.read_restricted )+ WHERE c2.read_restricted AND (+ cg.group_id IN (SELECT group_id FROM group_users WHERE user_id = :user_id)+ OR cg.group_id = :logged_in_users+ ))) ANDSQLend@@ -628,6 +631,7 @@ class TopicTrackingStatemin_new_topic_date: Time.at(SiteSetting.min_new_topics_time).to_datetime,max_topics: TopicTrackingState::MAX_TOPICS,user_first_unread_at: user.user_stat.first_unread_at,+ logged_in_users: Group::AUTO_GROUPS[:logged_in_users],}.merge(treat_as_new_topic_params),).countenddiff --git a/app/models/topic_user.rb b/app/models/topic_user.rbindex 2b78b8e5703..13bdb7bee09 100644--- a/app/models/topic_user.rb+++ b/app/models/topic_user.rb@@ -499,7 +499,12 @@ class TopicUser < ActiveRecord::Base)SQL- DB.exec(sql, user_id: user_id, count: count)+ DB.exec(+ sql,+ user_id: user_id,+ count: count,+ logged_in_users: Group::AUTO_GROUPS[:logged_in_users],+ )enddef self.ensure_consistency!(topic_id = nil)diff --git a/app/models/user.rb b/app/models/user.rbindex 4d0daa1cef4..4b599d44c1c 100644--- a/app/models/user.rb+++ b/app/models/user.rb@@ -1624,7 +1624,14 @@ class User < ActiveRecord::Baseif admin? && !SiteSetting.suppress_secured_categories_from_adminCategory.unscoped.where(read_restricted: true)else- secure_categories.references(:categories)+ Category.where(id: secure_categories.select(:id)).or(+ Category.where(+ id:+ CategoryGroup.where(group_id: Group::AUTO_GROUPS[:logged_in_users]).select(+ :category_id,+ ),+ ),+ )endcats.pluck("categories.id").sortdiff --git a/app/models/user_stat.rb b/app/models/user_stat.rbindex fa625edc892..e230ac78e31 100644--- a/app/models/user_stat.rb+++ b/app/models/user_stat.rb@@ -108,7 +108,8 @@ class UserStat < ActiveRecord::Baseenddef self.update_first_unread(last_seen, limit: UPDATE_UNREAD_USERS_LIMIT)- DB.exec(<<~SQL, min_date: last_seen, limit: limit, now: UPDATE_UNREAD_MINUTES_AGO.minutes.ago)+ DB.exec(+ <<~SQL,UPDATE user_stats usSET first_unread_at = COALESCE(Y.min_date, :now)FROM (@@ -151,9 +152,10 @@ class UserStat < ActiveRecord::Base(SELECT c2.idFROM categories c2JOIN category_groups cg ON cg.category_id = c2.id- JOIN group_users gu ON gu.user_id = u.id- AND cg.group_id = gu.group_id- WHERE c2.read_restricted ))+ WHERE c2.read_restricted AND (+ cg.group_id IN (SELECT group_id FROM group_users WHERE user_id = u.id)+ OR cg.group_id = :logged_in_users+ )))AND NOT EXISTS(SELECT 1FROM category_users cu@@ -175,6 +177,11 @@ class UserStat < ActiveRecord::Base) YWHERE Y.user_id = us.user_idSQL+ min_date: last_seen,+ limit: limit,+ now: UPDATE_UNREAD_MINUTES_AGO.minutes.ago,+ logged_in_users: Group::AUTO_GROUPS[:logged_in_users],+ )enddef self.reset_bounce_scoresdiff --git a/app/serializers/category_serializer.rb b/app/serializers/category_serializer.rbindex 2137013d751..67082b8bd3d 100644--- a/app/serializers/category_serializer.rb+++ b/app/serializers/category_serializer.rb@@ -20,6 +20,7 @@ class CategorySerializer < SiteCategorySerializerattributes :locale,:read_restricted,:available_groups,+ :permission_groups,:allowed_tags,:allowed_tag_groups,:auto_close_hours,@@ -67,7 +68,14 @@ class CategorySerializer < SiteCategorySerializer.category_groups.joins(:group).includes(:group)- .merge(Group.visible_groups(scope&.user, "groups.name ASC", include_everyone: true))+ .merge(+ Group.visible_groups(+ scope&.user,+ "groups.name ASC",+ include_everyone: true,+ include_pseudogroups: true,+ ),+ ).map do |cg|{permission_type: cg.permission_type,@@ -76,7 +84,7 @@ class CategorySerializer < SiteCategorySerializer}end- if perms.length == 0 && !object.read_restricted+ if perms.length == 0 && !object.read_restricted && !object.category_groups.exists?perms << {permission_type: CategoryGroup.permission_types[:full],group_name: Group[:everyone]&.name.presence || :everyone,@@ -100,6 +108,26 @@ class CategorySerializer < SiteCategorySerializercan_edit_category?end+ def include_permission_groups?+ can_edit_category?+ end++ def permission_groups+ # NOTE (martin): When we are moving category permissions fully to use ACLs,+ # or when the everyone pseudogroup permission UC becomes permanent, we will+ # need to include anonymous_users+ Group+ .visible_groups(+ scope.user,+ "groups.name ASC",+ include_everyone: true,+ include_pseudogroups: true,+ )+ .where.not(id: Group::AUTO_GROUPS[:anonymous_users])+ .pluck(:id, :name)+ .map { |id, name| { id: id, name: name } }+ end+def available_groupsGroup.order(:name).pluck(:name) - group_permissions.map { |g| g[:group_name] }enddiff --git a/config/locales/server.en.yml b/config/locales/server.en.ymlindex a5106d03e58..f08f5f2a621 100644--- a/config/locales/server.en.yml+++ b/config/locales/server.en.yml@@ -1159,6 +1159,7 @@ en:one: "Description is too long (maximum is %{count} character)."other: "Description is too long (maximum is %{count} characters)."special_category_permissions: "This is a pre-seeded category and the security settings cannot be edited. If you do not wish to use this category, delete it instead of repurposing it."+ anonymous_permissions_not_supported: "Use the everyone group to allow anonymous users to access a category."permission_conflict: "Any group that is allowed to access a subcategory must also be allowed to access the parent category. The following groups have access to one of the subcategories, but no access to parent category: %{group_names}."disallowed_topic_tags: "This topic has tags not allowed by this category: '%{tags}'"disallowed_tags_generic: "This topic has disallowed tags."diff --git a/frontend/discourse/admin/components/upsert-category/security.gjs b/frontend/discourse/admin/components/upsert-category/security.gjsindex c70e534082e..3b1ab0e42e6 100644--- a/frontend/discourse/admin/components/upsert-category/security.gjs+++ b/frontend/discourse/admin/components/upsert-category/security.gjs@@ -53,14 +53,35 @@ export default class UpsertCategorySecurity extends Component {return false;}- return !parentPerms.some((p) => p.group_id === AUTO_GROUPS.everyone.id);+ return !parentPerms.some((p) =>+ [AUTO_GROUPS.everyone.id, AUTO_GROUPS.logged_in_users.id].includes(+ p.group_id+ )+ );}get availableGroups() {const permissions = this.permissions || [];const permissionGroupIds = new Set(permissions.map((p) => p.group_id));- let groups = this.site.groups.filter((g) => !permissionGroupIds.has(g.id));+ let groups = (+ this.args.category.permission_groups ?? this.site.groups+ ).filter(+ (group) =>+ group.id !== AUTO_GROUPS.anonymous_users.id &&+ !permissionGroupIds.has(group.id)+ );++ if (+ this.parentPermissions?.some(+ (permission) => permission.group_id === AUTO_GROUPS.logged_in_users.id+ ) &&+ !this.parentPermissions.some(+ (permission) => permission.group_id === AUTO_GROUPS.everyone.id+ )+ ) {+ groups = groups.filter((group) => group.id !== AUTO_GROUPS.everyone.id);+ }if (this.isParentRestricted) {const parentGroupIds = new Set(@@ -110,7 +131,8 @@ export default class UpsertCategorySecurity extends Component {const newPermissions = [...(this.permissions || []),{- group_name: this.site.groupName(groupId),+ group_name: this.availableGroups.find((group) => group.id === groupId)+ ?.name,group_id: groupId,permission_type: this.minimumPermission,},diff --git a/frontend/discourse/admin/routes/new-category.js b/frontend/discourse/admin/routes/new-category.jsindex caff76b40d1..16b27510fe7 100644--- a/frontend/discourse/admin/routes/new-category.js+++ b/frontend/discourse/admin/routes/new-category.js@@ -45,6 +45,12 @@ export default class NewCategory extends DiscourseRoute {style_type: "icon",icon: "square-full",group_permissions,+ permission_groups: [+ this.site.groupsById[AUTO_GROUPS.everyone.id],+ ...this.site.groups.filter(+ (group) => group.id !== AUTO_GROUPS.everyone.id+ ),+ ],available_groups: this.site.groups.map((g) => g.name),allow_badges: true,topic_featured_link_allowed: true,diff --git a/frontend/discourse/app/models/category.ts b/frontend/discourse/app/models/category.tsindex 213a7864c3f..dcca92c4e19 100644--- a/frontend/discourse/app/models/category.ts+++ b/frontend/discourse/app/models/category.ts@@ -185,6 +185,7 @@ export interface CategoryFields {category_types?: Record<string, CategoryTypeMetadata>;locale?: string | null;available_groups?: string[];+ permission_groups?: { id: number; name: string }[];allowed_tags?: (CategoryAllowedTag | string)[];allowed_tag_groups?: string[];auto_close_hours?: number | null;diff --git a/frontend/discourse/tests/acceptance/category-edit-security-test.js b/frontend/discourse/tests/acceptance/category-edit-security-test.jsindex 8fc3b3fe529..671ee1cc339 100644--- a/frontend/discourse/tests/acceptance/category-edit-security-test.js+++ b/frontend/discourse/tests/acceptance/category-edit-security-test.js@@ -1,5 +1,6 @@import { click, visit } from "@ember/test-helpers";import { test } from "qunit";+import Site from "discourse/models/site";import formKit from "discourse/tests/helpers/form-kit-helper";import { acceptance } from "discourse/tests/helpers/qunit-helpers";import { i18n } from "discourse-i18n";@@ -165,3 +166,86 @@ acceptance("Category Edit - Security", function (needs) {);});});++acceptance("Category Edit - Logged-in permissions", function (needs) {+ let parentCategoryId;+ needs.hooks.beforeEach(() => {+ parentCategoryId = null;+ });+ needs.user();+ needs.settings({ granular_anonymous_and_logged_in_groups_permissions: true });+ needs.site({+ groups: [+ { id: 4, name: "anonymous_users", automatic: true },+ { id: 5, name: "logged_in_users", automatic: true },+ { id: 42, name: "custom_group" },+ ],+ });+ needs.pretender((server, helper) => {+ server.get("/c/bug/find_by_slug.json", () =>+ helper.response({+ category: {+ id: 1,+ name: "bug",+ slug: "bug",+ parent_category_id: parentCategoryId,+ can_edit: true,+ available_groups: ["everyone", "logged_in_users", "custom_group"],+ permission_groups: [+ { id: 0, name: "everyone" },+ { id: 5, name: "logged_in_users" },+ { id: 42, name: "custom_group" },+ ],+ group_permissions: [+ { group_id: 5, group_name: "logged_in_users", permission_type: 3 },+ ],+ },+ })+ );+ });++ test("category choices retain everyone and exclude anonymous users", async function (assert) {+ await visit("/c/bug/edit/security");++ assert+ .dom(".available-groups option[value='0']")+ .exists(+ "public access remains available when the UC hides everyone globally"+ );+ assert+ .dom(".available-groups option[value='4']")+ .doesNotExist("anonymous grants are unavailable for categories");+ assert+ .dom("[data-group-name='logged_in_users']")+ .exists("the saved logged-in grant remains visible");++ await formKit().field("security_add_group_id").select("0");++ assert+ .dom("[data-group-name='everyone']")+ .exists("adding public access uses the category-specific group name");+ });+ test("a logged-in parent permits custom-group children but excludes public access", async function (assert) {+ parentCategoryId = 99;+ Site.current().updateCategory({+ id: parentCategoryId,+ name: "Logged-in parent",+ slug: "logged-in-parent",+ available_groups: ["logged_in_users"],+ group_permissions: [+ { group_id: 5, group_name: "logged_in_users", permission_type: 3 },+ ],+ });++ await visit("/c/bug/edit/security");++ assert+ .dom(".available-groups option[value='42']")+ .exists("custom group members can access the logged-in parent");+ assert+ .dom(".available-groups option[value='0']")+ .doesNotExist(+ "a public child would expose content beyond the parent audience"+ );+ });+});diff --git a/frontend/discourse/type-tests/models/category-test.ts b/frontend/discourse/type-tests/models/category-test.tsindex e09f70e0b14..7a18e8c5a78 100644--- a/frontend/discourse/type-tests/models/category-test.ts+++ b/frontend/discourse/type-tests/models/category-test.ts@@ -143,6 +143,7 @@ interface ExpectedCategoryFields {category_types?: Record<string, CategoryTypeMetadata>;locale?: string | null;available_groups?: string[];+ permission_groups?: { id: number; name: string }[];allowed_tags?: (ExpectedAllowedTag | string)[];allowed_tag_groups?: string[];auto_close_hours?: number | null;diff --git a/plugins/chat/app/controllers/chat/api/category_chatables_controller.rb b/plugins/chat/app/controllers/chat/api/category_chatables_controller.rbindex 30e0ad4ad1f..e37df432471 100644--- a/plugins/chat/app/controllers/chat/api/category_chatables_controller.rb+++ b/plugins/chat/app/controllers/chat/api/category_chatables_controller.rb@@ -11,7 +11,7 @@ class Chat::Api::CategoryChatablesController < ApplicationControllerif category.read_restricted?permissions =Group- .visible_groups(guardian.user, nil, include_everyone: true)+ .visible_groups(guardian.user, nil, include_everyone: true, include_pseudogroups: true).joins(:category_groups).where(category_groups: { category_id: category.id }).where(@@ -23,7 +23,12 @@ class Chat::Api::CategoryChatablesController < ApplicationController.pluck("groups.name", "COUNT(group_users.user_id)")group_names = permissions.map { |p| "@#{p[0]}" }- members_count = permissions.sum { |p| p[1].to_i }+ members_count =+ if group_names.include?("@#{Group[:logged_in_users].name}")+ User.real.count+ else+ permissions.sum { |permission| permission[1].to_i }+ endpermissions_result = {allowed_groups: group_names,diff --git a/plugins/chat/app/services/chat/auto_join_channels.rb b/plugins/chat/app/services/chat/auto_join_channels.rbindex 9678c38f520..636f0f7c08e 100644--- a/plugins/chat/app/services/chat/auto_join_channels.rb+++ b/plugins/chat/app/services/chat/auto_join_channels.rb@@ -73,11 +73,13 @@ module ChatCROSS JOIN chat_users cuJOIN categories c ON c.id = cc.chatable_id AND c.read_restricted = FALSE #{category_sql}), private AS ( -- private chat channels- SELECT DISTINCT gu.user_id, cc.id AS chat_channel_id+ SELECT DISTINCT cu.id AS user_id, cc.id AS chat_channel_idFROM valid_chat_channels ccJOIN categories c ON c.id = cc.chatable_id AND c.read_restricted = TRUE #{category_sql}JOIN category_groups cg ON cg.category_id = c.id AND cg.permission_type IN (:group_permissions)- JOIN group_users gu ON gu.group_id = cg.group_id AND gu.user_id IN (SELECT id FROM chat_users)+ JOIN chat_users cu ON cg.group_id = :logged_in_users OR EXISTS (+ SELECT 1 FROM group_users gu WHERE gu.group_id = cg.group_id AND gu.user_id = cu.id+ ))INSERT INTO user_chat_channel_memberships (user_id, chat_channel_id, following, join_mode, created_at, updated_at)SELECT p.user_id, p.chat_channel_id, TRUE, :automatic, :now, :now@@ -92,7 +94,15 @@ module ChatSQLchannel_to_users = Hash.new { |h, k| h[k] = [] }- args = { now:, last_seen_at:, group_ids:, max_users:, group_permissions:, automatic: }+ args = {+ now:,+ last_seen_at:,+ group_ids:,+ max_users:,+ group_permissions:,+ automatic:,+ logged_in_users: Group::AUTO_GROUPS[:logged_in_users],+ }DB.query_array(sql, args)diff --git a/plugins/chat/app/services/chat/auto_leave_channels.rb b/plugins/chat/app/services/chat/auto_leave_channels.rbindex 0e22545b31a..f9761c2846a 100644--- a/plugins/chat/app/services/chat/auto_leave_channels.rb+++ b/plugins/chat/app/services/chat/auto_leave_channels.rb@@ -76,13 +76,17 @@ module ChatJOIN chat_channels cc ON cc.id = uccm.chat_channel_id AND cc.chatable_type = 'Category' #{channel_sql}JOIN categories c ON c.id = cc.chatable_id AND c.read_restricted = TRUE #{category_sql}LEFT JOIN valid_permissions vp ON vp.user_id = uccm.user_id AND vp.category_id = c.id- WHERE vp.user_id IS NULL+ WHERE vp.user_id IS NULL AND NOT EXISTS (+ SELECT 1 FROM category_groups cg+ WHERE cg.category_id = c.id AND cg.group_id = :logged_in_users+ AND cg.permission_type IN (:group_permissions)+ ))RETURNING chat_channel_id, user_idSQLDB- .query_array(sql, group_permissions:)+ .query_array(sql, group_permissions:, logged_in_users: Group::AUTO_GROUPS[:logged_in_users]).each { |channel_id, user_id| users_removed_map[channel_id] << user_id }if users_removed_map.present?diff --git a/plugins/chat/spec/requests/chat/api/category_chatables_controller_spec.rb b/plugins/chat/spec/requests/chat/api/category_chatables_controller_spec.rbindex 6e93711cf00..8b37990c685 100644--- a/plugins/chat/spec/requests/chat/api/category_chatables_controller_spec.rb+++ b/plugins/chat/spec/requests/chat/api/category_chatables_controller_spec.rb@@ -36,6 +36,49 @@ describe Chat::Api::CategoryChatablesController doexpect(response.parsed_body["private"]).to eq(true)end+ [false, true].each do |enabled|+ it "counts logged-in category members regardless of granular permissions #{enabled}" do+ SiteSetting.granular_anonymous_and_logged_in_groups_permissions = enabled+ member = Fabricate(:user)+ group.add(member)+ private_category.update!(+ permissions: {+ :logged_in_users => :create_post,+ group.name => :full,+ },+ )++ get "/chat/api/category-chatables/#{private_category.id}/permissions"++ expect(response.status).to eq(200)+ expect(response.parsed_body).to include(+ "members_count" => User.real.count,+ "private" => true,+ )+ expect(response.parsed_body["allowed_groups"]).to contain_exactly(+ "@logged_in_users",+ "@#{group.name}",+ )+ end+ end++ it "excludes a read-only logged-in grant from channel participation" do+ member = Fabricate(:user)+ group.add(member)+ private_category.update!(+ permissions: {+ :logged_in_users => :readonly,+ group.name => :full,+ },+ )++ get "/chat/api/category-chatables/#{private_category.id}/permissions"++ expect(response.status).to eq(200)+ expect(response.parsed_body).to include("members_count" => 1, "private" => true)+ expect(response.parsed_body["allowed_groups"]).to eq(["@#{group.name}"])+ end+it "doesn't return group names from other categories" doa_member = Fabricate(:user)group_2 = Fabricate(:group)diff --git a/plugins/chat/spec/services/chat/auto_join_channels_spec.rb b/plugins/chat/spec/services/chat/auto_join_channels_spec.rbindex e9af62551f0..72185d20c38 100644--- a/plugins/chat/spec/services/chat/auto_join_channels_spec.rb+++ b/plugins/chat/spec/services/chat/auto_join_channels_spec.rb@@ -2,13 +2,40 @@RSpec.describe Chat::AutoJoinChannels dodescribe ".call" do- subject(:result) { described_class.call(params: {}) }+ subject(:result) { described_class.call(params:) }+ let(:params) { {} }let!(:previous_events) { DiscourseEvent.events.dup }before { DiscourseEvent.events.clear }after { previous_events.each { |event, handlers| DiscourseEvent.events[event] = handlers } }+ context "with logged-in category permissions" do+ fab!(:user) { Fabricate(:user, trust_level: 1, last_seen_at: 5.minutes.ago) }++ let(:params) { { user_id: user.id } }++ before { SiteSetting.chat_enabled = true }++ [false, true].each do |enabled|+ it "joins channels with posting access regardless of granular permissions #{enabled}" do+ SiteSetting.granular_anonymous_and_logged_in_groups_permissions = enabled+ channels =+ %i[readonly create_post full].map do |permission|+ category = Fabricate(:category, permissions: { logged_in_users: permission })+ Fabricate(:chat_channel, chatable: category, auto_join_users: true)+ end++ expect(result).to run_successfully++ expect(user.user_chat_channel_memberships.pluck(:chat_channel_id)).to contain_exactly(+ channels[1].id,+ channels[2].id,+ )+ end+ end+ end+context "when chat is disabled" dobefore { SiteSetting.chat_enabled = false }diff --git a/plugins/chat/spec/services/chat/auto_leave_channels_spec.rb b/plugins/chat/spec/services/chat/auto_leave_channels_spec.rbindex d0dfa7164e2..bba8654d7fd 100644--- a/plugins/chat/spec/services/chat/auto_leave_channels_spec.rb+++ b/plugins/chat/spec/services/chat/auto_leave_channels_spec.rb@@ -2,13 +2,42 @@RSpec.describe Chat::AutoLeaveChannels dodescribe ".call" do- subject(:result) { described_class.call(params: { event: :generic_event }) }+ subject(:result) { described_class.call(params:) }+ let(:params) { { event: :generic_event } }let!(:previous_events) { DiscourseEvent.events.dup }before { DiscourseEvent.events.clear }after { previous_events.each { |event, handlers| DiscourseEvent.events[event] = handlers } }+ context "with logged-in category permissions" do+ fab!(:user) { Fabricate(:user, trust_level: 1) }++ let(:params) { { event: :generic_event, user_id: user.id } }++ before { SiteSetting.chat_enabled = true }++ [false, true].each do |enabled|+ it "retains only memberships with posting access regardless of granular permissions #{enabled}" do+ SiteSetting.granular_anonymous_and_logged_in_groups_permissions = enabled+ channels =+ %i[readonly create_post full].map do |permission|+ category = Fabricate(:category, permissions: { logged_in_users: permission })+ channel = Fabricate(:chat_channel, chatable: category)+ Fabricate(:user_chat_channel_membership, user:, chat_channel: channel)+ channel+ end++ expect(result).to run_successfully++ expect(user.user_chat_channel_memberships.pluck(:chat_channel_id)).to contain_exactly(+ channels[1].id,+ channels[2].id,+ )+ end+ end+ end+context "when chat is disabled" dobefore { SiteSetting.chat_enabled = false }diff --git a/plugins/chat/spec/services/chat/publisher_spec.rb b/plugins/chat/spec/services/chat/publisher_spec.rbindex 38e8badd5c0..b49b4b49795 100644--- a/plugins/chat/spec/services/chat/publisher_spec.rb+++ b/plugins/chat/spec/services/chat/publisher_spec.rb@@ -273,6 +273,57 @@ describe Chat::Publisher do)end+ [false, true].each do |enabled|+ it "bounds logged-in category delivery by chat eligibility with granular permissions #{enabled}" do+ SiteSetting.granular_anonymous_and_logged_in_groups_permissions = enabled+ category = Fabricate(:category, permissions: { logged_in_users: :full })+ restricted_channel = Fabricate(:category_channel, chatable: category)+ message = Fabricate(:chat_message, chat_channel: restricted_channel)+ chat_group = Fabricate(:group)+ SiteSetting.chat_allowed_groups = chat_group.id+ user = Fabricate(:user)+ user_group_ids = [+ Group::AUTO_GROUPS[:trust_level_0],+ Group::AUTO_GROUPS[:logged_in_users],+ ]++ published_message =+ MessageBus+ .track_publish(described_class.root_message_bus_channel(restricted_channel.id)) do+ described_class.publish_new!(restricted_channel, message, staged_id)+ end+ .first++ expect(published_message.group_ids).to contain_exactly(+ *Chat::CategoryChannel::STAFF_GROUP_IDS.map do |group_id|+ "chat-restricted-category-group-#{group_id}"+ end,+ "chat-restricted-category-group-#{Group::AUTO_GROUPS[:logged_in_users]}",+ )+ expect(+ MessageBus::Client.new(+ client_id: "chat-disallowed",+ user_id: user.id,+ group_ids: Chat.message_bus_group_ids_for(user_group_ids),+ message_bus: MessageBus,+ ).allowed?(published_message),+ ).to eq(false)+ expect(+ MessageBus::Client.new(+ client_id: "chat-allowed",+ user_id: user.id,+ group_ids: Chat.message_bus_group_ids_for(user_group_ids + [chat_group.id]),+ message_bus: MessageBus,+ ).allowed?(published_message),+ ).to eq(true)+ expect(+ MessageBus::Client.new(client_id: "anonymous", message_bus: MessageBus).allowed?(+ published_message,+ ),+ ).to eq(false)+ end+ end+it "publishes to trust level 0 when chat is allowed for everyone" doSiteSetting.chat_allowed_groups = Group::AUTO_GROUPS[:everyone]diff --git a/spec/models/category_spec.rb b/spec/models/category_spec.rbindex 56d769e29f4..a6a77e9af62 100644--- a/spec/models/category_spec.rb+++ b/spec/models/category_spec.rb@@ -287,6 +287,19 @@ RSpec.describe Category doenddescribe "resolve_permissions" do+ [false, true].each do |enabled|+ it "keeps logged-in-only access restricted with granular permissions #{enabled}" do+ SiteSetting.granular_anonymous_and_logged_in_groups_permissions = enabled++ read_restricted, resolved = Category.resolve_permissions(logged_in_users: :full)++ expect(read_restricted).to eq(true)+ expect(resolved).to eq(+ [[Group::AUTO_GROUPS[:logged_in_users], CategoryGroup.permission_types[:full]]],+ )+ end+ end+it "can determine read_restricted" doread_restricted, resolved = Category.resolve_permissions(everyone: :full)@@ -295,6 +308,79 @@ RSpec.describe Category doendend+ describe "pseudogroup permission validation" do+ fab!(:category)++ [false, true].each do |enabled|+ it "rejects anonymous grants on creation and updates with granular permissions #{enabled}" do+ SiteSetting.granular_anonymous_and_logged_in_groups_permissions = enabled+ permissions = { anonymous_users: :readonly, logged_in_users: :full }+ new_category = Fabricate.build(:category, permissions: permissions)++ expect(new_category.save).to eq(false)+ expect(new_category.errors[:base]).to include(+ I18n.t("category.errors.anonymous_permissions_not_supported"),+ )+ expect(category.update(permissions: permissions)).to eq(false)+ expect(category.errors[:base]).to include(+ I18n.t("category.errors.anonymous_permissions_not_supported"),+ )+ expect(category.reload.category_groups).to be_empty+ end+ end+ end++ describe "logged-in parent permission compatibility" do+ fab!(:group)+ fab!(:parent) { Fabricate(:category, permissions: { logged_in_users: :readonly }) }++ it "allows a child restricted to a custom group" do+ child = Fabricate(:category, parent_category: parent, permissions: { group.name => :full })++ expect(child).to be_persisted+ end++ it "allows an existing public parent to become logged-in-only with a private child" do+ parent.update!(permissions: { everyone: :readonly })+ Fabricate(:category, parent_category: parent, permissions: { group.name => :full })++ expect(parent.update(permissions: { logged_in_users: :readonly })).to eq(true)+ end++ it "rejects a public child beneath a logged-in-only parent" do+ child =+ Fabricate.build(:category, parent_category: parent, permissions: { everyone: :readonly })++ expect(child.save).to eq(false)+ expect(child.errors[:base]).to include(+ I18n.t("category.errors.permission_conflict", group_names: Group[:everyone].name),+ )+ end+ end++ describe "logged-in pseudogroup posting permissions" do+ fab!(:user)+ fab!(:category)++ [false, true].each do |enabled|+ it "honors permission levels with granular permissions #{enabled}" do+ SiteSetting.granular_anonymous_and_logged_in_groups_permissions = enabled++ %i[readonly create_post full].each do |permission|+ category.update!(permissions: { logged_in_users: permission })++ expect(Category.topic_create_allowed(user.guardian).exists?(id: category.id)).to eq(+ permission == :full,+ )+ expect(Category.post_create_allowed(user.guardian).exists?(id: category.id)).to eq(+ permission != :readonly,+ )+ expect(Category.post_create_allowed(Guardian.new).exists?(id: category.id)).to eq(false)+ end+ end+ end+ end+describe "permissions_params" doit "returns the right group names and permission type" docategory = Fabricate(:category_with_definition)diff --git a/spec/models/topic_tracking_state_spec.rb b/spec/models/topic_tracking_state_spec.rbindex 186c99fd347..deb0d6c8734 100644--- a/spec/models/topic_tracking_state_spec.rb+++ b/spec/models/topic_tracking_state_spec.rb@@ -198,6 +198,17 @@ RSpec.describe TopicTrackingState doenddescribe "#publish_unread" do+ [false, true].each do |enabled|+ it "notifies logged-in category watchers with granular permissions #{enabled}" do+ SiteSetting.granular_anonymous_and_logged_in_groups_permissions = enabled+ topic.update!(category: Fabricate(:category, permissions: { logged_in_users: :readonly }))++ message = MessageBus.track_publish("/unread") { described_class.publish_unread(post) }.first++ expect(message.user_ids).to contain_exactly(other_user.id)+ end+ end+let(:other_user) { Fabricate(:user) }let!(:other_user_watching_topic) doFabricate(:topic_user_watching, topic: topic, user: other_user)@@ -832,6 +843,21 @@ RSpec.describe TopicTrackingState doenddescribe ".report" do+ [false, true].each do |enabled|+ it "reports logged-in pseudogroup topics with granular permissions #{enabled}" do+ SiteSetting.granular_anonymous_and_logged_in_groups_permissions = enabled+ author = Fabricate(:admin)+ category = Fabricate(:category, permissions: { logged_in_users: :readonly })+ public_post = create_post(category: category, user: author)+ private_category = Fabricate(:private_category, group: Fabricate(:group))+ create_post(category: private_category, user: author)++ report = TopicTrackingState.report(user)++ expect(report.map(&:topic_id)).to eq([public_post.topic_id])+ end+ end+it "correctly reports topics with staff posts" doSiteSetting.whispers_allowed_groups = "#{Group::AUTO_GROUPS[:staff]}"create_post(raw: "this is a test post", topic: topic, user: post.user)diff --git a/spec/models/user_spec.rb b/spec/models/user_spec.rbindex 381e5e0b412..7cc77fe9f3a 100644--- a/spec/models/user_spec.rb+++ b/spec/models/user_spec.rb@@ -4133,6 +4133,18 @@ RSpec.describe User dofab!(:group)fab!(:private_category) { Fabricate(:private_category, group: group) }+ [false, true].each do |enabled|+ it "includes logged-in pseudogroup categories with granular permissions #{enabled}" do+ SiteSetting.granular_anonymous_and_logged_in_groups_permissions = enabled+ category = Fabricate(:category, permissions: { logged_in_users: :readonly })++ expect(user.secure_category_ids).to eq([category.id])+ expect(user.guardian.can_see_category?(category)).to eq(true)+ expect(Category.secured(user.guardian).exists?(id: category.id)).to eq(true)+ expect(Category.secured(Guardian.new).exists?(id: category.id)).to eq(false)+ end+ end+it "allows admin to see all secure categories" doexpect(admin.secure_category_ids).to include(private_category.id)enddiff --git a/spec/models/user_stat_spec.rb b/spec/models/user_stat_spec.rbindex 783b53cc5b7..e0f6dec9adf 100644--- a/spec/models/user_stat_spec.rb+++ b/spec/models/user_stat_spec.rb@@ -128,6 +128,36 @@ RSpec.describe UserStat doendend+ describe ".update_first_unread" do+ fab!(:user) { Fabricate(:user, last_seen_at: Time.zone.now) }++ [false, true].each do |enabled|+ it "includes logged-in pseudogroup topics with granular permissions #{enabled}" do+ freeze_time+ SiteSetting.granular_anonymous_and_logged_in_groups_permissions = enabled+ author = Fabricate(:admin)+ category = Fabricate(:category, permissions: { logged_in_users: :readonly })+ post = create_post(category: category, user: author, created_at: 1.hour.ago)+ private_category = Fabricate(:private_category, group: Fabricate(:group))+ private_post =+ create_post(category: private_category, user: author, created_at: 2.hours.ago)+ [post, private_post].each do |unread_post|+ TopicUser.change(+ user.id,+ unread_post.topic_id,+ last_read_post_number: 0,+ notification_level: TopicUser.notification_levels[:tracking],+ )+ end++ UserStat.update_first_unread(1.day.ago)++ expected = post.topic.reload.updated_at+ expect(user.user_stat.reload.first_unread_at).to eq_time(expected)+ end+ end+ end+describe "ensure consistency!" doit "can update first unread" dopost = create_postdiff --git a/spec/requests/api/schemas/json/category_create_response.json b/spec/requests/api/schemas/json/category_create_response.jsonindex 74b607e9d2c..e1b978baf65 100644--- a/spec/requests/api/schemas/json/category_create_response.json+++ b/spec/requests/api/schemas/json/category_create_response.json@@ -242,6 +242,25 @@"null"]},+ "permission_groups": {+ "type": "array",+ "items": {+ "type": "object",+ "additionalProperties": false,+ "properties": {+ "id": {+ "type": "integer"+ },+ "name": {+ "type": "string"+ }+ },+ "required": [+ "id",+ "name"+ ]+ }+ },"available_groups": {"type": "array","items": {diff --git a/spec/requests/api/schemas/json/category_update_response.json b/spec/requests/api/schemas/json/category_update_response.jsonindex 3abc0526861..2b5b23cd26c 100644--- a/spec/requests/api/schemas/json/category_update_response.json+++ b/spec/requests/api/schemas/json/category_update_response.json@@ -245,6 +245,25 @@"null"]},+ "permission_groups": {+ "type": "array",+ "items": {+ "type": "object",+ "additionalProperties": false,+ "properties": {+ "id": {+ "type": "integer"+ },+ "name": {+ "type": "string"+ }+ },+ "required": [+ "id",+ "name"+ ]+ }+ },"available_groups": {"type": "array","items": {diff --git a/spec/serializers/category_serializer_spec.rb b/spec/serializers/category_serializer_spec.rbindex 189df97a2de..fe60e948644 100644--- a/spec/serializers/category_serializer_spec.rb+++ b/spec/serializers/category_serializer_spec.rb@@ -71,6 +71,66 @@ RSpec.describe CategorySerializer docategory.save!end+ context "with logged-in permissions" do+ [false, true].each do |enabled|+ it "preserves grants through saves and flag toggles with granular permissions initially #{enabled}" do+ SiteSetting.granular_anonymous_and_logged_in_groups_permissions = enabled++ %i[readonly create_post full].each do |permission|+ category.update!(permissions: { logged_in_users: permission })+ SiteSetting.granular_anonymous_and_logged_in_groups_permissions = !enabled+ json = described_class.new(category, scope: admin.guardian, root: false).as_json++ expect(json[:group_permissions]).to eq(+ [+ {+ permission_type: CategoryGroup.permission_types[permission],+ group_name: "logged_in_users",+ group_id: Group::AUTO_GROUPS[:logged_in_users],+ },+ ],+ )+ category.update!(+ name: "Renamed category",+ permissions:+ json[:group_permissions].to_h do |grant|+ [grant[:group_name], grant[:permission_type]]+ end,+ )+ SiteSetting.granular_anonymous_and_logged_in_groups_permissions = enabled++ expect(category.reload.permissions_params).to eq(+ "logged_in_users" => CategoryGroup.permission_types[permission],+ )+ expect(category.read_restricted).to eq(true)+ end+ end+ end++ it "keeps an existing unsupported anonymous grant visible instead of synthesizing public access" do+ category.category_groups.destroy_all+ category.update!(read_restricted: false)+ Fabricate(+ :category_group,+ category: category,+ group: Group[:anonymous_users],+ permission_type: CategoryGroup.permission_types[:readonly],+ )++ json = described_class.new(category, scope: admin.guardian, root: false).as_json++ expect(json[:group_permissions]).to eq(+ [+ {+ permission_type: CategoryGroup.permission_types[:readonly],+ group_name: "anonymous_users",+ group_id: Group::AUTO_GROUPS[:anonymous_users],+ },+ ],+ )+ end+ end+it "does not include the attribute for an anon user" dojson = described_class.new(category, scope: Guardian.new, root: false).as_json@@ -116,6 +176,30 @@ RSpec.describe CategorySerializer doendend+ describe "permission groups" do+ [false, true].each do |enabled|+ it "offers category groups independently of granular permissions #{enabled}" do+ SiteSetting.granular_anonymous_and_logged_in_groups_permissions = enabled++ json = described_class.new(category, scope: admin.guardian, root: false).as_json++ expect(json[:permission_groups]).to include(+ { id: Group::AUTO_GROUPS[:everyone], name: Group[:everyone].name },+ { id: Group::AUTO_GROUPS[:logged_in_users], name: Group[:logged_in_users].name },+ )+ expect(json[:permission_groups].pluck(:id)).not_to include(+ Group::AUTO_GROUPS[:anonymous_users],+ )+ end+ end++ it "omits editor group choices for regular users" do+ json = described_class.new(category, scope: user.guardian, root: false).as_json++ expect(json).not_to have_key(:permission_groups)+ end+ end+describe "available groups" doit "not included for a regular user" dojson = described_class.new(category, scope: Guardian.new(user), root: false).as_jsondiff --git a/spec/system/edit_category_security_spec.rb b/spec/system/edit_category_security_spec.rbindex 28b51b4fc67..9269931860d 100644--- a/spec/system/edit_category_security_spec.rb+++ b/spec/system/edit_category_security_spec.rb@@ -58,4 +58,36 @@ describe "Edit Category Security" docategory_page.visit_security(category)expect(category_permission_row).to have_group_permission(category_group_1.group_name, %w[reply])end++ it "keeps logged-in permissions through edits and upcoming-change toggles" do+ form = PageObjects::Components::FormKit.new(".form-kit")+ category_page.visit_security(category)+ category_permission_row.remove_group_permission("everyone")+ category_permission_row.remove_group_permission(group.name)+ form.field("security_add_group_id").select(Group::AUTO_GROUPS[:logged_in_users])+ category_page.save_settings+ category_page.visit_security(category)+ expect(category_permission_row).to have_group_permission("logged_in_users")++ category_permission_row.toggle_group_permission("logged_in_users", "reply")+ category_page.save_settings+ category_page.visit_security(category)+ expect(category_permission_row).to have_group_permission("logged_in_users", %w[reply])++ SiteSetting.granular_anonymous_and_logged_in_groups_permissions = true+ category_page.visit_security(category)+ expect(category_permission_row).to have_group_permission("logged_in_users", %w[reply])+ category_permission_row.toggle_group_permission("logged_in_users", "create")+ category_page.save_settings+ category_page.visit_security(category)+ expect(category_permission_row).to have_group_permission("logged_in_users", %w[create reply])++ SiteSetting.granular_anonymous_and_logged_in_groups_permissions = false+ category_page.visit_general(category)+ form.field("name").fill_in("Renamed logged-in category")+ category_page.save_settings+ category_page.visit_security(category)+ expect(category_permission_row).to have_group_permission("logged_in_users", %w[create reply])+ expect(category_permission_row).to have_no_group_permission("everyone")+ endenddiff --git a/spec/system/page_objects/components/category_list.rb b/spec/system/page_objects/components/category_list.rbindex c46957ecd2a..4ea16f6d7e1 100644--- a/spec/system/page_objects/components/category_list.rb+++ b/spec/system/page_objects/components/category_list.rb@@ -9,6 +9,10 @@ module PageObjectspage.has_css?("tr[data-category-id='#{category.id}']")end+ def has_no_category?(category)+ page.has_no_css?("tr[data-category-id='#{category.id}']")+ end+def has_topic?(topic)page.has_css?(topic_list_item_class(topic))enddiff --git a/spec/system/viewing_category_permissions_spec.rb b/spec/system/viewing_category_permissions_spec.rbnew file mode 100644index 00000000000..f9ec9b2c4f5--- /dev/null+++ b/spec/system/viewing_category_permissions_spec.rb@@ -0,0 +1,54 @@+# frozen_string_literal: true++RSpec.describe "Viewing categories with group permissions" do+ fab!(:group)+ fab!(:user)+ fab!(:member, :user) { Fabricate(:user, groups: [group]) }+ fab!(:public_category, :category)+ fab!(:private_category) { Fabricate(:private_category, group: group) }+ fab!(:logged_in_category) { Fabricate(:category, permissions: { logged_in_users: :readonly }) }+ fab!(:public_topic) { Fabricate(:topic, category: public_category) }+ fab!(:private_topic) { Fabricate(:topic, category: private_category) }+ fab!(:logged_in_topic) { Fabricate(:topic, category: logged_in_category) }++ let(:category_page) { PageObjects::Pages::Category.new }+ let(:category_list) { PageObjects::Components::CategoryList.new }+ let(:topic_list) { PageObjects::Components::TopicList.new }+ let(:not_found_page) { PageObjects::Pages::NotFound.new }++ [false, true].each do |enabled|+ context "with granular permissions #{enabled}" do+ before { SiteSetting.granular_anonymous_and_logged_in_groups_permissions = enabled }++ %i[anonymous nonmember member].each do |viewer|+ it "lets a #{viewer} browse permitted categories and see a not-found page for denied categories" do+ sign_in(viewer == :member ? member : user) unless viewer == :anonymous++ visible_categories = [public_category]+ visible_categories << private_category if viewer == :member+ visible_categories << logged_in_category if viewer != :anonymous++ category_page.visit_categories++ [public_category, private_category, logged_in_category].each do |category|+ if visible_categories.include?(category)+ expect(category_list).to have_category(category)+ else+ expect(category_list).to have_no_category(category)+ end+ end++ [public_topic, private_topic, logged_in_topic].each do |topic|+ category_page.visit(topic.category)++ if visible_categories.include?(topic.category)+ expect(topic_list).to have_topic(topic)+ else+ expect(not_found_page).to be_visible+ end+ end+ end+ end+ end+ end+end