Skip to content

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

8.0 KB
Raw Blame
# frozen_string_literal: true

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_id
                    badge_name
                    badge_ids
                    badge_type_id
                    limit
                  ]

    user_badges = scoped_user_badges

    grant_count = nil

    if params[:username]
      user = fetch_user_from_params(include_inactive: true)
      raise Discourse::NotFound unless guardian.can_see_profile?(user)

      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

    user_badges_topic_ids = user_badges.map { |user_badge| user_badge.post&.topic_id }.compact

    user_badges =
      UserBadges.new(
        user_badges: user_badges,
        username: params[:username],
        grant_count: grant_count,
      )

    render_serialized(
      user_badges,
      UserBadgesSerializer,
      root: :user_badge_info,
      include_long_description: true,
      allowed_user_badge_topic_ids: guardian.can_see_topic_ids(topic_ids: user_badges_topic_ids),
    )
  end

  def username
    params.permit [:grouped]

    user =
      fetch_user_from_params(
        include_inactive:
          current_user.try(:staff?) || (current_user && SiteSetting.show_inactive_accounts),
      )
    raise Discourse::NotFound unless guardian.can_see_profile?(user)
    user_badges = user.user_badges

    user_badges = user_badges.group(:badge_id).select_for_grouping if params[:grouped]

    user_badges =
      user_badges
        .includes(badge: %i[badge_grouping badge_type image_upload])
        .includes(post: :topic)
        .includes(:granted_by)

    user_badges_topic_ids = user_badges.map { |user_badge| user_badge.post&.topic_id }.compact

    render_serialized(
      user_badges,
      DetailedUserBadgeSerializer,
      allowed_user_badge_topic_ids: guardian.can_see_topic_ids(topic_ids: user_badges_topic_ids),
      root: :user_badges,
    )
  end

  def create
    params.require(:username)
    user = fetch_user_from_params

    return render json: failed_json, status: :forbidden unless can_assign_badge_to_user?(user)

    badge = fetch_badge_from_params
    post_id = nil

    if params.key?(:post_id)
      raise Discourse::InvalidParameters.new(:post_id) if params[:reason].present?

      post_id = Integer(params[:post_id].to_s, 10, exception: false)
      raise Discourse::InvalidParameters.new(:post_id) if post_id.nil? || post_id < 1

      post = Post.find_by(id: post_id)
      raise Discourse::NotFound if post.blank?

      guardian.ensure_can_see!(post)
      post_id = post.id
    elsif params[:reason].present?
      unless is_badge_reason_valid? params[:reason]
        return(
          render json: failed_json.merge(message: I18n.t("invalid_grant_badge_reason_link")),
                 status: :bad_request
        )
      end

      if route = Discourse.route_for(params[:reason])
        if (route[:controller] == "topics" && route[:action] == "show") ||
             route[:controller] == "nested_topics"
          topic_id = (route[:id] || route[:topic_id]).to_i
          post_number = route[:post_number] || 1
          post_id = Post.find_by(topic_id: topic_id, post_number: post_number)&.id if topic_id > 0
        end
      end
    end

    grant_opts_from_params =
      DiscoursePluginRegistry.apply_modifier(
        :user_badges_badge_grant_opts,
        {
          granted_by: current_user,
          post_id: post_id,
          suppress_notification: params[:suppress_notification].to_s == "true",
        },
        { param: params },
      )

    user_badge = BadgeGranter.grant(badge, user, grant_opts_from_params)

    render_serialized(user_badge, DetailedUserBadgeSerializer, root: "user_badge")
  end

  def destroy
    params.require(:id)
    user_badge = UserBadge.find(params[:id])

    unless can_assign_badge_to_user?(user_badge.user)
      render json: failed_json, status: :forbidden
      return
    end

    BadgeGranter.revoke(user_badge, revoked_by: current_user)
    render json: success_json
  end

  def toggle_favorite
    params.require(:user_badge_id)
    user_badge = UserBadge.find(params[:user_badge_id])
    user_badges = user_badge.user.user_badges

    return render json: failed_json, status: :forbidden unless can_favorite_badge?(user_badge)

    is_favorite = user_badges.where(badge: user_badge.badge, is_favorite: true).exists?

    if !is_favorite &&
         user_badges.select(:badge_id).distinct.where(is_favorite: true).count >=
           SiteSetting.max_favorite_badges
      return render json: failed_json, status: :bad_request
    end

    UserBadge.where(user_id: user_badge.user_id, badge_id: user_badge.badge_id).update_all(
      is_favorite: !is_favorite,
    )
    UserBadge.update_featured_ranks!([user_badge.user_id])
  end

  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

    params.permit(:badge_name)
    if params[:badge_name].nil?
      params.require(:badge_id)
      badge = Badge.find_by(id: params[:badge_id], enabled: true)
    else
      badge = Badge.find_by(name: params[:badge_name], enabled: true)
    end
    raise Discourse::NotFound if badge.blank?

    badge
  end

  def can_assign_badge_to_user?(user)
    master_api_call = current_user.nil? && is_api?
    master_api_call || guardian.can_grant_badges?(user)
  end

  def can_favorite_badge?(user_badge)
    current_user == user_badge.user && !(1..4).include?(user_badge.badge_id)
  end

  def ensure_badges_enabled
    raise Discourse::NotFound unless SiteSetting.enable_badges?
  end

  def is_badge_reason_valid?(reason)
    route = Discourse.route_for(reason)
    route &&
      (
        route[:controller] == "posts" || route[:controller] == "topics" ||
          route[:controller] == "nested_topics"
      )
  end
end