Skip to content

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

5.8 KB
Raw Blame
# frozen_string_literal: true

class AccessControlList::Apply
  include Service::Base

  params do
    attribute :acl_target_type, :string
    attribute :acl_target_id, :integer
    attribute :acl_entries, :array, default: -> { [] } do
      attribute :type, :symbol
      attribute :id, :integer
      attribute :permission, :string

      validates :type, inclusion: { in: %i[group user] }
      validates :id, numericality: { only_integer: true, greater_than: 0 }
      validates :permission, presence: true
    end
    attribute :source, :string
    attribute :initial_owner_user_id, :integer
    attribute :owner_user_ids, :array

    before_validation do
      if owner_user_ids
        self.owner_user_ids =
          owner_user_ids.map { |user_id| Integer(user_id, exception: false) }.uniq
      end
    end

    validates :acl_target_type, presence: true
    validates :acl_target_id, numericality: { only_integer: true, greater_than: 0 }
    validates :source, presence: true, length: { maximum: 100 }
    validate :owner_user_ids_are_valid

    private

    def owner_user_ids_are_valid
      return if owner_user_ids.nil?

      all_ids_valid =
        owner_user_ids.all? { |user_id| user_id == Discourse::SYSTEM_USER_ID || user_id&.positive? }
      return if all_ids_valid

      errors.add(:owner_user_ids, :invalid)
    end
  end

  model :acl_target
  policy :has_no_owner_entries
  policy :grantees_exist
  policy :requested_owners_exist
  model :current_acl
  model :initial_owner, optional: true
  policy :has_initial_owner
  policy :can_change_owners
  model :replacement
  policy :has_at_least_one_owner
  policy :has_valid_permissions
  policy :has_no_banned_acl

  transaction do
    step :replace_permissions
    only_if(:ordinary_permissions_changed) { step :log_permission_change }
    only_if(:owners_added) { step :log_owner_additions }
    only_if(:owners_removed) { step :log_owner_removals }
  end

  step :refresh_target_permissions

  private

  def fetch_acl_target(params:)
    target_class =
      Site.access_control_target_classes.find { |klass| klass.name == params.acl_target_type }
    target_class&.find_by(id: params.acl_target_id)
  end

  def fetch_current_acl(acl_target:)
    AccessControlList.where(target: acl_target).target_acl(acl_target)
  end

  def fetch_initial_owner(params:, current_acl:)
    if current_acl.permission_user_ids(Acl::Permissions::OWNER).empty?
      User.find_by(id: params.initial_owner_user_id)
    end
  end

  def has_initial_owner(current_acl:, initial_owner:)
    current_acl.permission_user_ids(Acl::Permissions::OWNER).any? || initial_owner.present?
  end

  def has_no_owner_entries(params:)
    params.acl_entries.none? { |entry| entry.permission == Acl::Permissions::OWNER }
  end

  def requested_owners_exist(params:)
    return true if params.owner_user_ids.nil?

    User.where(id: params.owner_user_ids).count == params.owner_user_ids.length
  end

  def grantees_exist(params:)
    group_ids = params.acl_entries.filter_map { |entry| entry.id if entry.type == :group }.uniq
    user_ids = params.acl_entries.filter_map { |entry| entry.id if entry.type == :user }.uniq

    Group.where(id: group_ids).count == group_ids.length &&
      User.where(id: user_ids).count == user_ids.length
  end

  def fetch_replacement(params:, acl_target:, current_acl:, initial_owner:)
    AccessControlList::Action::BuildReplacement.call(
      acl_entries:
        params.acl_entries.map do |entry|
          { type: entry.type, id: entry.id, permission: entry.permission }
        end,
      initial_owner:,
      owner_user_ids: params.owner_user_ids,
      target: acl_target,
      current_acl:,
    )
  end

  def can_change_owners(params:, guardian:, current_acl:)
    return true if params.owner_user_ids.nil?

    guardian.is_admin? ||
      current_acl.permission_user_ids(Acl::Permissions::OWNER).include?(guardian.user&.id)
  end

  def has_at_least_one_owner(replacement:)
    replacement.permissions.dig(Acl::Permissions::OWNER, :user_ids)&.any?
  end

  def has_valid_permissions(acl_target:, replacement:)
    valid_permissions = acl_target.class.const_get(:ACL_PERMISSIONS).values
    replacement.flattened_acl.all? { |entry| valid_permissions.include?(entry[:permission].to_s) }
  end

  def has_no_banned_acl(acl_target:, replacement:)
    return true if !acl_target.class.has_banned_acl?

    replacement.flattened_acl.none? { |entry| acl_target.class.acl_is_banned?(entry) }
  end

  def replace_permissions(params:, acl_target:, replacement:)
    AccessControlList.where(target: acl_target).destroy_all
    AccessControlList.bulk_insert_flattened_acl!(
      replacement.flattened_acl,
      acl_target,
      params.source,
    )
  end

  def ordinary_permissions_changed(replacement:)
    replacement.ordinary_permissions_changed
  end

  def owners_added(replacement:)
    replacement.added_owner_user_ids.any?
  end

  def owners_removed(replacement:)
    replacement.removed_owner_user_ids.any?
  end

  def log_permission_change(guardian:, acl_target:, current_acl:, replacement:)
    StaffActionLogger.new(guardian.user).log_access_control_list_permission_change(
      acl_target,
      current_acl.permission_lookup.except(Acl::Permissions::OWNER),
      replacement.permissions.except(Acl::Permissions::OWNER),
    )
  end

  def log_owner_additions(guardian:, acl_target:, replacement:)
    logger = StaffActionLogger.new(guardian.user)
    User
      .where(id: replacement.added_owner_user_ids)
      .find_each { |user| logger.log_add_access_control_list_owner(acl_target, user) }
  end

  def log_owner_removals(guardian:, acl_target:, replacement:)
    logger = StaffActionLogger.new(guardian.user)
    User
      .where(id: replacement.removed_owner_user_ids)
      .find_each { |user| logger.log_remove_access_control_list_owner(acl_target, user) }
  end

  def refresh_target_permissions(acl_target:)
    acl_target.reload
  end
end