Skip to content

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

10.8 KB
Raw Blame
# frozen_string_literal: true

class GroupUpdater
  # Raised when a notification-default change would alter existing members and
  # the caller has not said whether to apply it to them.
  class ExistingUsersConfirmationRequired < StandardError
    attr_reader :user_count

    def initialize(user_count)
      @user_count = user_count
      super(I18n.t("groups.errors.update_existing_users_required", count: user_count))
    end
  end

  NOTIFICATION_DEFAULT_LEVELS = %i[muted regular tracking watching watching_first_post].freeze
  BLANK_SELECTION = ["-1", -1].freeze

  def self.permitted_params(guardian, group:)
    new(guardian, group, {}).permitted_params
  end

  def self.permitted_names(guardian, group:)
    permitted_params(guardian, group:).flat_map do |attribute|
      attribute.is_a?(Hash) ? attribute.keys.map(&:to_s) : attribute.to_s
    end
  end

  def self.update(guardian, group, attributes, update_existing_users: nil)
    new(guardian, group, attributes, update_existing_users:).update
  end

  def initialize(guardian, group, attributes, update_existing_users: nil)
    @guardian = guardian
    @group = group
    @attributes = attributes.to_h.with_indifferent_access
    @update_existing_users = update_existing_users
  end

  def permitted_params
    attributes = %i[
      bio_raw
      default_notification_level
      messageable_level
      mentionable_level
      flair_bg_color
      flair_color
      flair_icon
      flair_upload_id
    ]

    if !group.automatic
      attributes.push(
        :allow_membership_requests,
        :full_name,
        :public_exit,
        :public_admission,
        :membership_request_template,
      )
    end

    attributes.push(:visibility_level, :members_visibility_level) if guardian.is_staff?
    attributes.push(:incoming_email) if guardian.is_staff?

    if !group.automatic && guardian.is_staff?
      attributes.push(:title, :primary_group, :name, :grant_trust_level, :publish_read_state)

      custom_fields = DiscoursePluginRegistry.editable_group_custom_fields
      attributes << { custom_fields: custom_fields } if custom_fields.present?
    end

    if guardian.is_admin?
      attributes.push(
        :smtp_server,
        :smtp_port,
        :smtp_ssl_mode,
        :smtp_enabled,
        :smtp_updated_by,
        :smtp_updated_at,
        :email_username,
        :email_password,
        :email_from_alias,
        :allow_unknown_sender_topic_replies,
      )
    end

    attributes << :automatic_membership_email_domains if !group.automatic && can_admin_group?

    if !group.automatic || guardian.is_admin?
      NOTIFICATION_DEFAULT_LEVELS.each do |level|
        attributes << { "#{level}_category_ids" => [] }
        attributes << { "#{level}_tags" => [] }
      end
    end

    attributes << { associated_group_ids: [] } if guardian.can_associate_groups?
    attributes.concat(DiscoursePluginRegistry.group_params)
    attributes
  end

  def update
    guardian.ensure_can_edit!(group) if !can_admin_group?

    @attributes = ActionController::Parameters.new(attributes).permit(*permitted_params).to_h
    group_attributes = attributes_without_disabled_email_settings
    return false if !valid_flair_upload?(group_attributes)
    notification_level, categories, tags = nil

    if !group.automatic || guardian.is_admin?
      changes = notification_default_changes(group_attributes)
      return false if !changes
      notification_level, categories, tags = changes

      if update_existing_users.nil?
        user_count = apply_to_existing_users(notification_level, categories, tags, mutate: false)
        raise ExistingUsersConfirmationRequired, user_count if user_count > 0
      end
    end

    return false if !group.update(group_attributes)

    GroupActionLogger.new(guardian.user, group).log_change_group_settings
    group.record_email_setting_changes!(guardian.user)
    if update_existing_users
      apply_to_existing_users(notification_level, categories, tags, mutate: true)
    end

    true
  end

  private

  attr_reader :guardian, :group, :attributes, :update_existing_users

  def can_admin_group?
    return @can_admin_group if defined?(@can_admin_group)
    @can_admin_group = guardian.can_admin_group?(group)
  end

  def valid_flair_upload?(group_attributes)
    return true if !group_attributes.key?(:flair_upload_id)

    upload_id = group_attributes[:flair_upload_id].presence
    return true if upload_id.blank?
    return true if upload_id.to_i == group.flair_upload_id
    return true if guardian.can_use_flair_upload?(upload_id)

    group.errors.add(:base, I18n.t("groups.errors.flair_upload_not_owned"))
    false
  end

  def attributes_without_disabled_email_settings
    return attributes if !group.smtp_enabled
    return attributes if !attributes.key?(:smtp_enabled)
    return attributes if ActiveModel::Type::Boolean.new.cast(attributes[:smtp_enabled]) != false

    attributes.merge(
      smtp_server: nil,
      smtp_ssl_mode: Group.smtp_ssl_modes[:none],
      smtp_port: nil,
      email_username: nil,
      email_password: nil,
    )
  end

  def notification_default_changes(group_attributes)
    category_notifications =
      group.group_category_notification_defaults.pluck(:category_id, :notification_level).to_h
    tag_notifications =
      group.group_tag_notification_defaults.pluck(:tag_id, :notification_level).to_h
    categories = {}
    tags = {}
    selected_categories = Set.new
    selected_tags = Set.new

    NotificationLevels.all.each do |key, value|
      category_ids =
        Category.where(id: Array(group_attributes[:"#{key}_category_ids"]) - BLANK_SELECTION).pluck(
          :id,
        )
      tag_names = Array(group_attributes[:"#{key}_tags"]) - BLANK_SELECTION
      tag_ids = GroupTagNotificationDefault.resolve_tag_ids(tag_names)

      if selected_categories.intersect?(category_ids) || selected_tags.intersect?(tag_ids)
        group.errors.add(:base, I18n.t("groups.errors.conflicting_notification_defaults"))
        return false
      end
      selected_categories.merge(category_ids)
      selected_tags.merge(tag_ids)

      category_ids.each do |category_id|
        metadata = change_metadata(category_notifications, category_id, value)
        categories[category_id] = metadata if metadata
      end

      tag_ids.each do |tag_id|
        metadata = change_metadata(tag_notifications, tag_id, value)
        tags[tag_id] = metadata if metadata
      end
    end

    (category_notifications.keys - categories.keys).each do |category_id|
      level = NotificationLevels.all.key(category_notifications[category_id])
      next if !group_attributes.key?(:"#{level}_category_ids")

      categories[category_id] = { action: :delete, old_value: category_notifications[category_id] }
    end

    (tag_notifications.keys - tags.keys).each do |tag_id|
      level = NotificationLevels.all.key(tag_notifications[tag_id])
      next if !group_attributes.key?(:"#{level}_tags")

      tags[tag_id] = { action: :delete, old_value: tag_notifications[tag_id] }
    end

    notification_level = nil
    default_notification_level = group_attributes[:default_notification_level]&.to_i

    if default_notification_level.present? &&
         group.default_notification_level != default_notification_level
      notification_level = {
        old_value: group.default_notification_level,
        new_value: default_notification_level,
      }
    end

    [notification_level, categories, tags]
  end

  # Returns nil when the existing default already matches, which also drops the
  # target from the "no longer defaulted" set computed by the caller.
  def change_metadata(existing, id, new_value)
    old_value = existing[id]
    return { old_value:, new_value:, action: :create } if old_value.blank?

    if old_value == new_value
      existing.delete(id)
      return nil
    end

    { old_value:, new_value:, action: :update }
  end

  def apply_to_existing_users(notification_level, categories, tags, mutate:)
    return 0 if notification_level.blank? && categories.blank? && tags.blank?

    group_users = group.group_users
    user_ids = []

    if notification_level.present?
      users = group_users.where(notification_level: notification_level[:old_value])

      if mutate
        users.update_all(notification_level: notification_level[:new_value])
      else
        user_ids += users.pluck(:user_id)
      end
    end

    categories.to_a.each do |category_id, data|
      next if data[:action] != :update && data[:action] != :delete

      category_users =
        CategoryUser.where(
          category_id:,
          notification_level: data[:old_value],
          user_id: group_users.select(:user_id),
        )

      if mutate
        category_users.delete_all
      else
        user_ids += category_users.pluck(:user_id)
      end

      categories.delete(category_id) if data[:action] == :delete && mutate
    end

    tags.to_a.each do |tag_id, data|
      next if data[:action] != :update && data[:action] != :delete

      tag_users =
        TagUser.where(
          tag_id:,
          notification_level: data[:old_value],
          user_id: group_users.select(:user_id),
        )

      if mutate
        tag_users.delete_all
      else
        user_ids += tag_users.pluck(:user_id)
      end

      tags.delete(tag_id) if data[:action] == :delete && mutate
    end

    if categories.present? || tags.present?
      user_ids += backfill_notification_defaults(group_users, categories, tags, mutate:)
    end

    user_ids.uniq.count
  end

  def backfill_notification_defaults(group_users, categories, tags, mutate:)
    user_ids = []

    group_users
      .select(:id, :user_id)
      .find_in_batches do |batch|
        batch_user_ids = batch.pluck(:user_id)

        categories.each do |category_id, data|
          skip_user_ids =
            CategoryUser
              .where(category_id:, user_id: batch_user_ids)
              .where.not(notification_level: nil)
              .pluck(:user_id)
          rows =
            (batch_user_ids - skip_user_ids).map do |user_id|
              { category_id:, user_id:, notification_level: data[:new_value] }
            end
          next if rows.blank?

          mutate ? CategoryUser.insert_all!(rows) : user_ids += rows.pluck(:user_id)
        end

        tags.each do |tag_id, data|
          skip_user_ids =
            TagUser
              .where(tag_id:, user_id: batch_user_ids)
              .where.not(notification_level: nil)
              .pluck(:user_id)
          rows =
            (batch_user_ids - skip_user_ids).map do |user_id|
              {
                tag_id:,
                user_id:,
                notification_level: data[:new_value],
                created_at: Time.zone.now,
                updated_at: Time.zone.now,
              }
            end
          next if rows.blank?

          mutate ? TagUser.insert_all!(rows) : user_ids += rows.pluck(:user_id)
        end
      end

    user_ids
  end
end