]> git.openstreetmap.org Git - rails.git/blob - app/controllers/user_controller.rb
Merge branch 'master' into openid
[rails.git] / app / controllers / user_controller.rb
1 class UserController < ApplicationController
2   layout 'site', :except => :api_details
3
4   before_filter :authorize, :only => [:api_details, :api_gpx_files]
5   before_filter :authorize_web, :except => [:api_details, :api_gpx_files]
6   before_filter :set_locale, :except => [:api_details, :api_gpx_files]
7   before_filter :require_user, :only => [:account, :go_public, :make_friend, :remove_friend]
8   before_filter :check_database_readable, :except => [:api_details, :api_gpx_files]
9   before_filter :check_database_writable, :only => [:login, :new, :account, :go_public, :make_friend, :remove_friend]
10   before_filter :check_api_readable, :only => [:api_details, :api_gpx_files]
11   before_filter :require_allow_read_prefs, :only => [:api_details]
12   before_filter :require_allow_read_gpx, :only => [:api_gpx_files]
13   before_filter :require_cookies, :only => [:login, :confirm]
14   before_filter :require_administrator, :only => [:activate, :deactivate, :hide, :unhide, :delete]
15   before_filter :lookup_this_user, :only => [:activate, :deactivate, :hide, :unhide, :delete]
16
17   filter_parameter_logging :password, :pass_crypt, :pass_crypt_confirmation
18
19   cache_sweeper :user_sweeper, :only => [:account, :hide, :unhide, :delete]
20
21   def save
22     @title = t 'user.new.title'
23
24     if Acl.find_by_address(request.remote_ip, :conditions => {:k => "no_account_creation"})
25       render :action => 'new'
26     else
27           #The redirect from the OpenID provider reenters here again 
28       #and we need to pass the parameters through to the  
29       #open_id_authentication function a second time 
30       if params[:open_id_complete] 
31         openid_verify('', true) 
32         #We have set the user.openid_url to nil beforehand. If it hasn't 
33         #been set to a new valid openid_url, it means the openid couldn't be validated 
34         if @user.nil? or @user.openid_url.nil? 
35           render :action => 'new' 
36           return 
37         end   
38       else
39       @user = User.new(params[:user])
40
41       @user.visible = true
42       @user.data_public = true
43       @user.description = "" if @user.description.nil?
44       @user.creation_ip = request.remote_ip
45       @user.languages = request.user_preferred_languages
46         #Set the openid_url to nil as for one it is used 
47         #to check if the openid could be validated and secondly 
48         #to not get dupplicate conflicts for an empty openid  
49         @user.openid_url = nil
50
51 if (!params[:user][:openid_url].nil? and params[:user][:openid_url].length > 0)
52                   if @user.pass_crypt.length == 0 
53             #if the password is empty, but we have a openid 
54             #then generate a random passowrd to disable 
55             #loging in via password 
56             @user.pass_crypt = ActiveSupport::SecureRandom.base64(16) 
57             @user.pass_crypt_confirmation = @user.pass_crypt 
58           end
59                   #Validate all of the other fields before
60                   #redirecting to the openid provider
61                   if !@user.valid?
62                         render :action => 'new'
63                   else            
64                         #TODO: Is it a problem to store the user variable with respect to password safty in the session variables?
65                         #Store the user variable in the session for it to be accessible when redirecting back from the openid provider
66                         session[:new_usr] = @user
67                         begin
68                           @norm_openid_url = OpenIdAuthentication.normalize_identifier(params[:user][:openid_url])
69                         rescue
70                           flash.now[:error] = t 'user.login.openid invalid'
71                           render :action => 'new'
72                           return
73                         end
74                         #Verify that the openid provided is valid and that the user is the owner of the id
75                         openid_verify(@norm_openid_url, true)
76                         #openid_verify can return in two ways:
77                         #Either it returns with a redirect to the openid provider who then freshly
78                         #redirects back to this url if the openid is valid, or if the openid is not plausible
79                         #and no provider for it could be found it just returns
80                         #we want to just let the redirect through
81                         if response.headers["Location"].nil?
82                           render :action => 'new'
83                         end
84                   end
85                   #At this point there was either an error and the page has been rendered,
86                   #or there is a redirect to the openid provider and the rest of the method
87                   #gets executed whenn this method gets reentered after redirecting back
88                   #from the openid provider
89                   return
90                 end
91           end
92
93       if @user.save
94         flash[:notice] = t 'user.new.flash create success message'
95         Notifier.deliver_signup_confirm(@user, @user.tokens.create(:referer => params[:referer]))
96         redirect_to :action => 'login'
97       else
98         render :action => 'new'
99       end
100     end
101   end
102
103   def account
104     @title = t 'user.account.title'
105     @tokens = @user.oauth_tokens.find :all, :conditions => 'oauth_tokens.invalidated_at is null and oauth_tokens.authorized_at is not null'
106
107         #The redirect from the OpenID provider reenters here again
108     #and we need to pass the parameters through to the 
109     #open_id_authentication function
110     if params[:open_id_complete]
111       openid_verify('', false)
112           @user.save
113       return
114     end
115
116     if params[:user] and params[:user][:display_name] and params[:user][:description]
117       @user.display_name = params[:user][:display_name]
118       @user.new_email = params[:user][:new_email]
119
120       if params[:user][:pass_crypt].length > 0 or params[:user][:pass_crypt_confirmation].length > 0
121         @user.pass_crypt = params[:user][:pass_crypt]
122         @user.pass_crypt_confirmation = params[:user][:pass_crypt_confirmation]
123       end
124
125       @user.description = params[:user][:description]
126       @user.languages = params[:user][:languages].split(",")
127
128       case params[:image_action]
129         when "new" then @user.image = params[:user][:image]
130         when "delete" then @user.image = nil
131       end
132
133       @user.home_lat = params[:user][:home_lat]
134       @user.home_lon = params[:user][:home_lon]
135
136       if @user.save
137         set_locale
138
139         if @user.new_email.nil? or @user.new_email.empty?
140           flash.now[:notice] = t 'user.account.flash update success'
141         else
142           flash.now[:notice] = t 'user.account.flash update success confirm needed'
143
144           begin
145             Notifier.deliver_email_confirm(@user, @user.tokens.create)
146           rescue
147             # Ignore errors sending email
148           end
149         end
150       end
151
152           if (params[:user][:openid_url].length > 0)
153                 begin
154                   @norm_openid_url = OpenIdAuthentication.normalize_identifier(params[:user][:openid_url])
155                   if (@norm_openid_url != @user.openid_url)
156                         #If the OpenID has changed, we want to check that it is a valid OpenID and one
157                         #the user has control over before saving the openID as a password equivalent for
158                         #the user.
159                         openid_verify(@norm_openid_url, false)
160                   end
161                 rescue
162                   flash.now[:error] = t 'user.login.openid invalid'
163                 end
164       end
165
166     else
167       if flash[:errors]
168         flash[:errors].each do |attr,msg|
169           attr = "new_email" if attr == "email"
170           @user.errors.add(attr,msg)
171         end
172       end
173     end
174   end
175
176   def openid_specialcase_mapping(openid_url)
177     #Special case gmail.com, as it is pontentially a popular OpenID provider and unlike
178     #yahoo.com, where it works automatically, Google have hidden their OpenID endpoint
179     #somewhere obscure making it less userfriendly.
180     if (openid_url.match(/(.*)gmail.com(\/?)$/) or openid_url.match(/(.*)googlemail.com(\/?)$/) )
181       return 'https://www.google.com/accounts/o8/id'
182     end
183
184     return nil
185   end  
186
187   def openid_verify(openid_url,account_create)
188     authenticate_with_open_id(openid_url) do |result, identity_url|
189       if result.successful?
190         #We need to use the openid url passed back from the OpenID provider
191         #rather than the one supplied by the user, as these can be different.
192         #e.g. one can simply enter yahoo.com in the login box, i.e. no user specific url
193         #only once it comes back from the OpenID provider do we know the unique address for
194         #the user.
195                 @user = session[:new_usr] unless @user #this is used for account creation when the user is not yet in the database
196         @user.openid_url = identity_url
197           elsif result.missing?
198                 mapped_id = openid_specialcase_mapping(openid_url)
199                 if mapped_id
200                   openid_verify(mapped_id, account_create)
201                 else
202                   flash.now[:error] = t 'user.login.openid missing provider'
203                 end
204           elsif result.invalid?
205                 flash.now[:error] = t 'user.login.openid invalid'
206           else
207                 flash.now[:error] = t 'user.login.auth failure'
208           end
209     end
210   end
211
212   def open_id_authentication(openid_url)
213     #TODO: only ask for nickname and email, if we don't already have a user for that openID, in which case
214     #email and nickname are already filled out. I don't know how to do that with ruby syntax though, as we
215     #don't want to duplicate the do block
216     #On the other hand it also doesn't matter too much if we ask every time, as the OpenID provider should
217     #remember these results, and shouldn't repromt the user for these data each time.
218     authenticate_with_open_id(openid_url, :return_to => request.protocol + request.host_with_port + '/login?referer=' + params[:referer], :optional => [:nickname, :email]) do |result, identity_url, registration|
219       if result.successful?
220         #We need to use the openid url passed back from the OpenID provider
221         #rather than the one supplied by the user, as these can be different.
222         #e.g. one can simply enter yahoo.com in the login box, i.e. no user specific url
223         #only once it comes back from the OpenID provider do we know the unique address for
224         #the user.
225         user = User.find_by_openid_url(identity_url)
226         if user
227           if user.visible? and user.active?
228             session[:user] = user.id
229                         session_expires_after 1.month if session[:remember]
230           else
231             user = nil
232             flash.now[:error] = t 'user.login.account not active'
233           end
234         else
235           #We don't have a user registered to this OpenID. Redirect to the create account page
236           #with username and email filled in if they have been given by the OpenID provider through
237           #the simple registration protocol
238           redirect_to :controller => 'user', :action => 'new', :nickname => registration['nickname'], :email => registration['email'], :openid => identity_url
239         end
240       else if result.missing?
241              #Try and apply some heuristics to make common cases more userfriendly
242              mapped_id = openid_specialcase_mapping(openid_url)
243              if mapped_id
244                open_id_authentication(mapped_id)
245              else
246                flash.now[:error] = t 'user.login.openid missing provider'
247              end
248            else if result.invalid?
249                   flash.now[:error] = t 'user.login.openid invalid'
250                 else
251                   flash.now[:error] = t 'user.login.auth failure'
252                 end
253            end
254       end
255     end
256
257     user
258   end
259
260   def go_public
261     @user.data_public = true
262     @user.save
263     flash[:notice] = t 'user.go_public.flash success'
264     redirect_to :controller => 'user', :action => 'account', :display_name => @user.display_name
265   end
266
267   def lost_password
268     @title = t 'user.lost_password.title'
269
270     if params[:user] and params[:user][:email]
271       user = User.find_by_email(params[:user][:email], :conditions => {:visible => true})
272
273       if user
274         token = user.tokens.create
275         Notifier.deliver_lost_password(user, token)
276         flash[:notice] = t 'user.lost_password.notice email on way'
277         redirect_to :action => 'login'
278       else
279         flash.now[:error] = t 'user.lost_password.notice email cannot find'
280       end
281     end
282   end
283
284   def reset_password
285     @title = t 'user.reset_password.title'
286
287     if params[:token]
288       token = UserToken.find_by_token(params[:token])
289
290       if token
291         @user = token.user
292
293         if params[:user]
294           @user.pass_crypt = params[:user][:pass_crypt]
295           @user.pass_crypt_confirmation = params[:user][:pass_crypt_confirmation]
296           @user.active = true
297           @user.email_valid = true
298
299           if @user.save
300             token.destroy
301             flash[:notice] = t 'user.reset_password.flash changed'
302             redirect_to :action => 'login'
303           end
304         end
305       else
306         flash[:error] = t 'user.reset_password.flash token bad'
307         redirect_to :action => 'lost_password'
308       end
309     end
310   end
311
312   def new
313     @title = t 'user.new.title'
314
315     # The user is logged in already, so don't show them the signup
316     # page, instead send them to the home page
317     redirect_to :controller => 'site', :action => 'index' if session[:user]
318
319         @nickname = params['nickname']
320     @email = params['email']
321         @openID = params['openid']
322   end
323
324   def login
325     @title = t 'user.login.title'
326
327     #The redirect from the OpenID provider reenters here again
328     #and we need to pass the parameters through to the 
329     # open_id_authentication function
330     if params[:open_id_complete]
331       user = open_id_authentication('')
332     elsif params[:user]
333       if !params[:user][:openid_url].nil? and !params[:user][:openid_url].empty?
334         session[:remember] = params[:remember_me]
335         user = open_id_authentication(params[:user][:openid_url])
336       else
337         email_or_display_name = params[:user][:email]
338         pass = params[:user][:password]
339
340         if user = User.authenticate(:username => email_or_display_name, :password => pass)
341           session[:user] = user.id
342           session_expires_after 1.month if params[:remember_me]
343         elsif User.authenticate(:username => email_or_display_name, :password => pass, :inactive => true)
344           flash.now[:error] = t 'user.login.account not active'
345         else
346           flash.now[:error] = t 'user.login.auth failure'
347         end
348       end
349     end
350
351     if user
352       # The user is logged in, if the referer param exists, redirect
353       # them to that unless they've also got a block on them, in
354       # which case redirect them to the block so they can clear it.
355       if user.blocked_on_view
356         redirect_to user.blocked_on_view, :referrer => params[:referrer]
357       elsif params[:referer]
358         redirect_to params[:referer]
359       else
360         redirect_to :controller => 'site', :action => 'index'
361       end
362     end
363   end
364
365   def logout
366     @title = t 'user.logout.title'
367
368     if params[:session] == request.session_options[:id]
369       if session[:token]
370         token = UserToken.find_by_token(session[:token])
371         if token
372           token.destroy
373         end
374         session[:token] = nil
375       end
376       session[:user] = nil
377       session_expires_automatically
378       if params[:referer]
379         redirect_to params[:referer]
380       else
381         redirect_to :controller => 'site', :action => 'index'
382       end
383     end
384   end
385
386   def confirm
387     if params[:confirm_action]
388       token = UserToken.find_by_token(params[:confirm_string])
389       if token and !token.user.active?
390         @user = token.user
391         @user.active = true
392         @user.email_valid = true
393         @user.save!
394         referer = token.referer
395         token.destroy
396         flash[:notice] = t 'user.confirm.success'
397         session[:user] = @user.id
398         unless referer.nil?
399           redirect_to referer
400         else
401           redirect_to :action => 'account', :display_name => @user.display_name
402         end
403       else
404         flash.now[:error] = t 'user.confirm.failure'
405       end
406     end
407   end
408
409   def confirm_email
410     if params[:confirm_action]
411       token = UserToken.find_by_token(params[:confirm_string])
412       if token and token.user.new_email?
413         @user = token.user
414         @user.email = @user.new_email
415         @user.new_email = nil
416         @user.active = true
417         @user.email_valid = true
418         if @user.save
419           flash[:notice] = t 'user.confirm_email.success'
420         else
421           flash[:errors] = @user.errors
422         end
423         token.destroy
424         session[:user] = @user.id
425         redirect_to :action => 'account', :display_name => @user.display_name
426       else
427         flash.now[:error] = t 'user.confirm_email.failure'
428       end
429     end
430   end
431
432   def api_gpx_files
433     doc = OSM::API.new.get_xml_doc
434     @user.traces.each do |trace|
435       doc.root << trace.to_xml_node() if trace.public? or trace.user == @user
436     end
437     render :text => doc.to_s, :content_type => "text/xml"
438   end
439
440   def view
441     @this_user = User.find_by_display_name(params[:display_name])
442
443     if @this_user and
444        (@this_user.visible? or (@user and @user.administrator?))
445       @title = @this_user.display_name
446     else
447       @title = t 'user.no_such_user.title'
448       @not_found_user = params[:display_name]
449       render :action => 'no_such_user', :status => :not_found
450     end
451   end
452
453   def make_friend
454     if params[:display_name]
455       name = params[:display_name]
456       new_friend = User.find_by_display_name(name, :conditions => {:visible => true})
457       friend = Friend.new
458       friend.user_id = @user.id
459       friend.friend_user_id = new_friend.id
460       unless @user.is_friends_with?(new_friend)
461         if friend.save
462           flash[:notice] = t 'user.make_friend.success', :name => name
463           Notifier.deliver_friend_notification(friend)
464         else
465           friend.add_error(t('user.make_friend.failed', :name => name))
466         end
467       else
468         flash[:warning] = t 'user.make_friend.already_a_friend', :name => name
469       end
470
471       if params[:referer]
472         redirect_to params[:referer]
473       else
474         redirect_to :controller => 'user', :action => 'view'
475       end
476     end
477   end
478
479   def remove_friend
480     if params[:display_name]
481       name = params[:display_name]
482       friend = User.find_by_display_name(name, :conditions => {:visible => true})
483       if @user.is_friends_with?(friend)
484         Friend.delete_all "user_id = #{@user.id} AND friend_user_id = #{friend.id}"
485         flash[:notice] = t 'user.remove_friend.success', :name => friend.display_name
486       else
487         flash[:error] = t 'user.remove_friend.not_a_friend', :name => friend.display_name
488       end
489
490       if params[:referer]
491         redirect_to params[:referer]
492       else
493         redirect_to :controller => 'user', :action => 'view'
494       end
495     end
496   end
497
498   ##
499   # activate a user, allowing them to log in
500   def activate
501     @this_user.update_attributes(:active => true)
502     redirect_to :controller => 'user', :action => 'view', :display_name => params[:display_name]
503   end
504
505   ##
506   # deactivate a user, preventing them from logging in
507   def deactivate
508     @this_user.update_attributes(:active => false)
509     redirect_to :controller => 'user', :action => 'view', :display_name => params[:display_name]
510   end
511
512   ##
513   # hide a user, marking them as logically deleted
514   def hide
515     @this_user.update_attributes(:visible => false)
516     redirect_to :controller => 'user', :action => 'view', :display_name => params[:display_name]
517   end
518
519   ##
520   # unhide a user, clearing the logically deleted flag
521   def unhide
522     @this_user.update_attributes(:visible => true)
523     redirect_to :controller => 'user', :action => 'view', :display_name => params[:display_name]
524   end
525
526   ##
527   # delete a user, marking them as deleted and removing personal data
528   def delete
529     @this_user.delete
530     redirect_to :controller => 'user', :action => 'view', :display_name => params[:display_name]
531   end
532 private
533   ##
534   # require that the user is a administrator, or fill out a helpful error message
535   # and return them to the user page.
536   def require_administrator
537     unless @user.administrator?
538       flash[:error] = t('user.filter.not_an_administrator')
539       redirect_to :controller => 'user', :action => 'view', :display_name => params[:display_name]
540     end
541   end
542
543   ##
544   # ensure that there is a "this_user" instance variable
545   def lookup_this_user
546     @this_user = User.find_by_display_name(params[:display_name])
547   rescue ActiveRecord::RecordNotFound
548     redirect_to :controller => 'user', :action => 'view', :display_name => params[:display_name] unless @this_user
549   end
550 end