theforeman/foreman

require 'resolv'

class Setting < ApplicationRecord
  audited :except => [:name]
  extend FriendlyId
  friendly_id :name
  include ActiveModel::Validations
  include EncryptValue
  include PermissionName

  TYPES = %w{integer boolean hash array string}
  NONZERO_ATTRS = %w{puppet_interval idle_timeout entries_per_page outofsync_interval}
  # constant BLANK_ATTRS is deprecated and all settings without custom validation allow blank values
  # if you wish to validate non-empty arrays, please add validation through the new setting DSL
  BLANK_ATTRS = %w{}
  ARRAY_HOSTNAMES = %w{trusted_hosts}
  URI_ATTRS = %w{foreman_url unattended_url}
  URI_BLANK_ATTRS = %w{login_delegation_logout_url}
  IP_ATTRS = %w{libvirt_default_console_address}
  REGEXP_ATTRS = %w{}
  EMAIL_ATTRS = %w{administrator email_reply_address}
  NOT_STRIPPED = %w{}

  class ValueValidator < ActiveModel::Validator
    def validate(record)
      record.send("validate_#{record.name}", record)
    end
  end

  validates_lengths_from_database

  validates :name, :presence => true, :uniqueness => true
  validates :value, :numericality => true, :length => {:maximum => 8}, :if => proc { |s| s.settings_type == "integer" }
  validates :value, :numericality => {:greater_than => 0}, :if => proc { |s| NONZERO_ATTRS.include?(s.name) }
  validates :value, :inclusion => {:in => [true, false]}, :if => proc { |s| s.settings_type.to_s == "boolean" }, :allow_nil => true
  validates :value, :url_schema => ['http', 'https'], :if => proc { |s| URI_ATTRS.include?(s.name) }

  validates :value, :url_schema => ['http', 'https'], :if => proc { |s| URI_BLANK_ATTRS.include?(s.name) && s.value.present? }

  validate :validate_host_owner, :if => proc { |s| s.name == "host_owner" }
  validates :value, :format => { :with => Resolv::AddressRegex }, :if => proc { |s| IP_ATTRS.include? s.name }
  validates :value, :regexp => true, :if => proc { |s| REGEXP_ATTRS.include? s.name }
  validates :value, :array_type => true, :if => proc { |s| s.settings_type == "array" }
  validates_with ValueValidator, :if => proc { |s| Foreman.settings.ready? && s.respond_to?("validate_#{s.name}") }
  validates :value, :array_hostnames_ips => true, :if => proc { |s| ARRAY_HOSTNAMES.include? s.name }
  validates :value, :email => true, :if => proc { |s| EMAIL_ATTRS.include? s.name }
  before_save :clear_value_when_default
  validate :validate_frozen_attributes
  before_validation :remove_whitespaces, :if => proc { |s| s.settings_type == "array" }
  # Custom validations are added from SettingManager class
  after_find :readonly_when_overridden
  after_save :refresh_registry_value
  default_scope -> { order(:name) }

  scope :order_by, ->(attr) { except(:order).order(attr) }

  scoped_search :on => :id, :complete_enabled => false, :only_explicit => true, :validator => ScopedSearch::Validators::INTEGER
  scoped_search on: :name, complete_value: :true, operators: ['=', '~']
  scoped_search on: :description, complete_value: :true, operators: ['~']

  delegate :settings_type, :encrypted, :encrypted?, :default, to: :setting_definition, allow_nil: true

  def self.config_file
    'settings.yaml'
  end

  # can't use our own settings
  def self.per_page
    20
  end

  def self.complete_for(search_query, opts = {})
    SettingRegistry::SettingCompleter.auto_complete(Foreman.settings, scoped_search_definition, search_query, opts)
  end

  def self.[](name)
    Foreman.settings[name]
  end

  def self.[]=(name, value)
    Foreman.settings[name] = value
  end

  def self.setting_type_from_value(value_for_type)
    t = value_for_type.class.to_s.downcase
    return t if TYPES.include?(t)
    return "integer" if value_for_type.is_a?(Integer)
    return "boolean" if value_for_type.is_a?(TrueClass) || value_for_type.is_a?(FalseClass)
  end

  def to_param
    name
  end

  def value=(v)
    v = v.to_yaml unless v.nil?
    # the has_attribute is for enabling DB migrations on older versions
    if setting_definition&.encrypted?
      # Don't re-write the attribute if the current encrypted value is identical to the new one
      current_value = self[:value]
      unless is_decryptable?(current_value) && decrypt_field(current_value) == v
        self[:value] = encrypt_field(v)
      end
    else
      self[:value] = v
    end
  end

  def value
    v = self[:value]
    v = decrypt_field(v)
    v.nil? ? default : YAML.safe_load(v, permitted_classes: [Symbol, Pathname])
  end
  alias_method :value_before_type_cast, :value

  def parse_string_value(val)
    case settings_type
    when "boolean"
      boolean = Foreman::Cast.to_bool(val)

      if boolean.nil?
        invalid_value_error _("must be boolean")
      end

      self.value = boolean

    when "integer"
      if val.to_s =~ /\A\d+\Z/
        self.value = val.to_i
      else
        invalid_value_error _("must be integer")
      end

    when "array"
      if val =~ /\A\[.*\]\Z/
        begin
          self.value = YAML.safe_load(val.gsub(/(\,)(\S)/, "\\1 \\2"))
        rescue => e
          invalid_value_error e.to_s
        end
      else
        invalid_value_error _("must be an array")
      end

    when "string", "text", nil
      # string is taken as default setting type for parsing
      self.value = NOT_STRIPPED.include?(name) ? val : val.to_s.strip

    when "hash"
      raise Foreman::SettingValueException, N_("Parsing a hash from a string is not supported")

    else
      raise Foreman::SettingValueException.new(N_("Parsing settings type '%s' from a string is not defined"), settings_type)

    end
    if errors.present?
      raise Foreman::SettingValueException.new(N_("Error parsing value for setting '%(name)s': %(error)s"),
        { 'name' => name, 'error' => errors.full_messages.join(", ") })
    end
    true
  end

  def self.regexp_expand_wildcard_string(string, options = {})
    prefix = options[:prefix] || '\A'
    suffix = options[:suffix] || '\Z'
    prefix + Regexp.escape(string).gsub('\*', '.*').gsub('\?', '.') + suffix
  end

  def self.convert_array_to_regexp(array, regexp_options = {})
    Regexp.new(array.map { |string| regexp_expand_wildcard_string(string, regexp_options) }.join('|'))
  end

  def has_readonly_value?
    SETTINGS.key?(name.to_sym)
  end

  def self.readonly_value(name)
    SETTINGS[name]
  end

  def read_attribute_before_type_cast(attr_name)
    return value if attr_name == :value
    super(attr_name)
  end

  def self.replace_keywords(keyword)
    keyword&.gsub '$VERSION', SETTINGS[:version].version
  end

  # Methods for loading default settings

  def self.default_settings
    []
  end

  def self.load_defaults
    return false unless table_exists?
    Foreman::Deprecation.deprecation_warning('3.4', "subclassing Setting is deprecated '#{name}' should be migrated to setting DSL "\
                                                    'see https://github.com/theforeman/foreman/blob/develop/developer_docs/how_to_create_a_plugin.asciidoc#settings for details')
    default_settings.each do |s|
      t = Setting.setting_type_from_value(s[:default]) || 'string'
      kwargs = s.except(:name).merge(type: t.to_sym, category: name.delete_prefix('Setting::'), context: :deprecated)
      Foreman.settings._add(s[:name], **kwargs)
    end
    true
  end

  def self.select_collection_registry
    Foreman.settings.select_collection_registry
  end

  def self.set(name, description, default, full_name = nil, value = nil, options = {})
    if options.has_key? :collection
      select_collection_registry.add(name, options)
    end
    options[:encrypted] ||= false
    {:name => name, :value => value, :description => description, :default => default, :full_name => full_name, :encrypted => options[:encrypted]}
  end

  def select_collection
    self.class.select_collection_registry.collection_for self
  end

  def self.model_name
    ActiveModel::Name.new(Setting)
  end

  # End methods for loading default settings

  private

  def validate_host_owner
    owner_type_and_id = value
    return if owner_type_and_id.blank?

    OwnerClassifier.classify_owner(owner_type_and_id)
  rescue ArgumentError, ActiveRecord::RecordNotFound => e
    errors.add(:value, e.message)
  end

  def invalid_value_error(error)
    errors.add(:value, _("is invalid: %s") % error)
  end

  def validate_frozen_attributes
    return true if new_record?
    changed_attributes.each do |c, old|
      # Allow settings_type to change at first (from nil) since it gets populated during validation
      if c.to_s == 'name'
        errors.add(c, _("is not allowed to change"))
        return false
      end
    end
    true
  end

  def clear_value_when_default
    if value == default
      self[:value] = nil
    end
  end

  def readonly_when_overridden
    readonly! if !new_record? && has_readonly_value?
  end

  def setting_definition
    return unless Foreman.settings.ready?
    Foreman.settings.find(name)
  end

  def refresh_registry_value
    setting_definition&.tap do |definition|
      definition.updated_at = updated_at
      definition.value_from_db = value
    end
  end

  def remove_whitespaces
    self[:value] = value.each { |a| a.strip! if a.respond_to? :strip! }
  end
end