Skip to content

A platform for community discussion. Free, open, simple.

FEATURE: Add aggregate recent-grants feed to /user_badges (#43932)

Juan David Martínez Cubillosc38644cc2c89
diff --git a/app/controllers/user_badges_controller.rb b/app/controllers/user_badges_controller.rb
index a52eb7f2af9..be6c744be4a 100644
--- a/app/controllers/user_badges_controller.rb
+++ b/app/controllers/user_badges_controller.rb
@@ -2,23 +2,25 @@
class UserBadgesController < ApplicationController
MAX_BADGES = 96 # This was limited in PR#2360 to make it divisible by 8
+ MAX_INDEX_LIMIT = 400
+ MAX_BADGE_IDS = 100
before_action :ensure_badges_enabled
before_action :ensure_logged_in, only: %i[create destroy toggle_favorite]
def index
- params.permit %i[granted_before offset username]
-
- badge = fetch_badge_from_params
- user_badges = badge.user_badges.order("granted_at DESC, id DESC").limit(MAX_BADGES)
- user_badges =
- user_badges.includes(
- :user,
- :granted_by,
- badge: :badge_type,
- post: :topic,
- user: %i[primary_group flair_group],
- )
+ params.permit %i[
+ granted_before
+ offset
+ username
+ badge_id
+ badge_name
+ badge_ids
+ badge_type_id
+ limit
+ ]
+
+ user_badges = scoped_user_badges
grant_count = nil
@@ -26,11 +28,22 @@ class UserBadgesController < ApplicationController
user = fetch_user_from_params(include_inactive: true)
raise Discourse::NotFound unless guardian.can_see_profile?(user)
- user_id = user.id
- user_badges = user_badges.where(user_id: user_id)
- grant_count = badge.user_badges.where(user_id: user_id).count
+ user_badges = user_badges.where(user_id: user.id)
+ grant_count = user_badges.count
end
+ user_badges =
+ user_badges
+ .order("granted_at DESC, id DESC")
+ .limit(index_limit)
+ .includes(
+ :user,
+ :granted_by,
+ badge: :badge_type,
+ post: :topic,
+ user: %i[primary_group flair_group],
+ )
+
offset = fetch_int_from_params(:offset, default: 0)
user_badges = user_badges.offset(offset) if offset > 0
@@ -171,6 +184,67 @@ class UserBadgesController < ApplicationController
private
+ def scoped_user_badges
+ ids = selected_badge_ids
+
+ scope =
+ if ids
+ UserBadge.where(badge: Badge.enabled).where(badge_id: ids)
+ else
+ UserBadge.where(badge: Badge.enabled.where(listable: true))
+ end
+
+ if params[:badge_type_id].present?
+ type_id = fetch_int_from_params(:badge_type_id, default: nil, min: 1)
+ scope = scope.joins(:badge).where(badges: { badge_type_id: type_id })
+ end
+
+ scope
+ end
+
+ def selected_badge_ids
+ return parse_badge_ids(params[:badge_ids]) if params.key?(:badge_ids)
+
+ if params.key?(:badge_name)
+ badge = Badge.find_by(name: params[:badge_name], enabled: true)
+ raise Discourse::NotFound if badge.blank?
+
+ return [badge.id]
+ end
+
+ if params.key?(:badge_id)
+ params.require(:badge_id)
+ badge = Badge.find_by(id: params[:badge_id], enabled: true)
+ raise Discourse::NotFound if badge.blank?
+
+ return [badge.id]
+ end
+
+ nil
+ end
+
+ def parse_badge_ids(raw)
+ return nil if raw.blank?
+
+ tokens = raw.is_a?(Array) ? raw.flatten : raw.to_s.split(/[,|\s+]/)
+ ids =
+ tokens
+ .flat_map { |token| token.to_s.split(/[,|\s+]/) }
+ .filter_map { |token| Integer(token, exception: false) }
+ .select(&:positive?)
+ .uniq
+ raise Discourse::InvalidParameters.new(:badge_ids) if ids.length > MAX_BADGE_IDS
+
+ ids
+ end
+
+ def index_limit
+ limit = fetch_int_from_params(:limit, default: nil, min: 1)
+ return MAX_BADGES if limit.nil?
+
+ [limit, MAX_INDEX_LIMIT].min
+ end
+
# Get the badge from either the badge name or id specified in the params.
def fetch_badge_from_params
badge = nil
diff --git a/app/models/user_badge.rb b/app/models/user_badge.rb
index e50aa6d3dc2..5cf07b327fd 100644
--- a/app/models/user_badge.rb
+++ b/app/models/user_badge.rb
@@ -146,6 +146,7 @@ end
#
# Indexes
#
+# idx_user_badges_granted_at (granted_at DESC)
# index_user_badges_on_badge_id_and_user_id (badge_id,user_id)
# index_user_badges_on_badge_id_and_user_id_and_post_id (badge_id,user_id,post_id) UNIQUE WHERE (post_id IS NOT NULL)
# index_user_badges_on_badge_id_and_user_id_and_seq (badge_id,user_id,seq) UNIQUE WHERE (post_id IS NULL)
diff --git a/db/migrate/20260923174053_add_granted_at_index_to_user_badges.rb b/db/migrate/20260923174053_add_granted_at_index_to_user_badges.rb
new file mode 100644
index 00000000000..89d0a188819
--- /dev/null
+++ b/db/migrate/20260923174053_add_granted_at_index_to_user_badges.rb
@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+class AddGrantedAtIndexToUserBadges < ActiveRecord::Migration[8.1]
+ disable_ddl_transaction!
+
+ INDEX_NAME = "idx_user_badges_granted_at"
+
+ def up
+ remove_index :user_badges, name: INDEX_NAME, algorithm: :concurrently, if_exists: true
+ add_index :user_badges,
+ :granted_at,
+ name: INDEX_NAME,
+ order: {
+ granted_at: :desc,
+ },
+ algorithm: :concurrently
+ end
+
+ def down
+ remove_index :user_badges, name: INDEX_NAME, algorithm: :concurrently, if_exists: true
+ end
+end
diff --git a/db/structure.sql b/db/structure.sql
index e72b41e22ef..8248a03706b 100644
--- a/db/structure.sql
+++ b/db/structure.sql
@@ -20232,6 +20232,13 @@ CREATE INDEX idx_uploads_on_verification_status ON public.uploads USING btree (v
CREATE INDEX idx_user_actions_speed_up_user_all ON public.user_actions USING btree (user_id, created_at, action_type);
+--
+-- Name: idx_user_badges_granted_at; Type: INDEX; Schema: public; Owner: -
+--
+
+CREATE INDEX idx_user_badges_granted_at ON public.user_badges USING btree (granted_at DESC);
+
+
--
-- Name: idx_user_chat_thread_memberships_on_thread_id_user_id; Type: INDEX; Schema: public; Owner: -
--
@@ -25592,6 +25599,7 @@ INSERT INTO "schema_migrations" (version) VALUES
('20260928103925'),
('20260925155026'),
('20260925054715'),
+('20260923174053'),
('20260923141924'),
('20260923080644'),
('20260923080642'),
diff --git a/frontend/discourse/app/data/builders/user-badges.js b/frontend/discourse/app/data/builders/user-badges.js
index 0b2e3fc062c..aac92569aa5 100644
--- a/frontend/discourse/app/data/builders/user-badges.js
+++ b/frontend/discourse/app/data/builders/user-badges.js
@@ -29,6 +29,17 @@ export function findUserBadgesByBadgeId(badgeId, opts = {}) {
return readMany(url, normalizeUserBadgesPayload);
}
+export function findUserBadgesByBadgeIds(badgeIds, opts = {}) {
+ const url = applyQueryParams("/user_badges.json", {
+ badge_ids: badgeIds.length ? badgeIds.join(",") : null,
+ badge_type_id: opts.badgeTypeId,
+ offset: opts.offset,
+ username: opts.username,
+ limit: opts.limit,
+ });
+ return readMany(url, normalizeUserBadgesPayload);
+}
+
export function grantUserBadge(badgeId, username, reason) {
return createOne(
`/user_badges`,
diff --git a/frontend/discourse/app/models/user-badge.js b/frontend/discourse/app/models/user-badge.js
index 0247a5723f9..f1b3da4624f 100644
--- a/frontend/discourse/app/models/user-badge.js
+++ b/frontend/discourse/app/models/user-badge.js
@@ -1,6 +1,7 @@
import { dependentKeyCompat } from "@ember/object/compat";
import {
findUserBadgesByBadgeId,
+ findUserBadgesByBadgeIds,
findUserBadgesByUsername,
grantUserBadge,
toggleFavoriteUserBadge,
@@ -48,6 +49,13 @@ export default class UserBadge extends RestCompatModel {
return requestMany(this, findUserBadgesByBadgeId(badgeId, options));
}
+ // One request for the most recent grants across several badges (or every
+ // enabled listable badge when the list is empty). `options` may set
+ // `badgeTypeId`/`limit`.
+ static findByBadgeIds(badgeIds, options = {}) {
+ return requestMany(this, findUserBadgesByBadgeIds(badgeIds, options));
+ }
+
static grant(badgeId, username, reason) {
return requestOne(this, grantUserBadge(badgeId, username, reason));
}
diff --git a/frontend/discourse/tests/unit/models/user-badge-test.js b/frontend/discourse/tests/unit/models/user-badge-test.js
index 1d531362911..f84e2ea0014 100644
--- a/frontend/discourse/tests/unit/models/user-badge-test.js
+++ b/frontend/discourse/tests/unit/models/user-badge-test.js
@@ -97,6 +97,11 @@ module("Unit | Model | user-badge", function (hooks) {
assert.true(Array.isArray(badges), "returns an array");
});
+ test("findByBadgeIds", async function (assert) {
+ const badges = await UserBadge.findByBadgeIds([880, 50]);
+ assert.true(Array.isArray(badges), "returns an array");
+ });
+
test("grant", async function (assert) {
const userBadge = await UserBadge.grant(1, "username");
assert.false(Array.isArray(userBadge), "does not return an array");
diff --git a/spec/requests/user_badges_controller_spec.rb b/spec/requests/user_badges_controller_spec.rb
index 7fa2cd5739d..755e3780578 100644
--- a/spec/requests/user_badges_controller_spec.rb
+++ b/spec/requests/user_badges_controller_spec.rb
@@ -9,6 +9,22 @@ RSpec.describe UserBadgesController do
describe "#index" do
fab!(:badge) { Fabricate(:badge, target_posts: true, show_posts: false) }
+ fab!(:gold_badge) do
+ Fabricate(:badge).tap { |badge| badge.update!(badge_type_id: BadgeType::Gold) }
+ end
+ fab!(:silver_badge) do
+ Fabricate(:badge).tap { |badge| badge.update!(badge_type_id: BadgeType::Silver) }
+ end
+ fab!(:bronze_badge) do
+ Fabricate(:badge).tap { |badge| badge.update!(badge_type_id: BadgeType::Bronze) }
+ end
+ fab!(:gold_grant) do
+ Fabricate(:user_badge, badge: gold_badge, user: user, granted_at: 1.hour.ago)
+ end
+ fab!(:silver_grant) do
+ Fabricate(:user_badge, badge: silver_badge, user: user, granted_at: 2.hours.ago)
+ end
+ fab!(:bronze_grant) { Fabricate(:user_badge, badge: bronze_badge, granted_at: 3.hours.ago) }
it "does not leak private info" do
p = create_post
@@ -43,11 +59,184 @@ RSpec.describe UserBadgesController do
expect(response.status).to eq(200)
end
- it "requires username or badge_id to be specified" do
+ it "returns a recent grants feed when no badge id is specified" do
+ get "/user_badges.json"
+
+ expect(response.status).to eq(200)
+ ids = response.parsed_body["user_badge_info"]["user_badges"].map { |ub| ub["id"] }
+ expect(ids).to eq([gold_grant.id, silver_grant.id, bronze_grant.id])
+ end
+
+ it "excludes disabled badges from the recent grants feed" do
+ disabled_badge = Fabricate(:badge, enabled: false)
+ Fabricate(:user_badge, badge: disabled_badge, granted_at: 30.minutes.ago)
+
+ get "/user_badges.json"
+
+ expect(response.status).to eq(200)
+ ids = response.parsed_body["user_badge_info"]["user_badges"].map { |ub| ub["id"] }
+ expect(ids).to eq([gold_grant.id, silver_grant.id, bronze_grant.id])
+ end
+
+ it "combines grants across multiple badge_ids in a single request" do
+ get "/user_badges.json", params: { badge_ids: "#{gold_badge.id},#{silver_badge.id}" }
+
+ expect(response.status).to eq(200)
+ ids = response.parsed_body["user_badge_info"]["user_badges"].map { |ub| ub["id"] }
+ expect(ids).to contain_exactly(gold_grant.id, silver_grant.id)
+ expect(ids).not_to include(bronze_grant.id)
+ end
+
+ it "accepts pipe-separated badge_ids" do
+ get "/user_badges.json", params: { badge_ids: "#{gold_badge.id}|#{silver_badge.id}" }
+
+ expect(response.status).to eq(200)
+ ids = response.parsed_body["user_badge_info"]["user_badges"].map { |ub| ub["id"] }
+ expect(ids).to contain_exactly(gold_grant.id, silver_grant.id)
+ end
+
+ it "filters the recent grants feed by badge_type_id" do
+ get "/user_badges.json", params: { badge_type_id: BadgeType::Gold }
+
+ expect(response.status).to eq(200)
+ ids = response.parsed_body["user_badge_info"]["user_badges"].map { |ub| ub["id"] }
+ expect(ids).to contain_exactly(gold_grant.id)
+ expect(ids).not_to include(silver_grant.id, bronze_grant.id)
+ end
+
+ it "limits the recent grants feed" do
+ get "/user_badges.json", params: { limit: 1 }
+
+ expect(response.status).to eq(200)
+ ids = response.parsed_body["user_badge_info"]["user_badges"].map { |ub| ub["id"] }
+ expect(ids).to eq([gold_grant.id])
+ end
+
+ it "applies the feed limit to a single badge_id" do
+ newest_grant = Fabricate(:user_badge, badge: gold_badge, granted_at: 30.minutes.ago)
+
+ get "/user_badges.json", params: { badge_id: gold_badge.id, limit: 1 }
+
+ expect(response.status).to eq(200)
+ user_badges = response.parsed_body["user_badge_info"]["user_badges"]
+ expect(user_badges.map { |ub| ub["id"] }).to eq([newest_grant.id])
+ end
+
+ it "returns not found for a single badge_id that is unknown or disabled" do
+ get "/user_badges.json", params: { badge_id: 999_999 }
+ expect(response.status).to eq(404)
+
+ disabled_badge = Fabricate(:badge, enabled: false)
+ get "/user_badges.json", params: { badge_id: disabled_badge.id }
+ expect(response.status).to eq(404)
+ end
+
+ it "selects a single badge by badge_name with the same feed behaviour" do
+ get "/user_badges.json", params: { badge_name: gold_badge.name, limit: 10 }
+
+ expect(response.status).to eq(200)
+ user_badges = response.parsed_body["user_badge_info"]["user_badges"]
+ expect(user_badges.map { |ub| ub["id"] }).to eq([gold_grant.id])
+ end
+
+ it "treats an empty badge_ids param as the full recent grants feed" do
+ get "/user_badges.json", params: { badge_ids: "" }
+
+ expect(response.status).to eq(200)
+ ids = response.parsed_body["user_badge_info"]["user_badges"].map { |ub| ub["id"] }
+ expect(ids).to eq([gold_grant.id, silver_grant.id, bronze_grant.id])
+ end
+
+ it "excludes non-listable badges from the unfiltered recent grants feed" do
+ hidden_badge = Fabricate(:badge, listable: false)
+ Fabricate(:user_badge, badge: hidden_badge, granted_at: 30.minutes.ago)
+
get "/user_badges.json"
+
+ expect(response.status).to eq(200)
+ ids = response.parsed_body["user_badge_info"]["user_badges"].map { |ub| ub["id"] }
+ expect(ids).to eq([gold_grant.id, silver_grant.id, bronze_grant.id])
+ end
+
+ it "still returns grants for an explicitly requested non-listable badge" do
+ hidden_badge = Fabricate(:badge, listable: false)
+ hidden_grant = Fabricate(:user_badge, badge: hidden_badge, granted_at: 1.hour.ago)
+
+ get "/user_badges.json", params: { badge_id: hidden_badge.id }
+
+ expect(response.status).to eq(200)
+ ids = response.parsed_body["user_badge_info"]["user_badges"].map { |ub| ub["id"] }
+ expect(ids).to eq([hidden_grant.id])
+ end
+
+ it "returns no grants for a non-empty badge_ids that yields no valid ids" do
+ get "/user_badges.json", params: { badge_ids: "invalid" }
+
+ expect(response.status).to eq(200)
+ expect(response.parsed_body["user_badge_info"]["user_badges"]).to eq([])
+ end
+
+ it "keeps valid ids and drops junk from badge_ids" do
+ get "/user_badges.json", params: { badge_ids: "#{gold_badge.id},invalid" }
+
+ expect(response.status).to eq(200)
+ ids = response.parsed_body["user_badge_info"]["user_badges"].map { |ub| ub["id"] }
+ expect(ids).to eq([gold_grant.id])
+ end
+
+ it "accepts array-style badge_ids" do
+ get "/user_badges.json", params: { badge_ids: [gold_badge.id.to_s, silver_badge.id.to_s] }
+
+ expect(response.status).to eq(200)
+ ids = response.parsed_body["user_badge_info"]["user_badges"].map { |ub| ub["id"] }
+ expect(ids).to contain_exactly(gold_grant.id, silver_grant.id)
+ end
+
+ it "returns 400 for an array-form limit" do
+ get "/user_badges.json", params: { limit: [1] }
+
+ expect(response.status).to eq(400)
+ end
+
+ it "keeps the no-limit default above the explicit limit cap" do
+ 51.times { Fabricate(:user_badge, badge: badge) }
+
+ get "/user_badges.json", params: { badge_id: badge.id }
+
+ expect(response.status).to eq(200)
+ expect(response.parsed_body["user_badge_info"]["user_badges"].length).to eq(51)
+ end
+
+ it "returns 400 for a blank badge_id rather than falling back to the feed" do
+ get "/user_badges.json", params: { badge_id: "" }
+
+ expect(response.status).to eq(400)
+ end
+
+ it "returns 400 when badge_ids exceeds the maximum" do
+ get "/user_badges.json", params: { badge_ids: (1..101).to_a.join(",") }
+
+ expect(response.status).to eq(400)
+ end
+
+ it "returns 400 for an array-form badge_type_id" do
+ get "/user_badges.json", params: { badge_type_id: [BadgeType::Gold] }
+
expect(response.status).to eq(400)
end
+ it "returns a user's recent grants and grant_count when no badge id is specified" do
+ get "/user_badges.json", params: { username: user.username }
+
+ expect(response.status).to eq(200)
+ parsed = response.parsed_body["user_badge_info"]
+ expect(parsed["grant_count"]).to eq(2)
+ expect(parsed["user_badges"].map { |ub| ub["id"] }).to contain_exactly(
+ gold_grant.id,
+ silver_grant.id,
+ )
+ end
+
it "does not disclose badges when public profiles are hidden" do
SiteSetting.hide_user_profiles_from_public = true