Skip to content

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

17.8 KB
Raw Blame
# frozen_string_literal: true

class GroupsController < ApplicationController
  requires_login only: %i[
                   set_notifications
                   mentionable
                   messageable
                   check_name
                   update
                   histories
                   request_membership
                   search
                   new
                   test_email_settings
                   add_members
                   add_owners
                   remove_member
                   handle_membership_request
                   edit
                 ]

  skip_before_action :preload_json, :check_xhr, only: %i[posts_feed mentions_feed]
  skip_before_action :check_xhr, only: [:show]
  after_action :add_noindex_header

  TYPE_FILTERS = GroupDirectoryQuery::TYPE_FILTERS

  def index
    page = fetch_int_from_params(:page, default: 0)
    page_size = MobileDetection.mobile_device?(request.user_agent) ? 15 : 36
    filter = params[:filter]
    type = params[:type]
    result =
      GroupDirectoryQuery.new(user: current_user, guardian:, modifier_context: self).call(
        username: params[:username],
        filter:,
        type:,
        order: params[:order],
        ascending: params[:asc].to_s == "true",
        page:,
        limit: page_size,
      )
    user_group_ids = result.memberships.keys
    owner_group_ids =
      result.memberships.filter_map { |group_id, membership| group_id if membership.owner? }

    render_json_dump(
      groups:
        serialize_data(result.groups, BasicGroupSerializer, user_group_ids:, owner_group_ids:),
      extras: {
        type_filters: result.type_filters,
      },
      total_rows_groups: result.total,
      load_more_groups:
        groups_path(
          page: page + 1,
          type: type,
          order: result.order,
          asc: result.order ? params[:asc] : nil,
          filter: filter,
        ),
    )
  end

  def show
    respond_to do |format|
      group = find_group_for_show

      format.html do
        @title = group.full_name.presence || group.name
        @full_title = "#{@title} - #{SiteSetting.title}"
        @description_meta = group.bio_summary || @title
        render :show
      end

      format.json do
        groups = Group.visible_groups(current_user)
        if !guardian.is_staff?
          groups =
            groups.where(
              "groups.automatic IS FALSE OR groups.id = ?",
              Group::AUTO_GROUPS[:moderators],
            )
        end

        render_json_dump(
          group: serialize_data(group, GroupShowSerializer, root: nil),
          extras: {
            visible_group_names: groups.pluck(:name),
          },
        )
      end
    end
  end

  def new
  end

  def edit
  end

  def update
    group = Group.find(params[:id])
    guardian.ensure_can_edit!(group) if !guardian.can_admin_group?(group)

    attributes = params.require(:group).permit(*GroupUpdater.permitted_params(guardian, group:))
    updated =
      GroupUpdater.update(guardian, group, attributes, update_existing_users: existing_users_choice)
    return render_json_error(group) if !updated

    # Redirect user to groups index page if they can no longer see the group
    return redirect_with_client_support groups_path if !guardian.can_see?(group)

    render json: success_json
  rescue GroupUpdater::ExistingUsersConfirmationRequired => error
    render status: :unprocessable_entity,
           json: {
             user_count: error.user_count,
             errors: [error.message],
           }
  end

  def posts
    group = find_group(:name)
    guardian.ensure_can_see_group_members!(group)

    posts =
      group.posts_for(guardian, params.permit(:before_post_id, :before, :category_id)).limit(20)

    response = { posts: serialize_data(posts, GroupPostSerializer) }

    if guardian.can_lazy_load_categories?
      category_ids = posts.map { |p| p.topic.category_id }.compact.uniq
      categories = Category.secured(guardian).with_parents(category_ids)
      response[:categories] = serialize_data(categories, CategoryBadgeSerializer)
    end

    render json: response
  end

  def posts_feed
    group = find_group(:name)
    guardian.ensure_can_see_group_members!(group)

    @posts =
      group.posts_for(guardian, params.permit(:before_post_id, :before, :category_id)).limit(50)
    @title =
      "#{SiteSetting.title} - #{I18n.t("rss_description.group_posts", group_name: group.name)}"
    @link = Discourse.base_url
    @description = I18n.t("rss_description.group_posts", group_name: group.name)

    render "posts/latest", formats: [:rss]
  end

  def mentions
    raise Discourse::NotFound unless SiteSetting.enable_mentions?

    group = find_group(:name)
    guardian.ensure_can_see_group_members!(group)

    posts =
      group.mentioned_posts_for(
        guardian,
        params.permit(:before_post_id, :before, :category_id),
      ).limit(20)

    response = { posts: serialize_data(posts, GroupPostSerializer) }

    if guardian.can_lazy_load_categories?
      category_ids = posts.map { |p| p.topic.category_id }.compact.uniq
      categories = Category.secured(guardian).with_parents(category_ids)
      response[:categories] = serialize_data(categories, CategoryBadgeSerializer)
    end

    render json: response
  end

  def mentions_feed
    raise Discourse::NotFound unless SiteSetting.enable_mentions?

    group = find_group(:name)
    guardian.ensure_can_see_group_members!(group)

    @posts =
      group.mentioned_posts_for(
        guardian,
        params.permit(:before_post_id, :before, :category_id),
      ).limit(50)
    @title =
      "#{SiteSetting.title} - #{I18n.t("rss_description.group_mentions", group_name: group.name)}"
    @link = Discourse.base_url
    @description = I18n.t("rss_description.group_mentions", group_name: group.name)

    render "posts/latest", formats: [:rss]
  end

  MEMBERS_MAX_PAGE_SIZE = 1_000
  MEMBERS_DEFAULT_PAGE_SIZE = 50

  def members
    group = find_group(:name)

    guardian.ensure_can_see_group_members!(group)

    limit = fetch_limit_from_params(default: MEMBERS_DEFAULT_PAGE_SIZE, max: MEMBERS_MAX_PAGE_SIZE)
    offset = params[:offset].to_i

    raise Discourse::InvalidParameters.new(:offset) if offset < 0

    dir = params[:asc].to_s == "true" ? "ASC" : "DESC"
    order = "NOT group_users.owner"

    if params[:requesters]
      guardian.ensure_can_edit!(group)

      users = group.requesters
      total = users.count

      if (filter = params[:filter]).present?
        filter = filter.split(",") if filter.include?(",")

        if current_user&.admin
          users = users.filter_by_username_or_email(filter)
        else
          users = users.filter_by_username(filter)
        end
      end

      users =
        users
          .select("users.*, group_requests.reason, group_requests.created_at requested_at")
          .order(params[:order] == "requested_at" ? "group_requests.created_at #{dir}" : "")
          .order(username_lower: dir)
          .limit(limit)
          .offset(offset)

      return(
        render json: {
                 members: serialize_data(users, GroupRequesterSerializer),
                 meta: {
                   total: total,
                   limit: limit,
                   offset: offset,
                 },
               }
      )
    end

    include_custom_fields = params[:include_custom_fields] == "true"

    allowed_fields = User.allowed_user_custom_fields(guardian)
    if guardian.is_staff?
      allowed_fields += UserField.all.pluck(:id).map { |fid| "#{User::USER_FIELD_PREFIX}#{fid}" }
    end

    if params[:order] && %w[last_posted_at last_seen_at].include?(params[:order])
      order = "#{params[:order]} #{dir} NULLS LAST"
    elsif params[:order] == "added_at"
      order = "group_users.created_at #{dir}"
    elsif include_custom_fields && params[:order] == "custom_field" &&
          allowed_fields.include?(params[:order_field])
      order =
        "(SELECT value FROM user_custom_fields ucf WHERE ucf.user_id = users.id AND ucf.name = #{ActiveRecord::Base.connection.quote(params[:order_field])}) #{dir} NULLS LAST"
    end

    users = group.listed_users
    total = users.count

    if (filter = params[:filter]).present?
      filter = filter.split(",") if filter.include?(",")

      if current_user&.admin
        users = users.filter_by_username_or_email(filter)
      else
        users = users.filter_by_username(filter)
      end
    end

    users =
      users
        .includes(:primary_group)
        .includes(:user_option)
        .select("users.*, group_users.created_at as added_at")
        .order(order)
        .order(username_lower: dir)

    members = users.limit(limit).offset(offset)
    owners = users.where("group_users.owner")

    render json: {
             members: serialize_data(members, GroupUserWithCustomFieldsSerializer),
             owners: serialize_data(owners, GroupUserWithCustomFieldsSerializer),
             meta: {
               total: total,
               limit: limit,
               offset: offset,
             },
           }
  end

  def add_members
    group = Group.find(params[:id])

    result =
      GroupMemberAdder.add(
        guardian,
        group,
        **user_selectors,
        emails: params[:emails],
        notify_users: notify_users_choice,
        skip_email: params[:skip_email].to_s == "true",
      )

    render json: success_json.merge!(usernames: result[:usernames], emails: result[:emails])
  rescue GroupMemberAdder::EmailsNotAllowed,
         GroupMemberAdder::TooManyUsers,
         GroupMemberAdder::AlreadyMembers => error
    render_json_error(error.message)
  rescue RateLimiter::LimitExceeded => error
    render_json_error(
      I18n.t(
        "invite.rate_limit",
        count: SiteSetting.max_invites_per_day,
        time_left: error.time_left,
      ),
    )
  end

  def add_owners
    group = Group.find_by(id: params.require(:id))
    raise Discourse::NotFound unless group

    result =
      GroupOwnerManager.add(
        guardian,
        group,
        **user_selectors,
        notify_users: params[:notify_users].to_s == "true",
      )

    render json: success_json.merge!(usernames: result[:usernames])
  rescue GroupMutations::AutomaticGroup => error
    render_json_error(error.message)
  end

  def join
    ensure_logged_in

    group = find_group_for_show
    raise Discourse::NotFound unless group

    GroupSelfMembership.join(guardian, group)
  end

  def handle_membership_request
    group = Group.find_by(id: params[:id])
    raise Discourse::InvalidParameters.new(:id) if group.blank?
    guardian.ensure_can_edit!(group)

    user = User.find_by(id: params[:user_id])
    raise Discourse::InvalidParameters.new(:user_id) if user.blank?

    GroupMembershipRequestHandler.handle(guardian, group, user, accept: params[:accept].present?)

    render json: success_json
  end

  def mentionable
    group = find_group(:name)

    if group
      render json: { mentionable: Group.mentionable(current_user).where(id: group.id).present? }
    else
      raise Discourse::InvalidAccess.new
    end
  end

  def messageable
    group = find_group(:name)

    if group
      render json: { messageable: guardian.can_send_private_message?(group) }
    else
      raise Discourse::InvalidAccess.new
    end
  end

  def check_name
    group_name = params.require(:group_name)
    checker = UsernameCheckerService.new(allow_reserved_username: true)
    render json: checker.check_username(group_name, nil)
  end

  def remove_member
    group = Group.find_by(id: params[:id])
    raise Discourse::NotFound unless group

    # maintain backwards compatibility with the singular param names
    result =
      GroupMemberRemover.remove(
        guardian,
        group,
        usernames: params[:username].presence || params[:usernames],
        user_id: params[:user_id],
        user_ids: params[:user_ids],
        user_emails: params[:user_email].presence || params[:user_emails],
      )

    render json:
             success_json.merge!(
               usernames: result[:usernames],
               skipped_usernames: result[:skipped_usernames],
             )
  end

  def leave
    ensure_logged_in

    group = Group.find_by(id: params[:id])
    raise Discourse::NotFound unless group

    GroupSelfMembership.leave(guardian, group)
  end

  def request_membership
    reason = params.require(:reason)
    group = find_group(:name)

    post = GroupMembershipRequester.request(guardian, group, reason)

    render json: success_json.merge(relative_url: post.topic.relative_url)
  rescue GroupMembershipRequester::AlreadyRequested => error
    render json: failed_json.merge(error: error.message), status: :conflict
  end

  def set_notifications
    group = find_group(:name)
    notification_level = params.require(:notification_level)

    user_id = current_user.id
    user_id = params[:user_id] || user_id if guardian.is_staff?

    group_user = GroupUser.find_by(group_id: group.id, user_id: user_id)
    raise Discourse::InvalidParameters.new(:user_id) if group_user.blank?

    group_user.update!(notification_level: notification_level)

    render json: success_json
  end

  def histories
    group = find_group(:name)
    guardian.ensure_can_edit!(group) unless guardian.can_admin_group?(group)

    page_size = 25
    offset = (params[:offset] && params[:offset].to_i) || 0

    group_histories =
      GroupHistory.with_filters(group, params[:filters]).limit(page_size).offset(offset * page_size)

    render_json_dump(
      logs: serialize_data(group_histories, BasicGroupHistorySerializer),
      all_loaded: group_histories.count < page_size,
    )
  end

  def search
    include_everyone =
      (params[:include_everyone] == "true" || params[:include_pseudogroups] == "true") &&
        !SiteSetting.granular_anonymous_and_logged_in_groups_permissions
    include_pseudogroups = params[:include_pseudogroups] == "true"
    groups =
      Group.visible_groups(
        current_user,
        ["name"],
        include_everyone: include_everyone,
        include_pseudogroups: include_pseudogroups,
      ).includes(:flair_upload)

    if (term = params[:term]).present?
      groups =
        groups.where(
          "position(LOWER(:term) IN LOWER(groups.name)) <> 0 OR position(LOWER(:term) IN LOWER(groups.full_name)) <> 0",
          term: term,
        )
    end

    groups = groups.where(automatic: false) if params[:ignore_automatic].to_s == "true"
    groups = DiscoursePluginRegistry.apply_modifier(:groups_search_query, groups, self)

    if Group.preloaded_custom_field_names.present?
      Group.preload_custom_fields(groups, Group.preloaded_custom_field_names)
    end

    render_serialized(groups, BasicGroupSerializer)
  end

  def permissions
    group = find_group(:name)
    category_groups =
      group.category_groups.select do |category_group|
        guardian.can_see_category?(category_group.category)
      end
    render_serialized(
      category_groups.sort_by { |category_group| category_group.category.name },
      CategoryGroupSerializer,
    )
  end

  def test_email_settings
    params.require(:group_id)
    params.require(:protocol)
    params.require(:port)
    params.require(:host)
    params.require(:username)
    params.require(:password)

    group = Group.find(params[:group_id])
    guardian.ensure_can_admin_group!(group)

    RateLimiter.new(current_user, "group_test_email_settings", 5, 1.minute).performed!

    settings = params.except(:name, :protocol)
    email_host = params[:host]

    begin
      FinalDestination::SSRFDetector.lookup_and_filter_ips(email_host)
    rescue FinalDestination::SSRFDetector::DisallowedIpError
      raise Discourse::InvalidParameters.new(I18n.t("email_settings.invalid_host"))
    rescue FinalDestination::SSRFDetector::LookupFailedError
      raise Discourse::InvalidParameters.new(I18n.t("email_settings.host_resolve_failed"))
    end

    if params[:protocol] != "smtp"
      raise Discourse::InvalidParameters.new("Valid protocol to test is smtp")
    end

    hijack do
      raise Discourse::InvalidParameters if params[:ssl_mode].blank?

      settings.delete(:ssl_mode)

      if Group.smtp_ssl_modes.values.exclude?(params[:ssl_mode].to_i)
        raise Discourse::InvalidParameters.new("SSL mode must be valid")
      end

      final_settings =
        settings.merge(
          enable_tls: params[:ssl_mode].to_i == Group.smtp_ssl_modes[:ssl_tls],
          enable_starttls_auto: params[:ssl_mode].to_i == Group.smtp_ssl_modes[:starttls],
        ).permit(:host, :port, :username, :password, :enable_tls, :enable_starttls_auto, :debug)
      EmailSettingsValidator.validate_as_user(
        current_user,
        "smtp",
        **final_settings.to_h.symbolize_keys,
      )

      render json: success_json
    rescue *EmailSettingsExceptionHandler::EXPECTED_EXCEPTIONS, StandardError => err
      render_json_error(EmailSettingsExceptionHandler.friendly_exception_message(err, email_host))
    end
  end

  private

  def user_selectors
    {
      usernames: params[:usernames],
      user_id: params[:user_id],
      user_ids: params[:user_ids],
      user_emails: params[:user_emails],
    }
  end

  # nil when the caller said nothing, so the mutation keeps its own default
  def notify_users_choice
    return nil if !params.key?(:notify_users)
    params[:notify_users].to_s == "true"
  end

  def existing_users_choice
    return nil if params[:update_existing_users].blank?
    params[:update_existing_users] == "true"
  end

  def find_group_for_show(ensure_can_see: true)
    group =
      if params[:id]
        Group.find_by(id: params[:id])
      elsif params[:name]
        Group.find_by("LOWER(name) = ?", params[:name].downcase)
      end

    raise Discourse::NotFound if ensure_can_see && !guardian.can_see_group?(group)
    group
  end

  def find_group(param_name, ensure_can_see: true)
    name = params.require(param_name)

    group = Group.find_by("LOWER(name) = ?", name.downcase)

    raise Discourse::NotFound if ensure_can_see && !guardian.can_see_group?(group)
    group
  end
end