Module: LdapLookup

Extended by:
Configuration
Defined in:
lib/ldap_lookup.rb,
lib/ldap_lookup/version.rb

Constant Summary collapse

VERSION = 
"0.1.8"

Class Method Summary collapse

Methods included from Configuration

configuration, define_setting

Class Method Details

.all_groups_for_user(uid) ⇒ Object 



141
142
143
144
145
146
147
148
149
150
151
152
153
154
 
# File 'lib/ldap_lookup.rb', line 141

def self.all_groups_for_user(uid)
  ldap = ldap_connection
  result_array = []

  result_attrs = ['dn']

  ldap.search(filter: "member=uid=#{uid},ou=People,dc=umich,dc=edu", attributes: result_attrs) do |item|
    item.each { |key, value| result_array << value.first.split('=')[1].split(',')[0] }
  end

  result_array.sort
ensure
  get_ldap_response(ldap)
end

.get_dept(uniqname) ⇒ Object 



93
94
95
 
# File 'lib/ldap_lookup.rb', line 93

def self.get_dept(uniqname)
  get_nested_attribute(uniqname, 'umichpostaladdressdata.addr1')
end

.get_email(uniqname) ⇒ Object 



89
90
91
 
# File 'lib/ldap_lookup.rb', line 89

def self.get_email(uniqname)
  get_user_attribute(uniqname, 'mail')
end

.get_email_distribution_list(group_name) ⇒ Object 



117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
 
# File 'lib/ldap_lookup.rb', line 117

def self.get_email_distribution_list(group_name)
  ldap = ldap_connection
  result_hash = {}

  search_param = group_name
  result_attrs = %w[cn umichGroupEmail member]

  search_filter = Net::LDAP::Filter.join(
    Net::LDAP::Filter.eq('cn', search_param),
    Net::LDAP::Filter.eq('objectClass', 'group')
  )

  ldap.search(filter: search_filter, attributes: result_attrs) do |item|
    result_hash['group_name'] = item['cn']&.first
    result_hash['group_email'] = item['umichGroupEmail']&.first
    members = item['member']&.map { |individual| individual.split(',').first.split('=')[1] }
    result_hash['members'] = members&.sort || []
  end

  result_hash
ensure
  get_ldap_response(ldap)
end

.get_ldap_response(ldap) ⇒ Object 



13
14
15
16
 
# File 'lib/ldap_lookup.rb', line 13

def self.get_ldap_response(ldap)
  response = ldap.get_operation_result
  raise "Response Code: #{response.code}, Message: #{response.message}" unless response.code.zero?
end

.get_nested_attribute(uniqname, nested_attribute) ⇒ Object 



44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
 
# File 'lib/ldap_lookup.rb', line 44

def self.get_nested_attribute(uniqname, nested_attribute)
  ldap = ldap_connection
  search_param = uniqname
  # Specify the full nested attribute path using dot notation
  result_attrs = [nested_attribute.split('.').first]

  search_filter = Net::LDAP::Filter.eq('uid', search_param)

  ldap.search(filter: search_filter, attributes: result_attrs) do |item|
    # Split the string into key-value pairs
    if string1 = item[nested_attribute.split('.').first]&.first
      key_value_pairs = string1.split('}:{')
      # Find the key-value pair for addr1
      target_pair = key_value_pairs.find { |pair| pair.include?("#{nested_attribute.split('.').last}=") } 
      # Extract the target value
      target_pair_value = target_pair.split('=').last
      return target_pair_value unless target_pair_value.nil?
    end
  end
  "No #{nested_attribute} found for #{uniqname}"

ensure
  get_ldap_response(ldap)
end

.get_simple_name(uniqname) ⇒ Object 



85
86
87
 
# File 'lib/ldap_lookup.rb', line 85

def self.get_simple_name(uniqname)
  get_user_attribute(uniqname, 'displayname')
end

.get_user_attribute(uniqname, attribute) ⇒ Object 



27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
 
# File 'lib/ldap_lookup.rb', line 27

def self.get_user_attribute(uniqname, attribute)
  ldap = ldap_connection
  search_param = uniqname
  result_attrs = [attribute]

  search_filter = Net::LDAP::Filter.eq('uid', search_param)

  ldap.search(filter: search_filter, attributes: result_attrs) do |item|
    value = item[attribute]&.first
    return value unless value.nil?
  end

  "No #{attribute} found for #{uniqname}"
ensure
  get_ldap_response(ldap)
end

.is_member_of_group?(uid, group_name) ⇒ Boolean

Returns:

  • (Boolean) 


97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
 
# File 'lib/ldap_lookup.rb', line 97

def self.is_member_of_group?(uid, group_name)
  ldap = ldap_connection
  search_param = group_name
  result_attrs = ['member']

  search_filter = Net::LDAP::Filter.join(
    Net::LDAP::Filter.eq('cn', search_param),
    Net::LDAP::Filter.eq('objectClass', 'group')
  )

  ldap.search(filter: search_filter, attributes: result_attrs) do |item|
    members = item['member']
    return true if members&.any? { |entry| entry.split(',').first.split('=')[1] == uid }
  end

  false
ensure
  get_ldap_response(ldap)
end

.ldap_connection ⇒ Object 



18
19
20
21
22
23
24
25
 
# File 'lib/ldap_lookup.rb', line 18

def self.ldap_connection
  Net::LDAP.new(
    host: host,
    port: port,
    base: base,
    auth: { method: :anonymous }
  )
end

.uid_exist?(uniqname) ⇒ Boolean

method to check if a uid exist in LDAP

Returns:

  • (Boolean) 


70
71
72
73
74
75
76
77
78
79
80
81
82
83
 
# File 'lib/ldap_lookup.rb', line 70

def self.uid_exist?(uniqname)
  ldap = ldap_connection
  search_param = uniqname

  search_filter = Net::LDAP::Filter.eq('uid', search_param)

  ldap.search(filter: search_filter) do |item|
    return true if item['uid'].first == search_param
  end

  false
ensure
  get_ldap_response(ldap)
end