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.rbindex a52eb7f2af9..be6c744be4a 100644--- a/app/controllers/user_badges_controller.rb+++ b/app/controllers/user_badges_controller.rb@@ -2,23 +2,25 @@class UserBadgesController < ApplicationControllerMAX_BADGES = 96 # This was limited in PR#2360 to make it divisible by 8+ MAX_INDEX_LIMIT = 400+ MAX_BADGE_IDS = 100before_action :ensure_badges_enabledbefore_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_badgesgrant_count = nil@@ -26,11 +28,22 @@ class UserBadgesController < ApplicationControlleruser = 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.countend+ 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 < ApplicationControllerprivate+ 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_paramsbadge = nildiff --git a/app/models/user_badge.rb b/app/models/user_badge.rbindex 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.rbnew file mode 100644index 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+enddiff --git a/db/structure.sql b/db/structure.sqlindex 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 (vCREATE 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.jsindex 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.jsindex 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.jsindex 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.rbindex 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 dodescribe "#index" dofab!(: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" dop = create_post@@ -43,11 +59,184 @@ RSpec.describe UserBadgesController doexpect(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" doSiteSetting.hide_user_profiles_from_public = true