##// END OF EJS Templates
jro_apps » redmine
RSS
Fixed a bug in the OpenID login when a user signed up with OpenID but hasn't...
Eric Davis -
r2420:aed1787d510f
parent child
Show More
Side by Side Unified
Context file:
r2420:aed1787d510f Loading diff...:
Show file before | Show file after | Hide comments
@@ -1,278 +1,286
1 1 # Redmine - project management software
2 2 # Copyright (C) 2006-2008 Jean-Philippe Lang
3 3 #
4 4 # This program is free software; you can redistribute it and/or
5 5 # modify it under the terms of the GNU General Public License
6 6 # as published by the Free Software Foundation; either version 2
7 7 # of the License, or (at your option) any later version.
8 8 #
9 9 # This program is distributed in the hope that it will be useful,
10 10 # but WITHOUT ANY WARRANTY; without even the implied warranty of
11 11 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 12 # GNU General Public License for more details.
13 13 #
14 14 # You should have received a copy of the GNU General Public License
15 15 # along with this program; if not, write to the Free Software
16 16 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17 17
18 18 class AccountController < ApplicationController
19 19 helper :custom_fields
20 20 include CustomFieldsHelper
21 21
22 22 # prevents login action to be filtered by check_if_login_required application scope filter
23 23 skip_before_filter :check_if_login_required, :only => [:login, :lost_password, :register, :activate]
24 24
25 25 # Show user's account
26 26 def show
27 27 @user = User.active.find(params[:id])
28 28 @custom_values = @user.custom_values
29 29
30 30 # show only public projects and private projects that the logged in user is also a member of
31 31 @memberships = @user.memberships.select do |membership|
32 32 membership.project.is_public? || (User.current.member_of?(membership.project))
33 33 end
34 34
35 35 events = Redmine::Activity::Fetcher.new(User.current, :author => @user).events(nil, nil, :limit => 10)
36 36 @events_by_day = events.group_by(&:event_date)
37 37
38 38 rescue ActiveRecord::RecordNotFound
39 39 render_404
40 40 end
41 41
42 42 # Login request and validation
43 43 def login
44 44 if request.get?
45 45 # Logout user
46 46 self.logged_user = nil
47 47 else
48 48 # Authenticate user
49 49 if Setting.openid? && using_open_id?
50 50 open_id_authenticate(params[:openid_url])
51 51 else
52 52 password_authentication
53 53 end
54 54 end
55 55 end
56 56
57 57 # Log out current user and redirect to welcome page
58 58 def logout
59 59 cookies.delete :autologin
60 60 Token.delete_all(["user_id = ? AND action = ?", User.current.id, 'autologin']) if User.current.logged?
61 61 self.logged_user = nil
62 62 redirect_to home_url
63 63 end
64 64
65 65 # Enable user to choose a new password
66 66 def lost_password
67 67 redirect_to(home_url) && return unless Setting.lost_password?
68 68 if params[:token]
69 69 @token = Token.find_by_action_and_value("recovery", params[:token])
70 70 redirect_to(home_url) && return unless @token and !@token.expired?
71 71 @user = @token.user
72 72 if request.post?
73 73 @user.password, @user.password_confirmation = params[:new_password], params[:new_password_confirmation]
74 74 if @user.save
75 75 @token.destroy
76 76 flash[:notice] = l(:notice_account_password_updated)
77 77 redirect_to :action => 'login'
78 78 return
79 79 end
80 80 end
81 81 render :template => "account/password_recovery"
82 82 return
83 83 else
84 84 if request.post?
85 85 user = User.find_by_mail(params[:mail])
86 86 # user not found in db
87 87 flash.now[:error] = l(:notice_account_unknown_email) and return unless user
88 88 # user uses an external authentification
89 89 flash.now[:error] = l(:notice_can_t_change_password) and return if user.auth_source_id
90 90 # create a new token for password recovery
91 91 token = Token.new(:user => user, :action => "recovery")
92 92 if token.save
93 93 Mailer.deliver_lost_password(token)
94 94 flash[:notice] = l(:notice_account_lost_email_sent)
95 95 redirect_to :action => 'login'
96 96 return
97 97 end
98 98 end
99 99 end
100 100 end
101 101
102 102 # User self-registration
103 103 def register
104 104 redirect_to(home_url) && return unless Setting.self_registration? || session[:auth_source_registration]
105 105 if request.get?
106 106 session[:auth_source_registration] = nil
107 107 @user = User.new(:language => Setting.default_language)
108 108 else
109 109 @user = User.new(params[:user])
110 110 @user.admin = false
111 111 @user.status = User::STATUS_REGISTERED
112 112 if session[:auth_source_registration]
113 113 @user.status = User::STATUS_ACTIVE
114 114 @user.login = session[:auth_source_registration][:login]
115 115 @user.auth_source_id = session[:auth_source_registration][:auth_source_id]
116 116 if @user.save
117 117 session[:auth_source_registration] = nil
118 118 self.logged_user = @user
119 119 flash[:notice] = l(:notice_account_activated)
120 120 redirect_to :controller => 'my', :action => 'account'
121 121 end
122 122 else
123 123 @user.login = params[:user][:login]
124 124 @user.password, @user.password_confirmation = params[:password], params[:password_confirmation]
125 125
126 126 case Setting.self_registration
127 127 when '1'
128 128 register_by_email_activation(@user)
129 129 when '3'
130 130 register_automatically(@user)
131 131 else
132 132 register_manually_by_administrator(@user)
133 133 end
134 134 end
135 135 end
136 136 end
137 137
138 138 # Token based account activation
139 139 def activate
140 140 redirect_to(home_url) && return unless Setting.self_registration? && params[:token]
141 141 token = Token.find_by_action_and_value('register', params[:token])
142 142 redirect_to(home_url) && return unless token and !token.expired?
143 143 user = token.user
144 144 redirect_to(home_url) && return unless user.status == User::STATUS_REGISTERED
145 145 user.status = User::STATUS_ACTIVE
146 146 if user.save
147 147 token.destroy
148 148 flash[:notice] = l(:notice_account_activated)
149 149 end
150 150 redirect_to :action => 'login'
151 151 end
152 152
153 153 private
154 154 def logged_user=(user)
155 155 if user && user.is_a?(User)
156 156 User.current = user
157 157 session[:user_id] = user.id
158 158 else
159 159 User.current = User.anonymous
160 160 session[:user_id] = nil
161 161 end
162 162 end
163 163
164 164 def password_authentication
165 165 user = User.try_to_login(params[:username], params[:password])
166 166 if user.nil?
167 167 # Invalid credentials
168 168 flash.now[:error] = l(:notice_account_invalid_creditentials)
169 169 elsif user.new_record?
170 170 # Onthefly creation failed, display the registration form to fill/fix attributes
171 171 @user = user
172 172 session[:auth_source_registration] = {:login => user.login, :auth_source_id => user.auth_source_id }
173 173 render :action => 'register'
174 174 else
175 175 # Valid user
176 176 successful_authentication(user)
177 177 end
178 178 end
179 179
180 180
181 181 def open_id_authenticate(openid_url)
182 182 authenticate_with_open_id(openid_url, :required => [:nickname, :fullname, :email], :return_to => signin_url) do |result, identity_url, registration|
183 183 if result.successful?
184 184 user = User.find_or_initialize_by_identity_url(identity_url)
185 185 if user.new_record?
186 186 # Self-registration off
187 187 redirect_to(home_url) && return unless Setting.self_registration?
188 188
189 189 # Create on the fly
190 190 user.login = registration['nickname'] unless registration['nickname'].nil?
191 191 user.mail = registration['email'] unless registration['email'].nil?
192 192 user.firstname, user.lastname = registration['fullname'].split(' ') unless registration['fullname'].nil?
193 193 user.random_password
194 194 user.status = User::STATUS_REGISTERED
195 195
196 196 case Setting.self_registration
197 197 when '1'
198 198 register_by_email_activation(user) do
199 199 onthefly_creation_failed(user, {:login => user.login, :identity_url => identity_url })
200 200 end
201 201 when '3'
202 202 register_automatically(user) do
203 203 onthefly_creation_failed(user, {:login => user.login, :identity_url => identity_url })
204 204 end
205 205 else
206 206 register_manually_by_administrator(user) do
207 207 onthefly_creation_failed(user, {:login => user.login, :identity_url => identity_url })
208 208 end
209 209 end
210 210 else
211 211 # Existing record
212 successful_authentication(user)
212 if user.active?
213 successful_authentication(user)
214 else
215 account_pending
216 end
213 217 end
214 218 end
215 219 end
216 220 end
217 221
218 222 def successful_authentication(user)
219 223 # Valid user
220 224 self.logged_user = user
221 225 # generate a key and set cookie if autologin
222 226 if params[:autologin] && Setting.autologin?
223 227 token = Token.create(:user => user, :action => 'autologin')
224 228 cookies[:autologin] = { :value => token.value, :expires => 1.year.from_now }
225 229 end
226 230 redirect_back_or_default :controller => 'my', :action => 'page'
227 231 end
228 232
229 233 # Onthefly creation failed, display the registration form to fill/fix attributes
230 234 def onthefly_creation_failed(user, auth_source_options = { })
231 235 @user = user
232 236 session[:auth_source_registration] = auth_source_options unless auth_source_options.empty?
233 237 render :action => 'register'
234 238 end
235 239
236 240 # Register a user for email activation.
237 241 #
238 242 # Pass a block for behavior when a user fails to save
239 243 def register_by_email_activation(user, &block)
240 244 token = Token.new(:user => user, :action => "register")
241 245 if user.save and token.save
242 246 Mailer.deliver_register(token)
243 247 flash[:notice] = l(:notice_account_register_done)
244 248 redirect_to :action => 'login'
245 249 else
246 250 yield if block_given?
247 251 end
248 252 end
249 253
250 254 # Automatically register a user
251 255 #
252 256 # Pass a block for behavior when a user fails to save
253 257 def register_automatically(user, &block)
254 258 # Automatic activation
255 259 user.status = User::STATUS_ACTIVE
256 260 if user.save
257 261 self.logged_user = user
258 262 flash[:notice] = l(:notice_account_activated)
259 263 redirect_to :controller => 'my', :action => 'account'
260 264 else
261 265 yield if block_given?
262 266 end
263 267 end
264 268
265 269 # Manual activation by the administrator
266 270 #
267 271 # Pass a block for behavior when a user fails to save
268 272 def register_manually_by_administrator(user, &block)
269 273 if user.save
270 274 # Sends an email to the administrators
271 275 Mailer.deliver_account_activation_request(user)
272 flash[:notice] = l(:notice_account_pending)
273 redirect_to :action => 'login'
276 account_pending
274 277 else
275 278 yield if block_given?
276 279 end
277 280 end
281
282 def account_pending
283 flash[:notice] = l(:notice_account_pending)
284 redirect_to :action => 'login'
285 end
278 286 end
Show file before | Show file after | Hide comments
@@ -1,166 +1,181
1 1 # redMine - project management software
2 2 # Copyright (C) 2006-2007 Jean-Philippe Lang
3 3 #
4 4 # This program is free software; you can redistribute it and/or
5 5 # modify it under the terms of the GNU General Public License
6 6 # as published by the Free Software Foundation; either version 2
7 7 # of the License, or (at your option) any later version.
8 8 #
9 9 # This program is distributed in the hope that it will be useful,
10 10 # but WITHOUT ANY WARRANTY; without even the implied warranty of
11 11 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 12 # GNU General Public License for more details.
13 13 #
14 14 # You should have received a copy of the GNU General Public License
15 15 # along with this program; if not, write to the Free Software
16 16 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17 17
18 18 require File.dirname(__FILE__) + '/../test_helper'
19 19 require 'account_controller'
20 20
21 21 # Re-raise errors caught by the controller.
22 22 class AccountController; def rescue_action(e) raise e end; end
23 23
24 24 class AccountControllerTest < Test::Unit::TestCase
25 25 fixtures :users, :roles
26 26
27 27 def setup
28 28 @controller = AccountController.new
29 29 @request = ActionController::TestRequest.new
30 30 @response = ActionController::TestResponse.new
31 31 User.current = nil
32 32 end
33 33
34 34 def test_show
35 35 get :show, :id => 2
36 36 assert_response :success
37 37 assert_template 'show'
38 38 assert_not_nil assigns(:user)
39 39 end
40 40
41 41 def test_show_inactive
42 42 get :show, :id => 5
43 43 assert_response 404
44 44 assert_nil assigns(:user)
45 45 end
46 46
47 47 def test_login_should_redirect_to_back_url_param
48 48 # request.uri is "test.host" in test environment
49 49 post :login, :username => 'jsmith', :password => 'jsmith', :back_url => 'http%3A%2F%2Ftest.host%2Fissues%2Fshow%2F1'
50 50 assert_redirected_to '/issues/show/1'
51 51 end
52 52
53 53 def test_login_should_not_redirect_to_another_host
54 54 post :login, :username => 'jsmith', :password => 'jsmith', :back_url => 'http%3A%2F%2Ftest.foo%2Ffake'
55 55 assert_redirected_to '/my/page'
56 56 end
57 57
58 58 def test_login_with_wrong_password
59 59 post :login, :username => 'admin', :password => 'bad'
60 60 assert_response :success
61 61 assert_template 'login'
62 62 assert_tag 'div',
63 63 :attributes => { :class => "flash error" },
64 64 :content => /Invalid user or password/
65 65 end
66 66
67 67 if Object.const_defined?(:OpenID)
68 68
69 69 def test_login_with_openid_for_existing_user
70 70 Setting.self_registration = '3'
71 71 Setting.openid = '1'
72 72 existing_user = User.new(:firstname => 'Cool',
73 73 :lastname => 'User',
74 74 :mail => 'user@somedomain.com',
75 75 :identity_url => 'http://openid.example.com/good_user')
76 76 existing_user.login = 'cool_user'
77 77 assert existing_user.save!
78 78
79 79 post :login, :openid_url => existing_user.identity_url
80 80 assert_redirected_to 'my/page'
81 81 end
82 82
83 def test_login_with_openid_for_existing_non_active_user
84 Setting.self_registration = '2'
85 Setting.openid = '1'
86 existing_user = User.new(:firstname => 'Cool',
87 :lastname => 'User',
88 :mail => 'user@somedomain.com',
89 :identity_url => 'http://openid.example.com/good_user',
90 :status => User::STATUS_REGISTERED)
91 existing_user.login = 'cool_user'
92 assert existing_user.save!
93
94 post :login, :openid_url => existing_user.identity_url
95 assert_redirected_to 'login'
96 end
97
83 98 def test_login_with_openid_with_new_user_created
84 99 Setting.self_registration = '3'
85 100 Setting.openid = '1'
86 101 post :login, :openid_url => 'http://openid.example.com/good_user'
87 102 assert_redirected_to 'my/account'
88 103 user = User.find_by_login('cool_user')
89 104 assert user
90 105 assert_equal 'Cool', user.firstname
91 106 assert_equal 'User', user.lastname
92 107 end
93 108
94 109 def test_login_with_openid_with_new_user_and_self_registration_off
95 110 Setting.self_registration = '0'
96 111 Setting.openid = '1'
97 112 post :login, :openid_url => 'http://openid.example.com/good_user'
98 113 assert_redirected_to home_url
99 114 user = User.find_by_login('cool_user')
100 115 assert ! user
101 116 end
102 117
103 118 def test_login_with_openid_with_new_user_created_with_email_activation_should_have_a_token
104 119 Setting.self_registration = '1'
105 120 Setting.openid = '1'
106 121 post :login, :openid_url => 'http://openid.example.com/good_user'
107 122 assert_redirected_to 'login'
108 123 user = User.find_by_login('cool_user')
109 124 assert user
110 125
111 126 token = Token.find_by_user_id_and_action(user.id, 'register')
112 127 assert token
113 128 end
114 129
115 130 def test_login_with_openid_with_new_user_created_with_manual_activation
116 131 Setting.self_registration = '2'
117 132 Setting.openid = '1'
118 133 post :login, :openid_url => 'http://openid.example.com/good_user'
119 134 assert_redirected_to 'login'
120 135 user = User.find_by_login('cool_user')
121 136 assert user
122 137 assert_equal User::STATUS_REGISTERED, user.status
123 138 end
124 139
125 140 def test_login_with_openid_with_new_user_with_conflict_should_register
126 141 Setting.self_registration = '3'
127 142 Setting.openid = '1'
128 143 existing_user = User.new(:firstname => 'Cool', :lastname => 'User', :mail => 'user@somedomain.com')
129 144 existing_user.login = 'cool_user'
130 145 assert existing_user.save!
131 146
132 147 post :login, :openid_url => 'http://openid.example.com/good_user'
133 148 assert_response :success
134 149 assert_template 'register'
135 150 assert assigns(:user)
136 151 assert_equal 'http://openid.example.com/good_user', assigns(:user)[:identity_url]
137 152 end
138 153
139 154 def test_setting_openid_should_return_true_when_set_to_true
140 155 Setting.openid = '1'
141 156 assert_equal true, Setting.openid?
142 157 end
143 158
144 159 else
145 160 puts "Skipping openid tests."
146 161 end
147 162
148 163
149 164 def test_autologin
150 165 Setting.autologin = "7"
151 166 Token.delete_all
152 167 post :login, :username => 'admin', :password => 'admin', :autologin => 1
153 168 assert_redirected_to 'my/page'
154 169 token = Token.find :first
155 170 assert_not_nil token
156 171 assert_equal User.find_by_login('admin'), token.user
157 172 assert_equal 'autologin', token.action
158 173 end
159 174
160 175 def test_logout
161 176 @request.session[:user_id] = 2
162 177 get :logout
163 178 assert_redirected_to ''
164 179 assert_nil @request.session[:user_id]
165 180 end
166 181 end
General Comments 0
You need to be logged in to leave comments. Login now