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]
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.status = "pending"
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.nil? or @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       @user.openid_url = nil if (params[:user][:openid_url].length == 0)
137
138       if @user.save
139         set_locale
140
141         if @user.new_email.nil? or @user.new_email.empty?
142           flash[:notice] = t 'user.account.flash update success'
143         else
144           flash[:notice] = t 'user.account.flash update success confirm needed'
145
146           begin
147             Notifier.deliver_email_confirm(@user, @user.tokens.create)
148           rescue
149             # Ignore errors sending email
150           end
151         end
152
153         redirect_to :action => "account", :display_name => @user.display_name
154       end
155
156       if (params[:user][:openid_url].length > 0)
157         begin
158           @norm_openid_url = OpenIdAuthentication.normalize_identifier(params[:user][:openid_url])
159           if (@norm_openid_url != @user.openid_url)
160             #If the OpenID has changed, we want to check that it is a valid OpenID and one
161             #the user has control over before saving the openID as a password equivalent for
162             #the user.
163             openid_verify(@norm_openid_url, false)
164           end
165         rescue
166           flash.now[:error] = t 'user.login.openid invalid'
167         end
168       end
169
170     else
171       if flash[:errors]
172         flash[:errors].each do |attr,msg|
173           attr = "new_email" if attr == "email"
174           @user.errors.add(attr,msg)
175         end
176       end
177     end
178   end
179
180   def openid_specialcase_mapping(openid_url)
181     #Special case gmail.com, as it is pontentially a popular OpenID provider and unlike
182     #yahoo.com, where it works automatically, Google have hidden their OpenID endpoint
183     #somewhere obscure making it less userfriendly.
184     if (openid_url.match(/(.*)gmail.com(\/?)$/) or openid_url.match(/(.*)googlemail.com(\/?)$/) )
185       return 'https://www.google.com/accounts/o8/id'
186     end
187
188     return nil
189   end  
190
191   def openid_verify(openid_url,account_create)
192     authenticate_with_open_id(openid_url) do |result, identity_url|
193       if result.successful?
194         #We need to use the openid url passed back from the OpenID provider
195         #rather than the one supplied by the user, as these can be different.
196         #e.g. one can simply enter yahoo.com in the login box, i.e. no user specific url
197         #only once it comes back from the OpenID provider do we know the unique address for
198         #the user.
199         @user = session[:new_usr] unless @user #this is used for account creation when the user is not yet in the database
200         @user.openid_url = identity_url
201       elsif result.missing?
202         mapped_id = openid_specialcase_mapping(openid_url)
203         if mapped_id
204           openid_verify(mapped_id, account_create)
205         else
206           flash.now[:error] = t 'user.login.openid missing provider'
207         end
208       elsif result.invalid?
209         flash.now[:error] = t 'user.login.openid invalid'
210       else
211         flash.now[:error] = t 'user.login.auth failure'
212       end
213     end
214   end
215
216   def open_id_authentication(openid_url)
217     #TODO: only ask for nickname and email, if we don't already have a user for that openID, in which case
218     #email and nickname are already filled out. I don't know how to do that with ruby syntax though, as we
219     #don't want to duplicate the do block
220     #On the other hand it also doesn't matter too much if we ask every time, as the OpenID provider should
221     #remember these results, and shouldn't repromt the user for these data each time.
222     user = nil
223     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|
224       if result.successful?
225         #We need to use the openid url passed back from the OpenID provider
226         #rather than the one supplied by the user, as these can be different.
227         #e.g. one can simply enter yahoo.com in the login box, i.e. no user specific url
228         #only once it comes back from the OpenID provider do we know the unique address for
229         #the user.
230         user = User.find_by_openid_url(identity_url)
231         if user
232           if user.visible? and user.active?
233             session[:user] = user.id
234             session_expires_after 1.month if session[:remember]
235             return user
236           else
237             user = nil
238             flash.now[:error] = t 'user.login.account not active'
239           end
240         else
241           #We don't have a user registered to this OpenID. Redirect to the create account page
242           #with username and email filled in if they have been given by the OpenID provider through
243           #the simple registration protocol
244           redirect_to :controller => 'user', :action => 'new', :nickname => registration['nickname'], :email => registration['email'], :openid => identity_url
245         end
246       else if result.missing?
247              #Try and apply some heuristics to make common cases more userfriendly
248              mapped_id = openid_specialcase_mapping(openid_url)
249              if mapped_id
250                open_id_authentication(mapped_id)
251              else
252                flash.now[:error] = t 'user.login.openid missing provider'
253              end
254            else if result.invalid?
255                   flash.now[:error] = t 'user.login.openid invalid'
256                 else
257                   flash.now[:error] = t 'user.login.auth failure'
258                 end
259            end
260       end
261     end
262     return user
263   end
264
265   def go_public
266     @user.data_public = true
267     @user.save
268     flash[:notice] = t 'user.go_public.flash success'
269     redirect_to :controller => 'user', :action => 'account', :display_name => @user.display_name
270   end
271
272   def lost_password
273     @title = t 'user.lost_password.title'
274
275     if params[:user] and params[:user][:email]
276       user = User.find_by_email(params[:user][:email], :conditions => {:status => ["pending", "active", "confirmed"]})
277
278       if user
279         token = user.tokens.create
280         Notifier.deliver_lost_password(user, token)
281         flash[:notice] = t 'user.lost_password.notice email on way'
282         redirect_to :action => 'login'
283       else
284         flash.now[:error] = t 'user.lost_password.notice email cannot find'
285       end
286     end
287   end
288
289   def reset_password
290     @title = t 'user.reset_password.title'
291
292     if params[:token]
293       token = UserToken.find_by_token(params[:token])
294
295       if token
296         @user = token.user
297
298         if params[:user]
299           @user.pass_crypt = params[:user][:pass_crypt]
300           @user.pass_crypt_confirmation = params[:user][:pass_crypt_confirmation]
301           @user.status = "active" if @user.status == "pending"
302           @user.email_valid = true
303
304           if @user.save
305             token.destroy
306             flash[:notice] = t 'user.reset_password.flash changed'
307             redirect_to :action => 'login'
308           end
309         end
310       else
311         flash[:error] = t 'user.reset_password.flash token bad'
312         redirect_to :action => 'lost_password'
313       end
314     end
315   end
316
317   def new
318     @title = t 'user.new.title'
319
320     # The user is logged in already, so don't show them the signup
321     # page, instead send them to the home page
322     redirect_to :controller => 'site', :action => 'index' if session[:user]
323
324     @nickname = params['nickname']
325     @email = params['email']
326     @openID = params['openid']
327         
328     if !params['openid'].nil?
329           flash.now[:notice] = t 'user.new.openID association'
330     end
331   end
332
333   def login
334     @title = t 'user.login.title'
335
336     #The redirect from the OpenID provider reenters here again
337     #and we need to pass the parameters through to the 
338     # open_id_authentication function
339     if params[:open_id_complete]
340       user = open_id_authentication('')
341     elsif params[:user]
342       if !params[:user][:openid_url].nil? and !params[:user][:openid_url].empty?
343         session[:remember] = params[:remember_me]
344         #construct the openid request. This will redirect to the OpenID server to ask for validation
345         #The external OpenID server will then redirect back to the login method and reenters at the top
346         open_id_authentication(params[:user][:openid_url])
347         return
348       else
349         email_or_display_name = params[:user][:email]
350         pass = params[:user][:password]
351
352         if user = User.authenticate(:username => email_or_display_name, :password => pass)
353           session[:user] = user.id
354           session_expires_after 1.month if params[:remember_me]
355         elsif User.authenticate(:username => email_or_display_name, :password => pass, :pending => true)
356           flash.now[:error] = t 'user.login.account not active'
357         elsif User.authenticate(:username => email_or_display_name, :password => pass, :suspended => true)
358           flash.now[:error] = t 'user.login.account suspended'
359         else
360           flash.now[:error] = t 'user.login.auth failure'
361         end
362       end
363     end
364
365     if user
366       # The user is logged in, if the referer param exists, redirect
367       # them to that unless they've also got a block on them, in
368       # which case redirect them to the block so they can clear it.
369       if user.blocked_on_view
370         redirect_to user.blocked_on_view, :referrer => params[:referrer]
371       elsif params[:referer]
372         redirect_to params[:referer]
373       else
374         redirect_to :controller => 'site', :action => 'index'
375       end
376     end
377   end
378
379   def logout
380     @title = t 'user.logout.title'
381
382     if params[:session] == request.session_options[:id]
383       if session[:token]
384         token = UserToken.find_by_token(session[:token])
385         if token
386           token.destroy
387         end
388         session[:token] = nil
389       end
390       session[:user] = nil
391       session_expires_automatically
392       if params[:referer]
393         redirect_to params[:referer]
394       else
395         redirect_to :controller => 'site', :action => 'index'
396       end
397     end
398   end
399
400   def confirm
401     if params[:confirm_action]
402       token = UserToken.find_by_token(params[:confirm_string])
403       if token and !token.user.active?
404         @user = token.user
405         @user.status = "active"
406         @user.email_valid = true
407         @user.save!
408         referer = token.referer
409         token.destroy
410         flash[:notice] = t 'user.confirm.success'
411         session[:user] = @user.id
412         unless referer.nil?
413           redirect_to referer
414         else
415           redirect_to :action => 'account', :display_name => @user.display_name
416         end
417       else
418         flash.now[:error] = t 'user.confirm.failure'
419       end
420     end
421   end
422
423   def confirm_email
424     if params[:confirm_action]
425       token = UserToken.find_by_token(params[:confirm_string])
426       if token and token.user.new_email?
427         @user = token.user
428         @user.email = @user.new_email
429         @user.new_email = nil
430         @user.email_valid = true
431         if @user.save
432           flash[:notice] = t 'user.confirm_email.success'
433         else
434           flash[:errors] = @user.errors
435         end
436         token.destroy
437         session[:user] = @user.id
438         redirect_to :action => 'account', :display_name => @user.display_name
439       else
440         flash.now[:error] = t 'user.confirm_email.failure'
441       end
442     end
443   end
444
445   def api_gpx_files
446     doc = OSM::API.new.get_xml_doc
447     @user.traces.each do |trace|
448       doc.root << trace.to_xml_node() if trace.public? or trace.user == @user
449     end
450     render :text => doc.to_s, :content_type => "text/xml"
451   end
452
453   def view
454     @this_user = User.find_by_display_name(params[:display_name])
455
456     if @this_user and
457        (@this_user.visible? or (@user and @user.administrator?))
458       @title = @this_user.display_name
459     else
460       @title = t 'user.no_such_user.title'
461       @not_found_user = params[:display_name]
462       render :action => 'no_such_user', :status => :not_found
463     end
464   end
465
466   def make_friend
467     if params[:display_name]
468       name = params[:display_name]
469       new_friend = User.find_by_display_name(name, :conditions => {:status => ["active", "confirmed"]})
470       friend = Friend.new
471       friend.user_id = @user.id
472       friend.friend_user_id = new_friend.id
473       unless @user.is_friends_with?(new_friend)
474         if friend.save
475           flash[:notice] = t 'user.make_friend.success', :name => name
476           Notifier.deliver_friend_notification(friend)
477         else
478           friend.add_error(t('user.make_friend.failed', :name => name))
479         end
480       else
481         flash[:warning] = t 'user.make_friend.already_a_friend', :name => name
482       end
483
484       if params[:referer]
485         redirect_to params[:referer]
486       else
487         redirect_to :controller => 'user', :action => 'view'
488       end
489     end
490   end
491
492   def remove_friend
493     if params[:display_name]
494       name = params[:display_name]
495       friend = User.find_by_display_name(name, :conditions => {:status => ["active", "confirmed"]})
496       if @user.is_friends_with?(friend)
497         Friend.delete_all "user_id = #{@user.id} AND friend_user_id = #{friend.id}"
498         flash[:notice] = t 'user.remove_friend.success', :name => friend.display_name
499       else
500         flash[:error] = t 'user.remove_friend.not_a_friend', :name => friend.display_name
501       end
502
503       if params[:referer]
504         redirect_to params[:referer]
505       else
506         redirect_to :controller => 'user', :action => 'view'
507       end
508     end
509   end
510
511   ##
512   # sets a user's status
513   def set_status
514     @this_user.update_attributes(:status => params[:status])
515     redirect_to :controller => 'user', :action => 'view', :display_name => params[:display_name]
516   end
517
518   ##
519   # delete a user, marking them as deleted and removing personal data
520   def delete
521     @this_user.delete
522     redirect_to :controller => 'user', :action => 'view', :display_name => params[:display_name]
523   end
524
525   ##
526   # display a list of users matching specified criteria
527   def list
528     if request.post?
529       ids = params[:user].keys.collect { |id| id.to_i }
530
531       User.update_all("status = 'confirmed'", :id => ids) if params[:confirm]
532       User.update_all("status = 'deleted'", :id => ids) if params[:hide]
533
534       redirect_to url_for(:status => params[:status], :ip => params[:ip], :page => params[:page])
535     else
536       conditions = Hash.new
537       conditions[:status] = params[:status] if params[:status]
538       conditions[:creation_ip] = params[:ip] if params[:ip]
539
540       @user_pages, @users = paginate(:users,
541                                      :conditions => conditions,
542                                      :order => :id,
543                                      :per_page => 50)
544     end
545   end
546
547 private
548
549   ##
550   # require that the user is a administrator, or fill out a helpful error message
551   # and return them to the user page.
552   def require_administrator
553     if @user and not @user.administrator?
554       flash[:error] = t('user.filter.not_an_administrator')
555
556       if params[:display_name]
557         redirect_to :controller => 'user', :action => 'view', :display_name => params[:display_name]
558       else
559         redirect_to :controller => 'user', :action => 'login', :referer => request.request_uri
560       end
561     elsif not @user
562       redirect_to :controller => 'user', :action => 'login', :referer => request.request_uri
563     end
564   end
565
566   ##
567   # ensure that there is a "this_user" instance variable
568   def lookup_this_user
569     @this_user = User.find_by_display_name(params[:display_name])
570   rescue ActiveRecord::RecordNotFound
571     redirect_to :controller => 'user', :action => 'view', :display_name => params[:display_name] unless @this_user
572   end
573 end