jro_apps/redmine Commit - r10850:7b8ebb7e3ffc

Auto-populate fields while creating a new user with LDAP (#10286)....

Jean-Philippe Lang -

r10850:7b8ebb7e3ffc

parent child

Context file:

r10850:7b8ebb7e3ffc

Collapse all files

app/controllers/auth_sources_controller.rb +14 0

                  redirect_to auth_sources_path
                end
+               def autocomplete_for_new_user
+                 results = AuthSource.search(params[:term])
+                 render :json => results.map {|result| {
+                   'value' => result[:login],
+                   'label' => "#{result[:login]} (#{result[:firstname]} #{result[:lastname]})",
+                   'login' => result[:login].to_s,
+                   'firstname' => result[:firstname].to_s,
+                   'lastname' => result[:lastname].to_s,
+                   'mail' => result[:mail].to_s,
+                   'auth_source_id' => result[:auth_source_id].to_s
+                 }}
+               end
                private
                def find_auth_source

app/models/auth_source.rb +18 0

                  write_ciphered_attribute(:account_password, arg)
                end
+               def searchable?
+                 false
+               end
+               def self.search(q)
+                 results = []
+                 AuthSource.all.each do |source|
+                   begin
+                     if source.searchable?
+                       results += source.search(q)
+                     end
+                   rescue AuthSourceException => e
+                     logger.error "Error while searching users in #{source.name}: #{e.message}"
+                   end
+                 end
+                 results
+               end
                def allow_password_changes?
                  self.class.allow_password_changes?
                end

app/models/auth_source_ldap.rb +35 -7

                  "LDAP"
                end
+               # Returns true if this source can be searched for users
+               def searchable?
+                 !account.to_s.include?("$login") && %w(login firstname lastname mail).all? {|a| send("attr_#{a}?")}
+               end
+               # Searches the source for users and returns an array of results
+               def search(q)
+                 q = q.to_s.strip
+                 return [] unless searchable? && q.present?
+                 results = []
+                 search_filter = base_filter & Net::LDAP::Filter.begins(self.attr_login, q)
+                 ldap_con = initialize_ldap_con(self.account, self.account_password)
+                 ldap_con.search(:base => self.base_dn,
+                                 :filter => search_filter,
+                                 :attributes => ['dn', self.attr_login, self.attr_firstname, self.attr_lastname, self.attr_mail],
+                                 :size => 10) do |entry|
+                   attrs = get_user_attributes_from_ldap_entry(entry)
+                   attrs[:login] = AuthSourceLdap.get_attr(entry, self.attr_login)
+                   results << attrs
+                 end
+                 results
+               rescue Net::LDAP::LdapError => e
+                 raise AuthSourceException.new(e.message)
+               end
                private
                def with_timeout(&block)
                  nil
                end
+               def base_filter
+                 filter = Net::LDAP::Filter.eq("objectClass", "*")
+                 if f = ldap_filter
+                   filter = filter & f
+                 end
+                 filter
+               end
                def validate_filter
                  if filter.present? && ldap_filter.nil?
                    errors.add(:filter, :invalid)
                  else
                    ldap_con = initialize_ldap_con(self.account, self.account_password)
                  end
-                 login_filter = Net::LDAP::Filter.eq( self.attr_login, login )
-                 object_filter = Net::LDAP::Filter.eq( "objectClass", "*" )
                  attrs = {}
-                 search_filter = object_filter & login_filter
-                 if f = ldap_filter
-                   search_filter = search_filter & f
-                 end
+                 search_filter = base_filter & Net::LDAP::Filter.eq(self.attr_login, login)
                  ldap_con.search( :base => self.base_dn,
                                   :filter => search_filter,

app/views/users/new.html.erb +18 0

		@@ -10,3 +10,21
10	10	<%= submit_tag l(:button_create_and_continue), :name => 'continue' %>
11	11	</p>
12	12	<% end %>
	13
	14	<% if @auth_sources.present? && @auth_sources.any?(&:searchable?) %>
	15	<%= javascript_tag do %>
	16	observeAutocompleteField('user_login', '<%= escape_javascript autocomplete_for_new_user_auth_sources_path %>', {
	17	select: function(event, ui) {
	18	$('input#user_firstname').val(ui.item.firstname);
	19	$('input#user_lastname').val(ui.item.lastname);
	20	$('input#user_mail').val(ui.item.mail);
	21	$('select#user_auth_source_id option').each(function(){
	22	if ($(this).attr('value') == ui.item.auth_source_id) {
	23	$(this).attr('selected', true);
	24	$('select#user_auth_source_id').trigger('change');
	25	}
	26	});
	27	}
	28	});
	29	<% end %>
	30	<% end %>

config/routes.rb +3 0

                  member do
                    get 'test_connection', :as => 'try_connection'
                  end
+                 collection do
+                   get 'autocomplete_for_new_user'
+                 end
                end
                match 'workflows', :controller => 'workflows', :action => 'index', :via => :get

public/javascripts/application.js +3 -3

                });
              }
-             function observeAutocompleteField(fieldId, url) {
+             function observeAutocompleteField(fieldId, url, options) {
                $(document).ready(function() {
-                 $('#'+fieldId).autocomplete({
+                 $('#'+fieldId).autocomplete($.extend({
                    source: url,
                    minLength: 2
-                 });
+                 }, options));
                });
              }

test/functional/auth_sources_controller_test.rb +16 0

		@@ -149,4 +149,20 class AuthSourcesControllerTest < ActionController::TestCase
149	149	assert_not_nil flash[:error]
150	150	assert_include 'Something went wrong', flash[:error]
151	151	end
	152
	153	def test_autocomplete_for_new_user
	154	AuthSource.expects(:search).with('foo').returns([
	155	{:login => 'foo1', :firstname => 'John', :lastname => 'Smith', :mail => 'foo1@example.net', :auth_source_id => 1},
	156	{:login => 'Smith', :firstname => 'John', :lastname => 'Doe', :mail => 'foo2@example.net', :auth_source_id => 1}
	157	])
	158
	159	get :autocomplete_for_new_user, :term => 'foo'
	160	assert_response :success
	161	assert_equal 'application/json', response.content_type
	162	json = ActiveSupport::JSON.decode(response.body)
	163	assert_kind_of Array, json
	164	assert_equal 2, json.size
	165	assert_equal 'foo1', json.first['value']
	166	assert_equal 'foo1 (John Smith)', json.first['label']
	167	end
152	168	end

test/integration/routing/auth_sources_test.rb +4 0

                      { :controller => 'auth_sources', :action => 'test_connection',
                        :id => '1234' }
                    )
+                 assert_routing(
+                     { :method => 'get', :path => "/auth_sources/autocomplete_for_new_user" },
+                     { :controller => 'auth_sources', :action => 'autocomplete_for_new_user' }
+                   )
                end
              end

test/unit/auth_source_ldap_test.rb +24 0

		@@ -124,6 +124,30 class AuthSourceLdapTest < ActiveSupport::TestCase
124	124	auth_source.authenticate 'example1', '123456'
125	125	end
126	126	end
	127
	128	def test_search_should_return_matching_entries
	129	results = AuthSource.search("exa")
	130	assert_equal 1, results.size
	131	result = results.first
	132	assert_kind_of Hash, result
	133	assert_equal "example1", result[:login]
	134	assert_equal "Example", result[:firstname]
	135	assert_equal "One", result[:lastname]
	136	assert_equal "example1@redmine.org", result[:mail]
	137	assert_equal 1, result[:auth_source_id]
	138	end
	139
	140	def test_search_with_no_match_should_return_an_empty_array
	141	results = AuthSource.search("wro")
	142	assert_equal [], results
	143	end
	144
	145	def test_search_with_exception_should_return_an_empty_array
	146	Net::LDAP.stubs(:new).raises(Net::LDAP::LdapError, 'Cannot connect')
	147
	148	results = AuthSource.search("exa")
	149	assert_equal [], results
	150	end
127	151	else
128	152	puts '(Test LDAP server not configured)'
129	153	end

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages