Skip to content

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

20.7 KB
Raw Blame
# frozen_string_literal: true

class Admin::UsersController < Admin::StaffController
  skip_before_action :check_xhr, only: :new_bot

  before_action :ensure_admin, only: %i[new_bot create_bot bot_username_suggestion]
  before_action :rate_limit_bot_creation, only: :create_bot

  before_action :fetch_user,
                only: %i[
                  suspend
                  unsuspend
                  log_out
                  grant_admin
                  revoke_admin
                  revoke_moderation
                  grant_moderation
                  approve
                  activate
                  deactivate
                  silence
                  unsilence
                  trust_level
                  trust_level_lock
                  add_group
                  remove_group
                  primary_group
                  anonymize
                  merge
                  reset_bounce_score
                  disable_second_factor
                  delete_posts_batch
                  sso_record
                  delete_associated_accounts
                ]

  def index
    query = ::AdminUserIndexQuery.new(params, guardian:)
    users = query.find_users

    opts = {
      include_can_be_deleted: true,
      include_can_be_suspended: true,
      include_silence_reason: true,
      include_suspend_reason: true,
      silence_reasons: query.penalty_reasons(users.select(&:silenced?), :silence_user),
      suspend_reasons: query.penalty_reasons(users.select(&:suspended?), :suspend_user),
    }
    if params[:query] == "bots"
      opts[:user_ids] = users.map(&:id)
      opts[:bot_creators] = query.bot_creators(opts[:user_ids]) if guardian.is_admin?
    end

    if params[:show_emails] == "true"
      StaffActionLogger.new(current_user).log_show_emails(users, context: request.path)
      opts[:emails_desired] = true
    end

    render_serialized(users, AdminUserListSerializer, opts)
  end

  def new_bot
    if request.format.json?
      render json: {
               default_trust_level: SiteSetting.default_trust_level,
               name_required: SiteSetting.full_name_requirement == "required_at_signup",
             }
    else
      render "default/empty"
    end
  end

  def bot_username_suggestion
    render json: { username: UserNameSuggester.suggest(params.require(:name)) }
  end

  def create_bot
    plugin_param_names = DiscoursePluginRegistry.bot_creation_params.keys
    bot = params.expect(bot: %i[name username trust_level] + plugin_param_names)
    plugin_params = bot.extract!(*plugin_param_names).to_h

    # Request uses `key`, as `api_key` would be read as an authentication credential.
    key = params[:key]
    raise Discourse::InvalidParameters.new(:key) if key && !key.is_a?(ActionController::Parameters)

    User::CreateBot.call(
      service_params.merge(params: bot.to_h.merge(api_key: key&.to_unsafe_h, plugin_params:)),
    ) do
      on_success do |user:, api_key: nil|
        render json: {
                 user: AdminUserSerializer.new(user, scope: guardian, root: false).as_json,
                 key:
                   api_key && ApiKeySerializer.new(api_key, scope: guardian, root: false).as_json,
               }.compact,
               status: :created,
               location: admin_user_show_path(id: user.id, username: user.username)
      end
      on_failed_policy(:can_create_bot) { raise Discourse::InvalidAccess }
      on_failed_policy(:site_not_archived) { raise Discourse::SiteArchived }
      on_failed_contract { |contract| render_json_error(contract.errors.full_messages) }
      on_model_not_found(:bot_id) { |result| raise result.exception }
      on_model_errors(:user) { |user| render_json_error(user) }
      on_model_not_found(:user) do |result|
        raise result.exception if result.exception
        raise Discourse::NotFound
      end
      on_model_errors(:api_key) { |invalid_key| render_json_error(invalid_key) }
      on_model_not_found(:api_key) do |result|
        raise result.exception if result.exception
        raise Discourse::NotFound
      end
    end
  end

  def show
    @user = User.find_by(id: params[:id])
    raise Discourse::NotFound unless @user

    render_serialized(
      @user,
      AdminDetailedUserSerializer,
      root: false,
      similar_users_count: @user.similar_users.count,
      include_silence_reason: true,
      include_ip: guardian.can_see_ip?,
    )
  end

  def similar_users
    @user = User.find_by(id: params[:user_id])
    raise Discourse::NotFound if !@user

    render_json_dump(
      {
        users:
          ActiveModel::ArraySerializer.new(
            @user.similar_users.limit(User::MAX_SIMILAR_USERS),
            each_serializer: SimilarAdminUserSerializer,
            scope: guardian,
            root: false,
          ),
      },
    )
  end

  def delete_posts_batch
    deleted_posts = @user.delete_posts_in_batches(guardian)
    # staff action logs will have an entry for each post

    render json: { posts_deleted: deleted_posts.length }
  end

  def delete_posts_decider
    @user = User.find_by(id: params[:user_id])
    raise Discourse::NotFound if !@user
    raise Discourse::InvalidAccess unless guardian.can_delete_all_posts?(@user)

    post_count = @user.post_count
    threshold = SiteSetting.delete_all_posts_background_threshold.to_i

    if threshold > 0 && post_count > threshold
      Jobs.enqueue(:delete_user_posts, user_id: @user.id, acting_user_id: current_user.id)
      render json: { job_enqueued: true, post_count: post_count }
    else
      render json: { job_enqueued: false, post_count: post_count }
    end
  end

  # DELETE action to delete penalty history for a user
  def penalty_history
    # We don't delete any history, we merely remove the action type
    # with a removed type. It can still be viewed in the logs but
    # will not affect TL3 promotions.
    sql = <<~SQL
      UPDATE user_histories
      SET action = CASE
        WHEN action = :silence_user THEN :removed_silence_user
        WHEN action = :unsilence_user THEN :removed_unsilence_user
        WHEN action = :suspend_user THEN :removed_suspend_user
        WHEN action = :unsuspend_user THEN :removed_unsuspend_user
      END
      WHERE target_user_id = :user_id
        AND action IN (
          :silence_user,
          :suspend_user,
          :unsilence_user,
          :unsuspend_user
        )
    SQL

    DB.exec(
      sql,
      UserHistory
        .actions
        .slice(
          :silence_user,
          :suspend_user,
          :unsilence_user,
          :unsuspend_user,
          :removed_silence_user,
          :removed_unsilence_user,
          :removed_suspend_user,
          :removed_unsuspend_user,
        )
        .merge(user_id: params[:user_id].to_i),
    )

    render json: success_json
  end

  def suspend
    User::Suspend.call(service_params) do
      on_success do |params:, user:, full_reason:|
        render_json_dump(
          suspension: {
            suspend_reason: params.reason,
            full_suspend_reason: full_reason,
            suspended_till: user.suspended_till,
            suspended_at: user.suspended_at,
            suspended_by: BasicUserSerializer.new(current_user, root: false).as_json,
          },
        )
      end
      on_failed_contract do |contract|
        render json: failed_json.merge(errors: contract.errors.full_messages), status: :bad_request
      end
      on_model_not_found(:user) { raise Discourse::NotFound }
      on_failed_policy(:not_suspended_already) do |policy|
        render json: failed_json.merge(message: policy.reason), status: :conflict
      end
      on_failed_policy(:can_suspend_all_users) { raise Discourse::InvalidAccess.new }
    end
  end

  def unsuspend
    guardian.ensure_can_unsuspend!(@user)

    UserSuspender.unsuspend(@user, by_user: current_user)

    render_json_dump(suspension: { suspended_till: nil, suspended_at: nil })
  end

  def log_out
    if @user
      @user.user_auth_tokens.destroy_all
      PushNotificationPusher.clear_subscriptions(@user)
      @user.logged_out
      render json: success_json
    else
      render json: { error: I18n.t("admin_js.admin.users.id_not_found") }, status: :not_found
    end
  end

  def revoke_admin
    guardian.ensure_can_revoke_admin!(@user)
    @user.revoke_admin!
    StaffActionLogger.new(current_user).log_revoke_admin(@user)
    render_serialized(@user, AdminDetailedUserSerializer, root: false)
  end

  def grant_admin
    result = run_second_factor!(SecondFactor::Actions::GrantAdmin)
    if result.no_second_factors_enabled?
      render json: success_json.merge(email_confirmation_required: true)
    else
      render json: success_json
    end
  end

  def revoke_moderation
    guardian.ensure_can_revoke_moderation!(@user)
    @user.revoke_moderation!
    StaffActionLogger.new(current_user).log_revoke_moderation(@user)
    render_serialized(@user, AdminDetailedUserSerializer, root: false)
  end

  def grant_moderation
    guardian.ensure_can_grant_moderation!(@user)
    @user.grant_moderation!
    StaffActionLogger.new(current_user).log_grant_moderation(@user)
    render_serialized(@user, AdminDetailedUserSerializer, root: false)
  end

  def add_group
    group = Group.find(params[:group_id].to_i)
    raise Discourse::NotFound unless group

    return render_json_error(I18n.t("groups.errors.can_not_modify_automatic")) if group.automatic
    guardian.ensure_can_edit!(group)

    group.add(@user)
    GroupActionLogger.new(current_user, group).log_add_user_to_group(@user)

    render body: nil
  end

  def remove_group
    group = Group.find(params[:group_id].to_i)
    raise Discourse::NotFound unless group

    return render_json_error(I18n.t("groups.errors.can_not_modify_automatic")) if group.automatic
    guardian.ensure_can_edit!(group)

    if group.remove(@user)
      GroupActionLogger.new(current_user, group).log_remove_user_from_group(@user)
    end

    render body: nil
  end

  def primary_group
    if params[:primary_group_id].present?
      primary_group_id = params[:primary_group_id].to_i
      if group = Group.find(primary_group_id)
        guardian.ensure_can_change_primary_group!(@user, group)

        @user.primary_group_id = primary_group_id if group.user_ids.include?(@user.id)
      end
    else
      @user.primary_group_id = nil
    end

    @user.save!

    render body: nil
  end

  def trust_level
    guardian.ensure_can_change_trust_level!(@user)
    level = params[:level].to_i

    if @user.manual_locked_trust_level.nil?
      if [0, 1, 2].include?(level) && Promotion.public_send("tl#{level + 1}_met?", @user)
        @user.manual_locked_trust_level = level
        @user.save
      elsif level == 3 && Promotion.tl3_lost?(@user)
        @user.manual_locked_trust_level = level
        @user.save
      end
    end

    @user.change_trust_level!(level, log_action_for: current_user)

    render_serialized(@user, AdminUserSerializer)
  rescue Discourse::InvalidAccess => e
    render_json_error(e.message)
  end

  def trust_level_lock
    guardian.ensure_can_change_trust_level!(@user)

    new_lock = params[:locked].to_s
    return render_json_error I18n.t("errors.invalid_boolean") unless new_lock =~ /true|false/

    @user.manual_locked_trust_level = (new_lock == "true") ? @user.trust_level : nil
    @user.save

    StaffActionLogger.new(current_user).log_lock_trust_level(@user)
    Promotion.recalculate(@user, current_user)

    render body: nil
  end

  def approve
    UserApprover.approve(guardian, @user)
    render body: nil
  end

  def approve_bulk
    Reviewable.bulk_perform_targets(
      current_user,
      :approve_user,
      "ReviewableUser",
      params[:users],
      allow_reviewed: true,
    )
    render body: nil
  end

  def activate
    UserActivator.activate(guardian, @user)
    render json: success_json
  end

  def deactivate
    UserDeactivator.deactivate(
      guardian,
      @user,
      context: params.slice(:context),
      allow_deletion: true,
    )
    refresh_browser @user
    render json: success_json
  end

  def silence
    User::Silence.call(service_params) do
      on_success do |full_reason:, user:|
        render_json_dump(
          silence: {
            silenced: true,
            silence_reason: user.silence_reason,
            full_silence_reason: full_reason,
            silenced_till: user.silenced_till,
            silenced_at: user.silenced_at,
            silenced_by:
              BasicUserSerializer.new(
                current_user,
                root: false,
                include_silence_reason: true,
              ).as_json,
          },
        )
      end
      on_failed_contract do |contract|
        render json: failed_json.merge(errors: contract.errors.full_messages), status: :bad_request
      end
      on_model_not_found(:user) { raise Discourse::NotFound }
      on_failed_policy(:not_silenced_already) do |policy|
        render json: failed_json.merge(message: policy.reason), status: :conflict
      end
      on_failed_policy(:can_silence_all_users) { raise Discourse::InvalidAccess.new }
    end
  end

  def unsilence
    guardian.ensure_can_unsilence_user! @user
    UserSilencer.unsilence(@user, current_user)

    render_json_dump(
      unsilence: {
        silenced: false,
        silence_reason: nil,
        full_silence_reason: nil,
        silenced_till: nil,
        silenced_at: nil,
      },
    )
  end

  def disable_second_factor
    guardian.ensure_can_disable_second_factor!(@user)
    user_second_factor = @user.user_second_factors
    user_security_key = @user.security_keys
    raise Discourse::InvalidParameters if user_second_factor.empty? && user_security_key.empty?

    user_second_factor.destroy_all
    user_security_key.destroy_all
    StaffActionLogger.new(current_user).log_disable_second_factor_auth(@user)

    Jobs.enqueue(:critical_user_email, type: "account_second_factor_disabled", user_id: @user.id)

    render json: success_json
  end

  def destroy
    user = User.find_by(id: params[:id].to_i)
    guardian.ensure_can_delete_user!(user)

    options = params.slice(:context, :delete_as_spammer)
    %i[delete_posts block_email block_urls block_ip].each do |param_name|
      options[param_name] = ActiveModel::Type::Boolean.new.cast(params[param_name])
    end
    options[:prepare_for_destroy] = true

    hijack do
      if UserDestroyer.new(current_user).destroy(user, options)
        render json: { deleted: true }
      else
        render json: {
                 deleted: false,
                 user: AdminDetailedUserSerializer.new(user, root: false).as_json,
               }
      end
    rescue UserDestroyer::PostsExistError
      render json: {
               deleted: false,
               message:
                 I18n.t(
                   "user.cannot_delete_has_posts",
                   username: user.username,
                   count: user.posts.joins(:topic).count,
                 ),
             },
             status: :forbidden
    end
  end

  def destroy_bulk
    service_arg = service_params

    hijack do
      User::BulkDestroy.call(service_arg) do
        on_success { render json: { deleted: true } }

        on_failed_contract do |contract|
          render json: failed_json.merge(errors: contract.errors.full_messages),
                 status: :bad_request
        end

        on_failed_policy(:can_delete_users) do
          render json: failed_json.merge(errors: [I18n.t("user.cannot_bulk_delete")]),
                 status: :forbidden
        end

        on_model_not_found(:users) { render json: failed_json, status: :not_found }
      end
    end
  end

  def suspend_bulk
    service_arg = service_params

    hijack do
      User::BulkSuspend.call(service_arg) do
        on_success { render json: { suspended: true } }

        on_failed_contract do |contract|
          render json: failed_json.merge(errors: contract.errors.full_messages),
                 status: :bad_request
        end

        on_failed_policy(:can_suspend_users) do
          render json: failed_json.merge(errors: [I18n.t("user.cannot_bulk_suspend")]),
                 status: :forbidden
        end

        on_model_not_found(:users) { render json: failed_json, status: :not_found }
      end
    end
  end

  def badges
  end

  def tl3_requirements
  end

  def ip_info
    params.require(:ip)
    raise Discourse::InvalidAccess.new unless guardian.can_see_ip?

    render json: DiscourseIpInfo.get(params[:ip], resolve_hostname: true)
  end

  def sync_sso
    return render body: nil, status: :not_found unless SiteSetting.enable_discourse_connect

    sso =
      DiscourseConnect.parse(
        Rack::Utils.build_query(sso: params[:sso].to_s, sig: params[:sig].to_s),
        server_session:,
      )
    user = sso.lookup_or_create_user
    DiscourseEvent.trigger(:sync_sso, user)
    render_serialized(user, AdminDetailedUserSerializer, root: false)
  rescue DiscourseConnect::ParseError
    render json: failed_json.merge(message: I18n.t("discourse_connect.login_error")),
           status: :unprocessable_entity
  rescue DiscourseConnect::BlankExternalId
    render json: failed_json.merge(message: I18n.t("discourse_connect.blank_id_error")),
           status: :unprocessable_entity
  rescue DiscourseConnect::BannedExternalId
    render json: failed_json.merge(message: I18n.t("discourse_connect.banned_id_error")),
           status: :unprocessable_entity
  rescue ActiveRecord::RecordInvalid => e
    render json: failed_json.merge(message: e.message), status: :forbidden
  end

  def delete_other_accounts_with_same_ip
    params.require(:user_id)

    query = AdminUserIndexQuery.new(same_ip_query_params, guardian: guardian)
    raise Discourse::NotFound unless query.same_ip_target_user

    user_destroyer = UserDestroyer.new(current_user)
    options = {
      delete_posts: true,
      block_email: true,
      block_urls: true,
      block_ip: true,
      delete_as_spammer: true,
      context: same_ip_address_context(query),
    }

    query.find_users(50).each { |user| user_destroyer.destroy(user, options) }

    render json: success_json
  end

  def total_other_accounts_with_same_ip
    params.require(:user_id)

    render json: {
             total: AdminUserIndexQuery.new(same_ip_query_params, guardian: guardian).count_users,
           }
  end

  def anonymize
    guardian.ensure_can_anonymize_user!(@user)
    opts = {}
    opts[:anonymize_ip] = params[:anonymize_ip] if params[:anonymize_ip].present?

    if user = UserAnonymizer.new(@user, current_user, opts).make_anonymous
      render json: success_json.merge(username: user.username)
    else
      render json:
               failed_json.merge(user: AdminDetailedUserSerializer.new(user, root: false).as_json)
    end
  end

  def merge
    target_username = params.require(:target_username)
    target_user = User.find_by_username(target_username)
    raise Discourse::NotFound if target_user.blank?

    guardian.ensure_can_merge_users!(@user, target_user)

    Jobs.enqueue(
      :merge_user,
      user_id: @user.id,
      target_user_id: target_user.id,
      current_user_id: current_user.id,
    )
    render json: success_json
  end

  def reset_bounce_score
    guardian.ensure_can_reset_bounce_score!(@user)
    @user.user_stat&.reset_bounce_score!
    StaffActionLogger.new(current_user).log_reset_bounce_score(@user)
    render json: success_json
  end

  def sso_record
    guardian.ensure_can_delete_sso_record!(@user)
    @user.single_sign_on_record.destroy!
    render json: success_json
  end

  def delete_associated_accounts
    guardian.ensure_can_delete_user_associated_accounts!(@user)
    previous_value =
      @user
        .user_associated_accounts
        .select(:provider_name, :provider_uid, :info)
        .map do |associated_account|
          {
            provider: associated_account.provider_name,
            uid: associated_account.provider_uid,
            info: associated_account.info,
          }.to_s
        end
        .join(",")
    StaffActionLogger.new(current_user).log_delete_associated_accounts(
      @user,
      previous_value:,
      context: params[:context],
    )
    @user.user_associated_accounts.destroy_all
    render json: success_json
  end

  private

  def rate_limit_bot_creation
    RateLimiter.new(current_user, "create-bot", 10, 1.minute, apply_limit_to_staff: true).performed!
  end

  def fetch_user
    @user = User.find_by(id: params[:user_id])
    raise Discourse::NotFound unless @user
  end

  def same_ip_query_params
    {
      same_ip_user_id: params[:user_id],
      exclude: params[:user_id],
      ip_type: params[:ip_type].presence,
      order: "trust_level DESC",
    }.compact
  end

  def same_ip_address_context(query)
    if guardian.can_see_ip? && (ip = query.same_ip_address).present?
      I18n.t("user.destroy_reasons.same_ip_address", ip_address: ip)
    else
      I18n.t(
        "user.destroy_reasons.same_ip_address_user",
        username: query.same_ip_target_user.username,
      )
    end
  end

  def refresh_browser(user)
    MessageBus.publish "/file-change", ["refresh"], user_ids: [user.id]
  end
end