Skip to content

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.rb
index a777943c8d1..cef61cc7e9b 100644
--- a/app/models/category.rb
+++ b/app/models/category.rb
@@ -123,6 +123,7 @@ class Category < ActiveRecord::Base
validate :email_in_validator
validate :ensure_slug
validate :permissions_compatibility_validator
+ validate :pseudogroup_permissions_validator
validate :special_category_permissions_validator, on: :update
validate :posting_review_groups_validator
@@ -514,12 +515,15 @@ class Category < ActiveRecord::Base
SELECT category_id
FROM category_groups
WHERE 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],
)
end
end
@@ -1227,6 +1231,16 @@ class Category < ActiveRecord::Base
end
end
+ 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 subcategories
if (@permissions || parent_category_id_changed?) && parent_category_id.present?
@@ -1461,6 +1475,10 @@ class Category < ActiveRecord::Base
return 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_groups
if only_subcategory_groups.present?
diff --git a/app/models/topic_tracking_state.rb b/app/models/topic_tracking_state.rb
index d98c12cf77c..1cd331191c2 100644
--- a/app/models/topic_tracking_state.rb
+++ b/app/models/topic_tracking_state.rb
@@ -142,7 +142,7 @@ class TopicTrackingState
post.topic.category && post.topic.category.secure_group_ids
end
- 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 TopicTrackingState
min_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 TopicTrackingState
NOT c.read_restricted #{append} OR c.id IN (
SELECT c2.id FROM categories c2
JOIN 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
+ ))
) AND
SQL
end
@@ -628,6 +631,7 @@ class TopicTrackingState
min_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),
).count
end
diff --git a/app/models/topic_user.rb b/app/models/topic_user.rb
index 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],
+ )
end
def self.ensure_consistency!(topic_id = nil)
diff --git a/app/models/user.rb b/app/models/user.rb
index 4d0daa1cef4..4b599d44c1c 100644
--- a/app/models/user.rb
+++ b/app/models/user.rb
@@ -1624,7 +1624,14 @@ class User < ActiveRecord::Base
if admin? && !SiteSetting.suppress_secured_categories_from_admin
Category.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,
+ ),
+ ),
+ )
end
cats.pluck("categories.id").sort
diff --git a/app/models/user_stat.rb b/app/models/user_stat.rb
index fa625edc892..e230ac78e31 100644
--- a/app/models/user_stat.rb
+++ b/app/models/user_stat.rb
@@ -108,7 +108,8 @@ class UserStat < ActiveRecord::Base
end
def 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 us
SET first_unread_at = COALESCE(Y.min_date, :now)
FROM (
@@ -151,9 +152,10 @@ class UserStat < ActiveRecord::Base
(SELECT c2.id
FROM categories c2
JOIN 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 1
FROM category_users cu
@@ -175,6 +177,11 @@ class UserStat < ActiveRecord::Base
) Y
WHERE Y.user_id = us.user_id
SQL
+ min_date: last_seen,
+ limit: limit,
+ now: UPDATE_UNREAD_MINUTES_AGO.minutes.ago,
+ logged_in_users: Group::AUTO_GROUPS[:logged_in_users],
+ )
end
def self.reset_bounce_scores
diff --git a/app/serializers/category_serializer.rb b/app/serializers/category_serializer.rb
index 2137013d751..67082b8bd3d 100644
--- a/app/serializers/category_serializer.rb
+++ b/app/serializers/category_serializer.rb
@@ -20,6 +20,7 @@ class CategorySerializer < SiteCategorySerializer
attributes :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 < SiteCategorySerializer
can_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_groups
Group.order(:name).pluck(:name) - group_permissions.map { |g| g[:group_name] }
end
diff --git a/config/locales/server.en.yml b/config/locales/server.en.yml
index 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.gjs
index 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.js
index 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.ts
index 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.js
index 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.ts
index 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.rb
index 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 < ApplicationController
if 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 }
+ end
permissions_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.rb
index 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 Chat
CROSS JOIN chat_users cu
JOIN 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_id
FROM valid_chat_channels cc
JOIN 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 Chat
SQL
channel_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.rb
index 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 Chat
JOIN 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_id
SQL
DB
- .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.rb
index 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 do
expect(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" do
a_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.rb
index 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 do
describe ".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" do
before { 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.rb
index 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 do
describe ".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" do
before { SiteSetting.chat_enabled = false }
diff --git a/plugins/chat/spec/services/chat/publisher_spec.rb b/plugins/chat/spec/services/chat/publisher_spec.rb
index 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" do
SiteSetting.chat_allowed_groups = Group::AUTO_GROUPS[:everyone]
diff --git a/spec/models/category_spec.rb b/spec/models/category_spec.rb
index 56d769e29f4..a6a77e9af62 100644
--- a/spec/models/category_spec.rb
+++ b/spec/models/category_spec.rb
@@ -287,6 +287,19 @@ RSpec.describe Category do
end
describe "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" do
read_restricted, resolved = Category.resolve_permissions(everyone: :full)
@@ -295,6 +308,79 @@ RSpec.describe Category do
end
end
+ 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" do
it "returns the right group names and permission type" do
category = Fabricate(:category_with_definition)
diff --git a/spec/models/topic_tracking_state_spec.rb b/spec/models/topic_tracking_state_spec.rb
index 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 do
end
describe "#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) do
Fabricate(:topic_user_watching, topic: topic, user: other_user)
@@ -832,6 +843,21 @@ RSpec.describe TopicTrackingState do
end
describe ".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" do
SiteSetting.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.rb
index 381e5e0b412..7cc77fe9f3a 100644
--- a/spec/models/user_spec.rb
+++ b/spec/models/user_spec.rb
@@ -4133,6 +4133,18 @@ RSpec.describe User do
fab!(: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" do
expect(admin.secure_category_ids).to include(private_category.id)
end
diff --git a/spec/models/user_stat_spec.rb b/spec/models/user_stat_spec.rb
index 783b53cc5b7..e0f6dec9adf 100644
--- a/spec/models/user_stat_spec.rb
+++ b/spec/models/user_stat_spec.rb
@@ -128,6 +128,36 @@ RSpec.describe UserStat do
end
end
+ 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!" do
it "can update first unread" do
post = create_post
diff --git a/spec/requests/api/schemas/json/category_create_response.json b/spec/requests/api/schemas/json/category_create_response.json
index 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.json
index 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.rb
index 189df97a2de..fe60e948644 100644
--- a/spec/serializers/category_serializer_spec.rb
+++ b/spec/serializers/category_serializer_spec.rb
@@ -71,6 +71,66 @@ RSpec.describe CategorySerializer do
category.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" do
json = described_class.new(category, scope: Guardian.new, root: false).as_json
@@ -116,6 +176,30 @@ RSpec.describe CategorySerializer do
end
end
+ 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" do
it "not included for a regular user" do
json = described_class.new(category, scope: Guardian.new(user), root: false).as_json
diff --git a/spec/system/edit_category_security_spec.rb b/spec/system/edit_category_security_spec.rb
index 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" do
category_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")
+ end
end
diff --git a/spec/system/page_objects/components/category_list.rb b/spec/system/page_objects/components/category_list.rb
index 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 PageObjects
page.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))
end
diff --git a/spec/system/viewing_category_permissions_spec.rb b/spec/system/viewing_category_permissions_spec.rb
new file mode 100644
index 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