module ActiveLdap::Validations

Public Instance Methods

human_attribute_name_with_gettext(attribute_key_name, options={}) click to toggle source
# File lib/active_ldap/validations.rb, line 10
def human_attribute_name_with_gettext(attribute_key_name, options={})
  logger.warn("options was ignored.") unless options.empty?
  s_("#{self}|#{attribute_key_name.to_s.humanize}")
end
save(*) click to toggle source
Calls superclass method
# File lib/active_ldap/validations.rb, line 43
def save(*)
  valid? ? super : false
end
save!(*) click to toggle source
Calls superclass method
# File lib/active_ldap/validations.rb, line 47
def save!(*)
  valid? ? super : raise(EntryInvalid.new(self))
end
valid?(context = nil) click to toggle source
Calls superclass method
# File lib/active_ldap/validations.rb, line 37
def valid?(context = nil)
  context ||= (new_entry? ? :create : :update)
  output = super(context)
  errors.empty? && output
end
validation_skip_attributes() click to toggle source
# File lib/active_ldap/validations.rb, line 29
def validation_skip_attributes
  @validation_skip_attributes ||= []
end
validation_skip_attributes=(attributes) click to toggle source
# File lib/active_ldap/validations.rb, line 33
def validation_skip_attributes=(attributes)
  @validation_skip_attributes = attributes
end

Private Instance Methods

format_validation_message(format, parameters) click to toggle source
# File lib/active_ldap/validations.rb, line 52
def format_validation_message(format, parameters)
  format % parameters
end
validate_dn() click to toggle source
# File lib/active_ldap/validations.rb, line 90
def validate_dn
  dn
rescue DistinguishedNameInvalid
  format = _("is invalid: %s")
  message = format_validation_message(format, $!.message)
  errors.add("distinguishedName", message)
rescue DistinguishedNameNotSetError
  format = _("isn't set: %s")
  message = format_validation_message(format, $!.message)
  errors.add("distinguishedName", message)
end
validate_duplicated_dn_creation() click to toggle source
# File lib/active_ldap/validations.rb, line 56
def validate_duplicated_dn_creation
  _dn = nil
  begin
    _dn = dn
  rescue DistinguishedNameInvalid, DistinguishedNameNotSetError
    return
  end
  if _dn and exist?
    format = _("is duplicated: %s")
    message = format_validation_message(format, _dn)
    errors.add("distinguishedName", message)
  end
end
validate_duplicated_dn_rename() click to toggle source
# File lib/active_ldap/validations.rb, line 70
def validate_duplicated_dn_rename
  _dn_attribute = dn_attribute_with_fallback
  original_dn_value = @ldap_data[_dn_attribute]
  current_dn_value = @data[_dn_attribute]
  return if original_dn_value == current_dn_value
  return if original_dn_value == [current_dn_value]

  _dn = nil
  begin
    _dn = dn
  rescue DistinguishedNameInvalid, DistinguishedNameNotSetError
    return
  end
  if _dn and exist?
    format = _("is duplicated: %s")
    message = format_validation_message(format, _dn)
    errors.add("distinguishedName", message)
  end
end
validate_excluded_classes() click to toggle source
# File lib/active_ldap/validations.rb, line 102
def validate_excluded_classes
  excluded_classes = self.class.excluded_classes
  return if excluded_classes.empty?

  _schema = schema
  _classes = classes.collect do |name|
    _schema.object_class(name)
  end
  unexpected_classes = excluded_classes.inject([]) do |classes, name|
    excluded_class = _schema.object_class(name)
    if _classes.include?(excluded_class)
      classes << excluded_class
    end
    classes
  end
  return if unexpected_classes.empty?

  names = unexpected_classes.collect do |object_class|
    self.class.human_object_class_name(object_class)
  end
  format = n_("has excluded value: %s",
              "has excluded values: %s",
              names.size)
  message = format_validation_message(format, names.join(", "))
  errors.add("objectClass", message)
end
validate_ldap_value(attribute, name, value) click to toggle source
# File lib/active_ldap/validations.rb, line 181
def validate_ldap_value(attribute, name, value)
  failed_reason, option = attribute.validate(value)
  return if failed_reason.nil?
  if attribute.binary?
    inspected_value = _("<binary-value>")
  else
    inspected_value = self.class.human_readable_format(value)
  end
  params = [inspected_value,
            self.class.human_syntax_description(attribute.syntax),
            failed_reason]
  if option
    format = _("(%s) has invalid format: %s: required syntax: %s: %s")
  else
    format = _("has invalid format: %s: required syntax: %s: %s")
  end
  params.unshift(option) if option
  message = format_validation_message(format, params)
  errors.add(name, message)
end
validate_ldap_values() click to toggle source
# File lib/active_ldap/validations.rb, line 171
def validate_ldap_values
  entry_attribute.schemata.each do |name, attribute|
    value = self[name]
    # Is it really proper location for setting encoding?
    attribute.apply_encoding(value)
    next if self.class.blank_value?(value)
    validate_ldap_value(attribute, name, value)
  end
end
validate_required_ldap_values() click to toggle source

#validate_required_ldap_values

Basic validation:

  • Verify that every 'MUST' specified in the schema has a value defined

# File lib/active_ldap/validations.rb, line 133
def validate_required_ldap_values
  _schema = nil
  @validation_skip_attributes ||= []
  _validation_skip_attributes =
    @validation_skip_attributes +
    (self.class.validation_skip_attributes || [])
  # Make sure all MUST attributes have a value
  entry_attribute.object_classes.each do |object_class|
    object_class.must.each do |required_attribute|
      # Normalize to ensure we catch schema problems
      # needed?
      real_name = to_real_attribute_name(required_attribute.name, true)
      raise UnknownAttribute.new(required_attribute) if real_name.nil?

      next if required_attribute.read_only?
      next if _validation_skip_attributes.include?(real_name)

      value = @data[real_name]
      next unless self.class.blank_value?(value)

      _schema ||= schema
      aliases = required_attribute.aliases.collect do |name|
        self.class.human_attribute_name(name)
      end
      args = [self.class.human_object_class_name(object_class)]
      if aliases.empty?
        format = _("is required attribute by objectClass '%s'")
      else
        format = _("is required attribute by objectClass "                         "'%s': aliases: %s")
        args << aliases.join(', ')
      end
      message = format_validation_message(format, args)
      errors.add(real_name, message)
    end
  end
end