DuckCorp » LdapShadows

type: belongs_to

object: group

many: uniqueMember

plugin:

min_uid: 10000

max_uid: 65535

type: belongs_to

object: individual

many: gidNumber

botsPrimaryMembers:

type: belongs_to

object: bot

many: gidNumber

individualsSecondaryMembers:

type: has_many

object: individual

mapping:

"type": {type: str, required: true, enum: [belongs_to, has_many]}

"object": {type: str, required: true}

"many": {type: str}

"primary_key": {type: str}

"plugin":

mapping:

"type": {type: str, required: true, enum: [belongs_to, has_many]}

"object": {type: str, required: true}

"many": {type: str}

"primary_key": {type: str}

"plugin":

#++

module ActiveLdap

module Validations

# unfinished workaround for activeldap#26720 (not sure it would work in all cases)

def validate_required_ldap_values

end

def handle

name = name.first if name.is_a? Array

name.strip

end

end

rel[:class_name] = foreign_klass.to_s

case rel[:type]

when 'belongs_to'

belongs_to field_name, rel.reject {|key, val| not ActiveLdap::Associations::ClassMethods::VALID_BELONGS_TO_OPTIONS.include?(key) }

when 'has_many'

has_many field_name, rel.reject {|key, val| not ActiveLdap::Associations::ClassMethods::VALID_HAS_MANY_OPTIONS.include?(key) }

else

object_relations_info[field_name] = {

:foreign_klass => foreign_klass,

:read_only => rel[:read_only] || false

}

end

attr_list.unshift(name_attribute) unless name_attribute.nil?

attr_list.each do |attr|

if attr == 'dn'

elsif self.attribute_present?(attr)

val = self.send(attr, true)

return val[0].strip

expert_attributes = self.class.parameters[:presentation][:expert_attributes]

admin_attributes = attr_list.select do |attr|

end

rel_list = self.possible_relations

parent_item = Manipulation.find_item_by_full_handle(self.class.shadow, parent_full_handle)

if self.new_entry?

else

raise PreProcessingError, _("Moving items is not yet implemented")

end

begin

parent_item = Manipulation.find_item_by_full_handle(self.class.shadow, parent_full_handle)

rescue

raise PreProcessingError, _("Cannot create the item: bad default parent for this kind of object: %s") % $!

end

# for ActiveLDAP

module ActiveLdap

class Base

def family_parent_dn

end

def family_parent

end

def family_children

end

def family_siblings

end

def family_siblings_dn

def self.items_find_from_strings(shadow, str_list)

ldap_search_objects = "(objectClass=*)"

ldap_search_aspects = ""

str_list.each do |str|

unless str =~ /^([a-zA-Z]*(?::[a-zA-Z]+)?)(=|~=)(.*)$/

raise SyntaxError, _("search parameter '%s' is invalid") % str

when 'parents'

val.split(",").each do |parent_fh|

parent = find_item_by_full_handle(shadow, parent_fh)

end

when 'siblings'

val.split(",").each do |sibling_fh|

sibling = find_item_by_full_handle(shadow, sibling_fh)

end

when 'children'

val.split(",").each do |child_fh|

child = find_item_by_full_handle(shadow, child_fh)

end

when 'ancestors'

val.split(",").each do |parent_fh|

parent = find_item_by_full_handle(shadow, parent_fh)

end

when 'successors'

val.split(",").each do |child_fh|

child = find_item_by_full_handle(shadow, child_fh)

dn.shift

end

end

else

raise PreProcessingError, _("Unknown type '%s' for field '%s'") % [type, field]

end

end

if ldap_search_where.empty?

end

ldap_search_where.each do |where|

res += ActiveLdap::Base.find(:all, :base => where[0], :scope => where[1], :filter => ldap_search_string, :attributes => ["objectClass"])

end

end

def self.find_raw_item_object(shadow, raw_item)

return {:full_handle => item.full_handle, :name => name, :item => item, :object => obj_klass, :is_root => is_root}

end

else

end

{:full_handle => nil, :name => "unknown/#{item_fake_hdl}", :is_root => is_root}

def self.interpret_field_value(shadow, syntax, val)

case syntax

when "1.3.6.1.4.1.1466.115.121.1.12"

LdapShadows::Manipulation.raw_item_info(shadow, raw_item, val.to_s)[:full_handle]

else

val

def self.find_item_by_full_handle(shadow, full_handle, with_admin_fields = false)

if full_handle == "root"

raw_item = ActiveLdap::Base.find(:first, :base => raw_item_dn, :scope => :base)

info = raw_item_info(shadow, raw_item, raw_item_dn)

if info.nil?

item_list = {}

if all_objects

ActiveLdap::Base.find(:all, :base => search_base, :scope => :sub, :attributes => ['']).each do |item|

end

else

self.get_config[:presentation][:tree_objects].each do |obj_hdl|

end

obj_klass.find(:all, :base => search_base, :scope => :sub).each do |item|

end

end

end

raw_tree = {}

tree = {}

dn_list = item_list.keys

dn_list.each do |dn|

current_dn = ActiveLdap::DistinguishedName.parse(current_dn_parts.join(","))

current_item = item_list[current_dn]

if current_item.nil?

item_list[current_dn] = current_item

end

p_item = LdapShadows::Manipulation.raw_item_info(self, item_list[current_dn])[:name]

if raw

res = {base_dn.to_s => raw_tree}

else

res = {LdapShadows::Manipulation.raw_item_info(self, base_obj)[:name] => tree}

end