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 => [:set_status, :delete, :list]
15   before_filter :lookup_this_user, :only => [:set_status, :delete]
16
17   filter_parameter_logging :password, :pass_crypt, :pass_crypt_confirmation
18
19   cache_sweeper :user_sweeper, :only => [:account, :set_status, :delete], :unless => STATUS == :database_offline
20
21   def terms
22     @legale = params[:legale] || OSM.IPToCountry(request.remote_ip) || DEFAULT_LEGALE
23     @text = OSM.legal_text_for_country(@legale)
24
25     if request.xhr?
26       render :update do |page|
27         page.replace_html "contributorTerms", :partial => "terms", :locals => { :has_decline => params[:has_decline] }
28       end
29     elsif using_open_id?
30       # The redirect from the OpenID provider reenters here
31       # again and we need to pass the parameters through to
32       # the open_id_authentication function
33       @user = session.delete(:new_user)
34
35       openid_verify(nil, @user) do |user|
36       end
37
38       if @user.openid_url.nil? or @user.invalid?
39         render :action => 'new'
40       else
41         render :action => 'terms'
42       end
43     else
44       session[:referer] = params[:referer]
45
46       @title = t 'user.terms.title'
47       @user = User.new(params[:user]) if params[:user]
48
49       if params[:user][:openid_url] and @user.pass_crypt.empty?
50         # We are creating an account with OpenID and no password
51         # was specified so create a random one
52         @user.pass_crypt = ActiveSupport::SecureRandom.base64(16) 
53         @user.pass_crypt_confirmation = @user.pass_crypt 
54       end
55
56       if @user
57         if @user.invalid?
58           # Something is wrong, so rerender the form
59           render :action => :new
60         elsif @user.terms_agreed?
61           # Already agreed to terms, so just show settings
62           redirect_to :action => :account, :display_name => @user.display_name
63         elsif params[:user][:openid_url]
64           # Verify OpenID before moving on
65           session[:new_user] = @user
66           openid_verify(params[:user][:openid_url], @user)
67         end
68       else
69         # Not logged in, so redirect to the login page
70         redirect_to :action => :login, :referer => request.request_uri
71       end
72     end
73   end
74
75   def save
76     @title = t 'user.new.title'
77
78     if Acl.find_by_address(request.remote_ip, :conditions => {:k => "no_account_creation"})
79       render :action => 'new'
80     elsif params[:decline]
81       redirect_to t('user.terms.declined')
82     elsif @user
83       if !@user.terms_agreed?
84         @user.consider_pd = params[:user][:consider_pd]
85         @user.terms_agreed = Time.now.getutc
86         if @user.save
87           flash[:notice] = t 'user.new.terms accepted'
88         end
89       end
90
91       redirect_to :action => :account, :display_name => @user.display_name
92     else
93       @user = User.new(params[:user])
94
95       @user.status = "pending"
96       @user.data_public = true
97       @user.description = "" if @user.description.nil?
98       @user.creation_ip = request.remote_ip
99       @user.languages = request.user_preferred_languages
100       @user.terms_agreed = Time.now.getutc
101
102       if @user.save
103         flash[:notice] = t 'user.new.flash create success message'
104         Notifier.deliver_signup_confirm(@user, @user.tokens.create(:referer => session.delete(:referer)))
105         redirect_to :action => 'login'
106       else
107         render :action => 'new'
108       end
109     end
110   end
111
112   def account
113     @title = t 'user.account.title'
114     @tokens = @user.oauth_tokens.find :all, :conditions => 'oauth_tokens.invalidated_at is null and oauth_tokens.authorized_at is not null'
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       @user.openid_url = nil if params[:user][:openid_url].empty?
137
138       if params[:user][:openid_url].length > 0 and
139          params[:user][:openid_url] != @user.openid_url
140         # If the OpenID has changed, we want to check that it is a
141         # valid OpenID and one the user has control over before saving
142         # it as a password equivalent for the user.
143         session[:new_user] = @user
144         openid_verify(params[:user][:openid_url], @user)
145       else
146         update_user(@user)
147       end
148     elsif using_open_id?
149       # The redirect from the OpenID provider reenters here
150       # again and we need to pass the parameters through to
151       # the open_id_authentication function
152       @user = session.delete(:new_user)
153       openid_verify(nil, @user) do |user|
154         update_user(user)
155       end
156     end
157   end
158
159   def go_public
160     @user.data_public = true
161     @user.save
162     flash[:notice] = t 'user.go_public.flash success'
163     redirect_to :controller => 'user', :action => 'account', :display_name => @user.display_name
164   end
165
166   def lost_password
167     @title = t 'user.lost_password.title'
168
169     if params[:user] and params[:user][:email]
170       user = User.find_by_email(params[:user][:email], :conditions => {:status => ["pending", "active", "confirmed"]})
171
172       if user
173         token = user.tokens.create
174         Notifier.deliver_lost_password(user, token)
175         flash[:notice] = t 'user.lost_password.notice email on way'
176         redirect_to :action => 'login'
177       else
178         flash.now[:error] = t 'user.lost_password.notice email cannot find'
179       end
180     end
181   end
182
183   def reset_password
184     @title = t 'user.reset_password.title'
185
186     if params[:token]
187       token = UserToken.find_by_token(params[:token])
188
189       if token
190         @user = token.user
191
192         if params[:user]
193           @user.pass_crypt = params[:user][:pass_crypt]
194           @user.pass_crypt_confirmation = params[:user][:pass_crypt_confirmation]
195           @user.status = "active" if @user.status == "pending"
196           @user.email_valid = true
197
198           if @user.save
199             token.destroy
200             flash[:notice] = t 'user.reset_password.flash changed'
201             redirect_to :action => 'login'
202           end
203         end
204       else
205         flash[:error] = t 'user.reset_password.flash token bad'
206         redirect_to :action => 'lost_password'
207       end
208     end
209   end
210
211   def new
212     @title = t 'user.new.title'
213     @referer = params[:referer] || session[:referer]
214
215     if session[:user]
216       # The user is logged in already, so don't show them the signup
217       # page, instead send them to the home page
218       redirect_to :controller => 'site', :action => 'index'
219     elsif not params['openid'].nil?
220       flash.now[:notice] = t 'user.new.openid association'
221     end
222   end
223
224   def login
225     if params[:username] or using_open_id?
226       session[:remember_me] ||= params[:remember_me]
227       session[:referer] ||= params[:referer]
228
229       if using_open_id?
230         openid_authentication(params[:openid_url])
231       else
232         password_authentication(params[:username], params[:password])
233       end
234     else
235       flash.now[:notice] =  t 'user.login.notice'
236     end
237   end
238
239   def logout
240     @title = t 'user.logout.title'
241
242     if params[:session] == request.session_options[:id]
243       if session[:token]
244         token = UserToken.find_by_token(session[:token])
245         if token
246           token.destroy
247         end
248         session[:token] = nil
249       end
250       session[:user] = nil
251       session_expires_automatically
252       if params[:referer]
253         redirect_to params[:referer]
254       else
255         redirect_to :controller => 'site', :action => 'index'
256       end
257     end
258   end
259
260   def confirm
261     if params[:confirm_action]
262       token = UserToken.find_by_token(params[:confirm_string])
263       if token and !token.user.active?
264         @user = token.user
265         @user.status = "active"
266         @user.email_valid = true
267         @user.save!
268         referer = token.referer
269         token.destroy
270         flash[:notice] = t 'user.confirm.success'
271         session[:user] = @user.id
272         unless referer.nil?
273           redirect_to referer
274         else
275           redirect_to :action => 'account', :display_name => @user.display_name
276         end
277       else
278         flash.now[:error] = t 'user.confirm.failure'
279       end
280     end
281   end
282
283   def confirm_email
284     if params[:confirm_action]
285       token = UserToken.find_by_token(params[:confirm_string])
286       if token and token.user.new_email?
287         @user = token.user
288         @user.email = @user.new_email
289         @user.new_email = nil
290         @user.email_valid = true
291         if @user.save
292           flash[:notice] = t 'user.confirm_email.success'
293         else
294           flash[:errors] = @user.errors
295         end
296         token.destroy
297         session[:user] = @user.id
298         redirect_to :action => 'account', :display_name => @user.display_name
299       else
300         flash.now[:error] = t 'user.confirm_email.failure'
301       end
302     end
303   end
304
305   def api_gpx_files
306     doc = OSM::API.new.get_xml_doc
307     @user.traces.each do |trace|
308       doc.root << trace.to_xml_node() if trace.public? or trace.user == @user
309     end
310     render :text => doc.to_s, :content_type => "text/xml"
311   end
312
313   def view
314     @this_user = User.find_by_display_name(params[:display_name])
315
316     if @this_user and
317        (@this_user.visible? or (@user and @user.administrator?))
318       @title = @this_user.display_name
319     else
320       @title = t 'user.no_such_user.title'
321       @not_found_user = params[:display_name]
322       render :action => 'no_such_user', :status => :not_found
323     end
324   end
325
326   def make_friend
327     if params[:display_name]
328       name = params[:display_name]
329       new_friend = User.find_by_display_name(name, :conditions => {:status => ["active", "confirmed"]})
330       friend = Friend.new
331       friend.user_id = @user.id
332       friend.friend_user_id = new_friend.id
333       unless @user.is_friends_with?(new_friend)
334         if friend.save
335           flash[:notice] = t 'user.make_friend.success', :name => name
336           Notifier.deliver_friend_notification(friend)
337         else
338           friend.add_error(t('user.make_friend.failed', :name => name))
339         end
340       else
341         flash[:warning] = t 'user.make_friend.already_a_friend', :name => name
342       end
343
344       if params[:referer]
345         redirect_to params[:referer]
346       else
347         redirect_to :controller => 'user', :action => 'view'
348       end
349     end
350   end
351
352   def remove_friend
353     if params[:display_name]
354       name = params[:display_name]
355       friend = User.find_by_display_name(name, :conditions => {:status => ["active", "confirmed"]})
356       if @user.is_friends_with?(friend)
357         Friend.delete_all "user_id = #{@user.id} AND friend_user_id = #{friend.id}"
358         flash[:notice] = t 'user.remove_friend.success', :name => friend.display_name
359       else
360         flash[:error] = t 'user.remove_friend.not_a_friend', :name => friend.display_name
361       end
362
363       if params[:referer]
364         redirect_to params[:referer]
365       else
366         redirect_to :controller => 'user', :action => 'view'
367       end
368     end
369   end
370
371   ##
372   # sets a user's status
373   def set_status
374     @this_user.update_attributes(:status => params[:status])
375     redirect_to :controller => 'user', :action => 'view', :display_name => params[:display_name]
376   end
377
378   ##
379   # delete a user, marking them as deleted and removing personal data
380   def delete
381     @this_user.delete
382     redirect_to :controller => 'user', :action => 'view', :display_name => params[:display_name]
383   end
384
385   ##
386   # display a list of users matching specified criteria
387   def list
388     if request.post?
389       ids = params[:user].keys.collect { |id| id.to_i }
390
391       User.update_all("status = 'confirmed'", :id => ids) if params[:confirm]
392       User.update_all("status = 'deleted'", :id => ids) if params[:hide]
393
394       redirect_to url_for(:status => params[:status], :ip => params[:ip], :page => params[:page])
395     else
396       conditions = Hash.new
397       conditions[:status] = params[:status] if params[:status]
398       conditions[:creation_ip] = params[:ip] if params[:ip]
399
400       @user_pages, @users = paginate(:users,
401                                      :conditions => conditions,
402                                      :order => :id,
403                                      :per_page => 50)
404     end
405   end
406
407 private
408
409   ##
410   # handle password authentication
411   def password_authentication(username, password)
412     if user = User.authenticate(:username => username, :password => password)
413       successful_login(user)
414     elsif User.authenticate(:username => username, :password => password, :pending => true)
415       failed_login t('user.login.account not active')
416     elsif User.authenticate(:username => username, :password => password, :suspended => true)
417       webmaster = link_to t('user.login.webmaster'), "mailto:webmaster@openstreetmap.org"
418       failed_login t('user.login.account suspended', :webmaster => webmaster)
419     else
420       failed_login t('user.login.auth failure')
421     end
422   end
423
424   ##
425   # handle OpenID authentication
426   def openid_authentication(openid_url)
427     # If we don't appear to have a user for this URL then ask the
428     # provider for some extra information to help with signup
429     if openid_url and User.find_by_openid_url(openid_url)
430       optional = nil
431     else
432       optional = [:nickname, :email]
433     end
434
435     # Start the authentication
436     authenticate_with_open_id(openid_expand_url(openid_url), :optional => optional) do |result, identity_url, registration|
437       if result.successful?
438         # We need to use the openid url passed back from the OpenID provider
439         # rather than the one supplied by the user, as these can be different.
440         #
441         # For example, you can simply enter yahoo.com in the login box rather
442         # than a user specific url. Only once it comes back from the provider
443         # provider do we know the unique address for the user.
444         if user = User.find_by_openid_url(identity_url)
445           case user.status
446             when "pending" then
447               failed_login t('user.login.account not active')
448             when "active", "confirmed" then
449               successful_login(user)
450             when "suspended" then
451               webmaster = link_to t('user.login.webmaster'), "mailto:webmaster@openstreetmap.org"
452               failed_login t('user.login.account suspended', :webmaster => webmaster)
453             else
454               failed_login t('user.login.auth failure')
455           end
456         else
457           # We don't have a user registered to this OpenID, so redirect
458           # to the create account page with username and email filled
459           # in if they have been given by the OpenID provider through
460           # the simple registration protocol.
461           redirect_to :controller => 'user', :action => 'new', :nickname => registration['nickname'], :email => registration['email'], :openid => identity_url
462         end
463       elsif result.missing?
464         failed_login t('user.login.openid missing provider')
465       elsif result.invalid?
466         failed_login t('user.login.openid invalid')
467       else
468         failed_login t('user.login.auth failure')
469       end
470     end
471   end
472
473   ##
474   # verify an OpenID URL
475   def openid_verify(openid_url, user)
476     user.openid_url = openid_url
477
478     authenticate_with_open_id(openid_expand_url(openid_url)) do |result, identity_url|
479       if result.successful?
480         # We need to use the openid url passed back from the OpenID provider
481         # rather than the one supplied by the user, as these can be different.
482         #
483         # For example, you can simply enter yahoo.com in the login box rather
484         # than a user specific url. Only once it comes back from the provider
485         # provider do we know the unique address for the user.
486         user.openid_url = identity_url
487         yield user
488       elsif result.missing?
489         flash.now[:error] = t 'user.login.openid missing provider'
490       elsif result.invalid?
491         flash.now[:error] = t 'user.login.openid invalid'
492       else
493         flash.now[:error] = t 'user.login.auth failure'
494       end
495     end
496   end
497
498   ##
499   # special case some common OpenID providers by applying heuristics to
500   # try and come up with the correct URL based on what the user entered
501   def openid_expand_url(openid_url)
502     if openid_url.nil?
503       return nil
504     elsif openid_url.match(/(.*)gmail.com(\/?)$/) or openid_url.match(/(.*)googlemail.com(\/?)$/)
505       # Special case gmail.com as it is potentially a popular OpenID
506       # provider and, unlike yahoo.com, where it works automatically, Google
507       # have hidden their OpenID endpoint somewhere obscure this making it
508       # somewhat less user friendly.
509       return 'https://www.google.com/accounts/o8/id'
510     else
511       return openid_url
512     end
513   end  
514
515   ##
516   # process a successful login
517   def successful_login(user)
518     session[:user] = user.id
519
520     session_expires_after 1.month if session[:remember_me]
521
522     if user.blocked_on_view
523       redirect_to user.blocked_on_view, :referer => params[:referer]
524     elsif session[:referer]
525       redirect_to session[:referer]
526     else
527       redirect_to :controller => 'site', :action => 'index'
528     end
529
530     session.delete(:remember_me)
531     session.delete(:referer)
532   end
533
534   ##
535   # process a failed login
536   def failed_login(message)
537     flash[:error] = message
538
539     redirect_to :action => 'login', :referer =>  session[:referer]
540
541     session.delete(:remember_me)
542     session.delete(:referer)
543   end
544
545   ##
546   # update a user's details
547   def update_user(user)
548     if user.save
549       set_locale
550
551       if user.new_email.nil? or user.new_email.empty?
552         flash.now[:notice] = t 'user.account.flash update success'
553       else
554         flash.now[:notice] = t 'user.account.flash update success confirm needed'
555
556         begin
557           Notifier.deliver_email_confirm(user, user.tokens.create)
558         rescue
559           # Ignore errors sending email
560         end
561       end
562     end
563   end
564
565   ##
566   # require that the user is a administrator, or fill out a helpful error message
567   # and return them to the user page.
568   def require_administrator
569     if @user and not @user.administrator?
570       flash[:error] = t('user.filter.not_an_administrator')
571
572       if params[:display_name]
573         redirect_to :controller => 'user', :action => 'view', :display_name => params[:display_name]
574       else
575         redirect_to :controller => 'user', :action => 'login', :referer => request.request_uri
576       end
577     elsif not @user
578       redirect_to :controller => 'user', :action => 'login', :referer => request.request_uri
579     end
580   end
581
582   ##
583   # ensure that there is a "this_user" instance variable
584   def lookup_this_user
585     @this_user = User.find_by_display_name(params[:display_name])
586   rescue ActiveRecord::RecordNotFound
587     redirect_to :controller => 'user', :action => 'view', :display_name => params[:display_name] unless @this_user
588   end
589 end