Skip to content

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

7.7 KB
Raw Blame
# frozen_string_literal: true

class Admin::DashboardController < Admin::StaffController
  BULK_REPORTS_FILTER_KEYS = %i[start_date end_date].freeze

  before_action :ensure_admin,
                only: %i[
                  available_reports
                  mount_report
                  traffic
                  unmount_report
                  update_reports_section
                  update_configuration
                  update_section_settings
                ]

  def index
    render json: dashboard_sections_payload
  end

  def update_configuration
    sections = params.permit(sections: %i[id visible])[:sections] || []
    AdminDashboardSectionConfiguration.update(sections, actor: current_user)
    head :no_content
  end

  def update_section_settings
    section_id = params.require(:section_id)
    key = params.require(:setting_key)

    definition = AdminDashboardSectionConfiguration.setting_definition(section_id, key)

    AdminDashboardSectionConfiguration.update_setting(
      section_id:,
      key:,
      attrs: params.permit(*(definition&.dig(:permit) || [])),
    )
    head :no_content
  end

  def traffic
    AdminDashboardSiteTrafficExplorer.call(service_params.deep_merge(params: traffic_params)) do
      on_success { |traffic:| render json: traffic }
      on_failed_contract { raise Discourse::InvalidParameters }
      on_failed_step(:load_traffic) do |step|
        render json: { error_type: step.error }, status: :service_unavailable
      end
    end
  end

  def problems
    ProblemCheck.realtime.run_all

    render json: { problems: serialized_problems }
  end

  def new_features
    force_refresh = params[:force_refresh] == "true"

    if force_refresh
      RateLimiter.new(
        current_user,
        "force-refresh-new-features",
        5,
        1.minute,
        apply_limit_to_staff: true,
      ).performed!
    end

    new_features = DiscourseUpdates.new_features(force_refresh:)
    new_features_with_permanent_uc =
      DiscourseUpdates.merge_new_features_with_upcoming_changes(
        new_features&.map { |item| item.symbolize_keys } || [],
      )

    if current_user.admin? && most_recent = new_features_with_permanent_uc&.first
      DiscourseUpdates.bump_last_viewed_feature_date(current_user.id, most_recent[:created_at])
    end

    data = {
      new_features: new_features_with_permanent_uc,
      has_unseen_features: DiscourseUpdates.has_unseen_features?(current_user.id),
      release_notes_link: release_notes_link,
    }

    mark_new_features_as_seen

    render json: data
  end

  def toggle_feature
    UpcomingChanges::Toggle.call(service_params) do
      on_success { render(json: success_json) }
      on_failure { render(json: failed_json, status: :unprocessable_entity) }
      on_failed_policy(:current_user_is_admin) { raise Discourse::InvalidAccess }
      on_failed_policy(:setting_is_available) { raise Discourse::InvalidAccess }
      on_failed_contract do |contract|
        render(json: failed_json.merge(errors: contract.errors.full_messages), status: :bad_request)
      end
    end
  end

  def update_reports_section
    AdminDashboard::Reports::LayoutUpdater.call(
      items: parse_reports_items_payload,
      guardian: guardian,
    )
    head :no_content
  end

  def mount_report
    report =
      AdminDashboard::Reports::Mounter.mount(
        source: params.require(:source),
        identifier: params.require(:identifier),
        guardian: guardian,
      )
    render json: report.slice(:source, :identifier, :position, :rows, :cols), status: :created
  rescue AdminDashboard::Reports::Mounter::CapReached
    render_json_error(
      I18n.t("dashboard.reports.cap_reached", max: AdminDashboardReport::VISIBLE_CAP),
      status: 422,
    )
  end

  def unmount_report
    AdminDashboard::Reports::Mounter.unmount(
      source: params.require(:source),
      identifier: params.require(:identifier),
    )
    head :no_content
  end

  def available_reports
    search = params[:search]
    cursor = params.permit(cursor: %i[title key])[:cursor]&.to_h&.symbolize_keys
    enabled = AdminDashboard::Reports::Section.build(guardian: guardian, search: search)[:items]
    listing = AdminDashboard::Reports::Listing.call(cursor: cursor, search: search)

    render json: {
             providers: listing[:providers],
             enabled: enabled,
             available: listing[:items],
             has_more: listing[:has_more],
             cursor: listing[:cursor],
           }
  end

  def bulk_reports
    permitted_filters = params.permit(filters: BULK_REPORTS_FILTER_KEYS).fetch(:filters, nil)
    filters = permitted_filters.present? ? permitted_filters.to_h.symbolize_keys : {}

    hijack do
      render_json_dump(
        AdminDashboard::Reports::BulkFetch.call(
          items: parse_reports_items_payload,
          filters: filters,
          guardian: guardian,
        ),
      )
    end
  end

  private

  def traffic_params
    permitted = params.permit(:start_date, :end_date).to_h

    AdminDashboardSiteTrafficExplorer::FILTER_KEYS.each do |key|
      value = params[key]
      next if value.nil?

      if !value.is_a?(Array) || value.any? { |item| !item.is_a?(String) }
        raise Discourse::InvalidParameters.new(key)
      end

      permitted[key] = if key == :traffic_type
        value.flat_map { |item| item.split(",") }
      else
        value
      end
    end

    permitted
  end

  def serialized_problems
    serialize_data(AdminNotice.problem.order(:id), AdminNoticeSerializer)
  end

  def dashboard_sections_payload
    visible_ids = AdminDashboardSectionConfiguration.visible_section_ids
    data = {
      sections:
        AdminDashboardSectionLoader.build(
          section_ids: visible_ids,
          current_user: current_user,
          start_date: params[:start_date],
          end_date: params[:end_date],
          parallel: !mini_profiler_flamegraph_request?,
        ),
      problems: serialized_problems,
    }
    if current_user.admin?
      data[:configuration] = { sections: AdminDashboardSectionConfiguration.sections }
    end
    data
  end

  def mark_new_features_as_seen
    DiscourseUpdates.mark_new_features_as_seen(current_user.id)
  end

  def release_notes_link
    days_since_update =
      Discourse.last_commit_date ? ((DateTime.now - Discourse.last_commit_date) / 1.day).to_i : nil
    "https://meta.discourse.org/c/announcements/67?tags=release-notes&before=#{days_since_update}"
  end

  def parse_reports_items_payload
    raise Discourse::InvalidParameters.new(:items) if !params[:items].is_a?(Array)
    if params[:items].size > AdminDashboardReport::VISIBLE_CAP
      raise Discourse::InvalidParameters.new(:items)
    end

    existing_reports =
      AdminDashboardReport.all.index_by { |report| [report.source, report.identifier] }

    params
      .permit(items: %i[source identifier rows cols])
      .fetch(:items, [])
      .map do |entry|
        source = entry[:source]
        identifier = entry[:identifier]
        raise Discourse::InvalidParameters.new(:items) if source.blank? || identifier.blank?

        existing_report = existing_reports[[source.to_s, identifier.to_s]]
        rows = Integer(entry[:rows].presence || existing_report&.rows || 1, exception: false)
        if rows.nil? || rows < 1 || rows > AdminDashboardReport::MAX_ROWS
          raise Discourse::InvalidParameters.new(:items)
        end

        cols = Integer(entry[:cols].presence || existing_report&.cols || 1, exception: false)
        if cols.nil? || cols < 1 || cols > AdminDashboardReport::MAX_COLS
          raise Discourse::InvalidParameters.new(:items)
        end
        if rows > 1 && cols != AdminDashboardReport::MAX_COLS
          raise Discourse::InvalidParameters.new(:items)
        end

        { source: source.to_s, identifier: identifier.to_s, rows: rows, cols: cols }
      end
  end
end