Replace attr_accessible with strong parameters
[rails.git] / app / controllers / user_controller.rb
1 class UserController < ApplicationController
2   layout :choose_layout
3
4   skip_before_filter :verify_authenticity_token, :only => [:api_read, :api_details, :api_gpx_files]
5   before_filter :disable_terms_redirect, :only => [:terms, :save, :logout, :api_details]
6   before_filter :authorize, :only => [:api_details, :api_gpx_files]
7   before_filter :authorize_web, :except => [:api_read, :api_details, :api_gpx_files]
8   before_filter :set_locale, :except => [:api_read, :api_details, :api_gpx_files]
9   before_filter :require_user, :only => [:account, :go_public, :make_friend, :remove_friend]
10   before_filter :check_database_readable, :except => [:login, :api_read, :api_details, :api_gpx_files]
11   before_filter :check_database_writable, :only => [:new, :account, :confirm, :confirm_email, :lost_password, :reset_password, :go_public, :make_friend, :remove_friend]
12   before_filter :check_api_readable, :only => [:api_read, :api_details, :api_gpx_files]
13   before_filter :require_allow_read_prefs, :only => [:api_details]
14   before_filter :require_allow_read_gpx, :only => [:api_gpx_files]
15   before_filter :require_cookies, :only => [:new, :login, :confirm]
16   before_filter :require_administrator, :only => [:set_status, :delete, :list]
17   around_filter :api_call_handle_error, :only => [:api_read, :api_details, :api_gpx_files]
18   before_filter :lookup_user_by_id, :only => [:api_read]
19   before_filter :lookup_user_by_name, :only => [:set_status, :delete]
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 :partial => "terms"
27     else
28       @title = t 'user.terms.title'
29       @user ||= session[:new_user]
30
31       if !@user
32         redirect_to :action => :login, :referer => request.fullpath
33       elsif @user.terms_agreed?
34         # Already agreed to terms, so just show settings
35         redirect_to :action => :account, :display_name => @user.display_name
36       end
37     end
38   end
39
40   def save
41     @title = t 'user.new.title'
42
43     if params[:decline]
44       if @user
45         @user.terms_seen = true
46
47         if @user.save
48           flash[:notice] = t 'user.new.terms declined', :url => t('user.new.terms declined url')
49         end
50
51         if params[:referer]
52           redirect_to params[:referer]
53         else
54           redirect_to :action => :account, :display_name => @user.display_name
55         end
56       else
57         redirect_to t('user.terms.declined')
58       end
59     elsif @user
60       if !@user.terms_agreed?
61         @user.consider_pd = params[:user][:consider_pd]
62         @user.terms_agreed = Time.now.getutc
63         @user.terms_seen = true
64         if @user.save
65           flash[:notice] = t 'user.new.terms accepted'
66         end
67       end
68
69       if params[:referer]
70         redirect_to params[:referer]
71       else
72         redirect_to :action => :account, :display_name => @user.display_name
73       end
74     else
75       @user = session.delete(:new_user)
76
77       if Acl.no_account_creation(request.remote_ip, @user.email.split("@").last)
78         render :action => 'blocked'
79       else
80         @user.data_public = true
81         @user.description = "" if @user.description.nil?
82         @user.creation_ip = request.remote_ip
83         @user.languages = request.user_preferred_languages
84         @user.terms_agreed = Time.now.getutc
85         @user.terms_seen = true
86         @user.openid_url = nil if @user.openid_url and @user.openid_url.empty?
87
88         if @user.save
89           flash[:piwik_goal] = PIWIK["goals"]["signup"] if defined?(PIWIK)
90
91           referer = welcome_path
92
93           begin
94             uri = URI(session[:referer])
95             /map=(.*)\/(.*)\/(.*)/.match(uri.fragment) do |m|
96               editor = Rack::Utils.parse_query(uri.query).slice('editor')
97               referer = welcome_path({'zoom' => m[1],
98                                       'lat' => m[2],
99                                       'lon' => m[3]}.merge(editor))
100             end
101           rescue
102             # Use default
103           end
104
105           if @user.status == "active"
106             session[:referer] = referer
107             successful_login(@user)
108           else
109             session[:token] = @user.tokens.create.token
110             Notifier.signup_confirm(@user, @user.tokens.create(:referer => referer)).deliver
111             redirect_to :action => 'confirm', :display_name => @user.display_name
112           end
113         else
114           render :action => 'new', :referer => params[:referer]
115         end
116       end
117     end
118   end
119
120   def account
121     @title = t 'user.account.title'
122     @tokens = @user.oauth_tokens.authorized
123
124     if params[:user] and params[:user][:display_name] and params[:user][:description]
125       if params[:user][:openid_url] and
126          params[:user][:openid_url].length > 0 and
127          params[:user][:openid_url] != @user.openid_url
128         # If the OpenID has changed, we want to check that it is a
129         # valid OpenID and one the user has control over before saving
130         # it as a password equivalent for the user.
131         session[:new_user_settings] = params
132         openid_verify(params[:user][:openid_url], @user)
133       else
134         update_user(@user, params)
135       end
136     elsif using_open_id?
137       # The redirect from the OpenID provider reenters here
138       # again and we need to pass the parameters through to
139       # the open_id_authentication function
140       settings = session.delete(:new_user_settings)
141       openid_verify(nil, @user) do |user|
142         update_user(user, settings)
143       end
144     end
145   end
146
147   def go_public
148     @user.data_public = true
149     @user.save
150     flash[:notice] = t 'user.go_public.flash success'
151     redirect_to :controller => 'user', :action => 'account', :display_name => @user.display_name
152   end
153
154   def lost_password
155     @title = t 'user.lost_password.title'
156
157     if params[:user] and params[:user][:email]
158       user = User.visible.find_by_email(params[:user][:email])
159
160       if user.nil?
161         users = User.visible.where("LOWER(email) = LOWER(?)", params[:user][:email])
162
163         if users.count == 1
164           user = users.first
165         end
166       end
167
168       if user
169         token = user.tokens.create
170         Notifier.lost_password(user, token).deliver
171         flash[:notice] = t 'user.lost_password.notice email on way'
172         redirect_to :action => 'login'
173       else
174         flash.now[:error] = t 'user.lost_password.notice email cannot find'
175       end
176     end
177   end
178
179   def reset_password
180     @title = t 'user.reset_password.title'
181
182     if params[:token]
183       token = UserToken.find_by_token(params[:token])
184
185       if token
186         @user = token.user
187
188         if params[:user]
189           @user.pass_crypt = params[:user][:pass_crypt]
190           @user.pass_crypt_confirmation = params[:user][:pass_crypt_confirmation]
191           @user.status = "active" if @user.status == "pending"
192           @user.email_valid = true
193
194           if @user.save
195             token.destroy
196             flash[:notice] = t 'user.reset_password.flash changed'
197             redirect_to :action => 'login'
198           end
199         end
200       else
201         flash[:error] = t 'user.reset_password.flash token bad'
202         redirect_to :action => 'lost_password'
203       end
204     end
205   end
206
207   def new
208     @title = t 'user.new.title'
209     @referer = params[:referer] || session[:referer]
210
211     if using_open_id?
212       # The redirect from the OpenID provider reenters here
213       # again and we need to pass the parameters through to
214       # the open_id_authentication function
215       @user = session.delete(:new_user)
216
217       openid_verify(nil, @user) do |user, verified_email|
218         user.status = "active" if user.email == verified_email
219       end
220
221       if @user.openid_url.nil? or @user.invalid?
222         render :action => 'new'
223       else
224         session[:new_user] = @user
225         redirect_to :action => 'terms'
226       end
227     elsif @user
228       # The user is logged in already, so don't show them the signup
229       # page, instead send them to the home page
230       if @referer
231         redirect_to @referer
232       else
233         redirect_to :controller => 'site', :action => 'index'
234       end
235     elsif params.key?(:openid)
236       @user = User.new(:email => params[:email],
237                        :email_confirmation => params[:email],
238                        :display_name => params[:nickname],
239                        :openid_url => params[:openid])
240
241       flash.now[:notice] = t 'user.new.openid association'
242     elsif Acl.no_account_creation(request.remote_ip)
243       render :action => 'blocked'
244     end
245   end
246
247   def create
248     if params[:user] and Acl.no_account_creation(request.remote_ip, params[:user][:email].split("@").last)
249       render :action => 'blocked'
250
251     else
252       session[:referer] = params[:referer]
253
254       @user = User.new(user_params)
255       @user.status = "pending"
256
257       if @user.openid_url.present? && @user.pass_crypt.empty?
258         # We are creating an account with OpenID and no password
259         # was specified so create a random one
260         @user.pass_crypt = SecureRandom.base64(16)
261         @user.pass_crypt_confirmation = @user.pass_crypt
262       end
263
264       if @user.invalid?
265         # Something is wrong with a new user, so rerender the form
266         render :action => "new"
267       elsif @user.openid_url.present?
268         # Verify OpenID before moving on
269         session[:new_user] = @user
270         openid_verify(@user.openid_url, @user)
271       else
272         # Save the user record
273         session[:new_user] = @user
274         redirect_to :action => :terms
275       end
276     end
277   end
278
279   def login
280     if params[:username] or using_open_id?
281       session[:remember_me] ||= params[:remember_me]
282       session[:referer] ||= params[:referer]
283
284       if using_open_id?
285         openid_authentication(params[:openid_url])
286       else
287         password_authentication(params[:username], params[:password])
288       end
289     end
290   end
291
292   def logout
293     @title = t 'user.logout.title'
294
295     if params[:session] == request.session_options[:id]
296       if session[:token]
297         token = UserToken.find_by_token(session[:token])
298         if token
299           token.destroy
300         end
301         session.delete(:token)
302       end
303       session.delete(:user)
304       session_expires_automatically
305       if params[:referer]
306         redirect_to params[:referer]
307       else
308         redirect_to :controller => 'site', :action => 'index'
309       end
310     end
311   end
312
313   def confirm
314     if request.post?
315       token = UserToken.find_by_token(params[:confirm_string])
316       if token && token.user.active?
317         flash[:error] = t('user.confirm.already active')
318         redirect_to :action => 'login'
319       elsif !token || token.expired?
320         flash[:error] = t('user.confirm.unknown token')
321         redirect_to :action => 'confirm'
322       else
323         user = token.user
324         user.status = "active"
325         user.email_valid = true
326         user.save!
327         referer = token.referer
328         token.destroy
329
330         if session[:token]
331           token = UserToken.find_by_token(session[:token])
332           session.delete(:token)
333         else
334           token = nil
335         end
336
337         if token.nil? or token.user != user
338           flash[:notice] = t('user.confirm.success')
339           redirect_to :action => :login, :referer => referer
340         else
341           token.destroy
342
343           session[:user] = user.id
344           cookies.permanent["_osm_username"] = user.display_name
345
346           redirect_to referer || welcome_path
347         end
348       end
349     else
350       user = User.find_by_display_name(params[:display_name])
351       if !user || user.active?
352         redirect_to root_path
353       end
354     end
355   end
356
357   def confirm_resend
358     if user = User.find_by_display_name(params[:display_name])
359       Notifier.signup_confirm(user, user.tokens.create).deliver
360       flash[:notice] = t 'user.confirm_resend.success', :email => user.email
361     else
362       flash[:notice] = t 'user.confirm_resend.failure', :name => params[:display_name]
363     end
364
365     redirect_to :action => 'login'
366   end
367
368   def confirm_email
369     if request.post?
370       token = UserToken.find_by_token(params[:confirm_string])
371       if token and token.user.new_email?
372         @user = token.user
373         @user.email = @user.new_email
374         @user.new_email = nil
375         @user.email_valid = true
376         if @user.save
377           flash[:notice] = t 'user.confirm_email.success'
378         else
379           flash[:errors] = @user.errors
380         end
381         token.destroy
382         session[:user] = @user.id
383         cookies.permanent["_osm_username"] = @user.display_name
384         redirect_to :action => 'account', :display_name => @user.display_name
385       else
386         flash[:error] = t 'user.confirm_email.failure'
387         redirect_to :action => 'account', :display_name => @user.display_name
388       end
389     end
390   end
391
392   def api_read
393     render :text => "", :status => :gone unless @this_user.visible?
394   end
395
396   def api_details
397     @this_user = @user
398     render :action => :api_read
399   end
400
401   def api_gpx_files
402     doc = OSM::API.new.get_xml_doc
403     @user.traces.each do |trace|
404       doc.root << trace.to_xml_node() if trace.public? or trace.user == @user
405     end
406     render :text => doc.to_s, :content_type => "text/xml"
407   end
408
409   def view
410     @this_user = User.find_by_display_name(params[:display_name])
411
412     if @this_user and
413        (@this_user.visible? or (@user and @user.administrator?))
414       @title = @this_user.display_name
415     else
416       render_unknown_user params[:display_name]
417     end
418   end
419
420   def make_friend
421     @new_friend = User.find_by_display_name(params[:display_name])
422
423     if @new_friend
424       if request.post?
425         friend = Friend.new
426         friend.user_id = @user.id
427         friend.friend_user_id = @new_friend.id
428         unless @user.is_friends_with?(@new_friend)
429           if friend.save
430             flash[:notice] = t 'user.make_friend.success', :name => @new_friend.display_name
431             Notifier.friend_notification(friend).deliver
432           else
433             friend.add_error(t('user.make_friend.failed', :name => @new_friend.display_name))
434           end
435         else
436           flash[:warning] = t 'user.make_friend.already_a_friend', :name => @new_friend.display_name
437         end
438
439         if params[:referer]
440           redirect_to params[:referer]
441         else
442           redirect_to :controller => 'user', :action => 'view'
443         end
444       end
445     else
446       render_unknown_user params[:display_name]
447     end
448   end
449
450   def remove_friend
451     @friend = User.find_by_display_name(params[:display_name])
452
453     if @friend
454       if request.post?
455         if @user.is_friends_with?(@friend)
456           Friend.delete_all "user_id = #{@user.id} AND friend_user_id = #{@friend.id}"
457           flash[:notice] = t 'user.remove_friend.success', :name => @friend.display_name
458         else
459           flash[:error] = t 'user.remove_friend.not_a_friend', :name => @friend.display_name
460         end
461
462         if params[:referer]
463           redirect_to params[:referer]
464         else
465           redirect_to :controller => 'user', :action => 'view'
466         end
467       end
468     else
469       render_unknown_user params[:display_name]
470     end
471   end
472
473   ##
474   # sets a user's status
475   def set_status
476     @this_user.status = params[:status]
477     @this_user.save
478     redirect_to :controller => 'user', :action => 'view', :display_name => params[:display_name]
479   end
480
481   ##
482   # delete a user, marking them as deleted and removing personal data
483   def delete
484     @this_user.delete
485     redirect_to :controller => 'user', :action => 'view', :display_name => params[:display_name]
486   end
487
488   ##
489   # display a list of users matching specified criteria
490   def list
491     if request.post?
492       ids = params[:user].keys.collect { |id| id.to_i }
493
494       User.update_all("status = 'confirmed'", :id => ids) if params[:confirm]
495       User.update_all("status = 'deleted'", :id => ids) if params[:hide]
496
497       redirect_to url_for(:status => params[:status], :ip => params[:ip], :page => params[:page])
498     else
499       conditions = Hash.new
500       conditions[:status] = params[:status] if params[:status]
501       conditions[:creation_ip] = params[:ip] if params[:ip]
502
503       @user_pages, @users = paginate(:users,
504                                      :conditions => conditions,
505                                      :order => :id,
506                                      :per_page => 50)
507     end
508   end
509
510 private
511
512   ##
513   # handle password authentication
514   def password_authentication(username, password)
515     if user = User.authenticate(:username => username, :password => password)
516       successful_login(user)
517     elsif user = User.authenticate(:username => username, :password => password, :pending => true)
518       unconfirmed_login(user)
519     elsif User.authenticate(:username => username, :password => password, :suspended => true)
520       failed_login t('user.login.account is suspended', :webmaster => "mailto:webmaster@openstreetmap.org")
521     else
522       failed_login t('user.login.auth failure')
523     end
524   end
525
526   ##
527   # handle OpenID authentication
528   def openid_authentication(openid_url)
529     # If we don't appear to have a user for this URL then ask the
530     # provider for some extra information to help with signup
531     if openid_url and User.find_by_openid_url(openid_url)
532       required = nil
533     else
534       required = [:nickname, :email, "http://axschema.org/namePerson/friendly", "http://axschema.org/contact/email"]
535     end
536
537     # Start the authentication
538     authenticate_with_open_id(openid_expand_url(openid_url), :method => :get, :required => required) do |result, identity_url, sreg, ax|
539       if result.successful?
540         # We need to use the openid url passed back from the OpenID provider
541         # rather than the one supplied by the user, as these can be different.
542         #
543         # For example, you can simply enter yahoo.com in the login box rather
544         # than a user specific url. Only once it comes back from the provider
545         # provider do we know the unique address for the user.
546         if user = User.find_by_openid_url(identity_url)
547           case user.status
548             when "pending" then
549               unconfirmed_login(user)
550             when "active", "confirmed" then
551               successful_login(user)
552             when "suspended" then
553               failed_login t('user.login.account is suspended', :webmaster => "mailto:webmaster@openstreetmap.org")
554             else
555               failed_login t('user.login.auth failure')
556           end
557         else
558           # Guard against not getting any extension data
559           sreg = Hash.new if sreg.nil?
560           ax = Hash.new if ax.nil?
561
562           # We don't have a user registered to this OpenID, so redirect
563           # to the create account page with username and email filled
564           # in if they have been given by the OpenID provider through
565           # the simple registration protocol.
566           nickname = sreg["nickname"] || ax["http://axschema.org/namePerson/friendly"].first
567           email = sreg["email"] || ax["http://axschema.org/contact/email"].first
568
569           redirect_to :controller => 'user', :action => 'new', :nickname => nickname, :email => email, :openid => identity_url
570         end
571       elsif result.missing?
572         failed_login t('user.login.openid missing provider')
573       elsif result.invalid?
574         failed_login t('user.login.openid invalid')
575       else
576         failed_login t('user.login.auth failure')
577       end
578     end
579   end
580
581   ##
582   # verify an OpenID URL
583   def openid_verify(openid_url, user)
584     user.openid_url = openid_url
585
586     authenticate_with_open_id(openid_expand_url(openid_url), :method => :get, :required => [:email, "http://axschema.org/contact/email"]) do |result, identity_url, sreg, ax|
587       if result.successful?
588         # Do we trust the emails this provider returns?
589         if openid_email_verified(identity_url)
590           # Guard against not getting any extension data
591           sreg = Hash.new if sreg.nil?
592           ax = Hash.new if ax.nil?
593
594           # Get the verified email
595           verified_email = sreg["email"] || ax["http://axschema.org/contact/email"].first
596         end
597
598         # We need to use the openid url passed back from the OpenID provider
599         # rather than the one supplied by the user, as these can be different.
600         #
601         # For example, you can simply enter yahoo.com in the login box rather
602         # than a user specific url. Only once it comes back from the provider
603         # provider do we know the unique address for the user.
604         user.openid_url = identity_url
605         yield user, verified_email
606       elsif result.missing?
607         flash.now[:error] = t 'user.login.openid missing provider'
608       elsif result.invalid?
609         flash.now[:error] = t 'user.login.openid invalid'
610       else
611         flash.now[:error] = t 'user.login.auth failure'
612       end
613     end
614   end
615
616   ##
617   # special case some common OpenID providers by applying heuristics to
618   # try and come up with the correct URL based on what the user entered
619   def openid_expand_url(openid_url)
620     if openid_url.nil?
621       return nil
622     elsif openid_url.match(/(.*)gmail.com(\/?)$/) or openid_url.match(/(.*)googlemail.com(\/?)$/)
623       # Special case gmail.com as it is potentially a popular OpenID
624       # provider and, unlike yahoo.com, where it works automatically, Google
625       # have hidden their OpenID endpoint somewhere obscure this making it
626       # somewhat less user friendly.
627       return 'https://www.google.com/accounts/o8/id'
628     else
629       return openid_url
630     end
631   end
632
633   ##
634   # check if we trust an OpenID provider to return a verified
635   # email, so that we can skpi verifying it ourselves
636   def openid_email_verified(openid_url)
637     openid_url.match(/https:\/\/www.google.com\/accounts\/o8\/id?(.*)/) or
638     openid_url.match(/https:\/\/me.yahoo.com\/(.*)/)
639   end
640
641   ##
642   # process a successful login
643   def successful_login(user)
644     cookies.permanent["_osm_username"] = user.display_name
645
646     session[:user] = user.id
647     session_expires_after 28.days if session[:remember_me]
648
649     target = session[:referer] || url_for(:controller => :site, :action => :index)
650
651     # The user is logged in, so decide where to send them:
652     #
653     # - If they haven't seen the contributor terms, send them there.
654     # - If they have a block on them, show them that.
655     # - If they were referred to the login, send them back there.
656     # - Otherwise, send them to the home page.
657     if REQUIRE_TERMS_SEEN and not user.terms_seen
658       redirect_to :controller => :user, :action => :terms, :referer => target
659     elsif user.blocked_on_view
660       redirect_to user.blocked_on_view, :referer => target
661     else
662       redirect_to target
663     end
664
665     session.delete(:remember_me)
666     session.delete(:referer)
667   end
668
669   ##
670   # process a failed login
671   def failed_login(message)
672     flash[:error] = message
673
674     redirect_to :action => 'login', :referer =>  session[:referer]
675
676     session.delete(:remember_me)
677     session.delete(:referer)
678   end
679
680   ##
681   #
682   def unconfirmed_login(user)
683     redirect_to :action => 'confirm', :display_name => user.display_name
684
685     session.delete(:remember_me)
686     session.delete(:referer)
687   end
688
689   ##
690   # update a user's details
691   def update_user(user, params)
692     user.display_name = params[:user][:display_name]
693     user.new_email = params[:user][:new_email]
694
695     if params[:user][:pass_crypt].length > 0 or params[:user][:pass_crypt_confirmation].length > 0
696       user.pass_crypt = params[:user][:pass_crypt]
697       user.pass_crypt_confirmation = params[:user][:pass_crypt_confirmation]
698     end
699
700     if params[:user][:description] != user.description
701       user.description = params[:user][:description]
702       user.description_format = "markdown"
703     end
704
705     user.languages = params[:user][:languages].split(",")
706
707     case params[:image_action]
708     when "new" then
709       user.image = params[:user][:image]
710       user.image_use_gravatar = false
711     when "delete" then
712       user.image = nil
713       user.image_use_gravatar = false
714     when "gravatar" then
715       user.image = nil
716       user.image_use_gravatar = true
717     end
718
719     user.home_lat = params[:user][:home_lat]
720     user.home_lon = params[:user][:home_lon]
721
722     if params[:user][:preferred_editor] == "default"
723       user.preferred_editor = nil
724     else
725       user.preferred_editor = params[:user][:preferred_editor]
726     end
727
728     user.openid_url = nil if params[:user][:openid_url].blank?
729
730     if user.save
731       set_locale
732
733       cookies.permanent["_osm_username"] = user.display_name
734
735       if user.new_email.blank? or user.new_email == user.email
736         flash.now[:notice] = t 'user.account.flash update success'
737       else
738         user.email = user.new_email
739
740         if user.valid?
741           flash.now[:notice] = t 'user.account.flash update success confirm needed'
742
743           begin
744             Notifier.email_confirm(user, user.tokens.create).deliver
745           rescue
746             # Ignore errors sending email
747           end
748         else
749           @user.errors.set(:new_email, @user.errors.get(:email))
750           @user.errors.set(:email, [])
751         end
752
753         user.reset_email!
754       end
755     end
756   end
757
758   ##
759   # require that the user is a administrator, or fill out a helpful error message
760   # and return them to the user page.
761   def require_administrator
762     if @user and not @user.administrator?
763       flash[:error] = t('user.filter.not_an_administrator')
764
765       if params[:display_name]
766         redirect_to :controller => 'user', :action => 'view', :display_name => params[:display_name]
767       else
768         redirect_to :controller => 'user', :action => 'login', :referer => request.fullpath
769       end
770     elsif not @user
771       redirect_to :controller => 'user', :action => 'login', :referer => request.fullpath
772     end
773   end
774
775   ##
776   # ensure that there is a "this_user" instance variable
777   def lookup_user_by_id
778     @this_user = User.find(params[:id])
779   end
780
781   ##
782   # ensure that there is a "this_user" instance variable
783   def lookup_user_by_name
784     @this_user = User.find_by_display_name(params[:display_name])
785   rescue ActiveRecord::RecordNotFound
786     redirect_to :controller => 'user', :action => 'view', :display_name => params[:display_name] unless @this_user
787   end
788
789   ##
790   # Choose the layout to use. See
791   # https://rails.lighthouseapp.com/projects/8994/tickets/5371-layout-with-onlyexcept-options-makes-other-actions-render-without-layouts
792   def choose_layout
793     oauth_url = url_for(:controller => :oauth, :action => :authorize, :only_path => true)
794
795     if [ 'api_details' ].include? action_name
796       nil
797     elsif params[:referer] and URI.parse(params[:referer]).path == oauth_url
798       'slim'
799     else
800       'site'
801     end
802   end
803
804   ##
805   #
806   def disable_terms_redirect
807     # this is necessary otherwise going to the user terms page, when
808     # having not agreed already would cause an infinite redirect loop.
809     # it's .now so that this doesn't propagate to other pages.
810     flash.now[:skip_terms] = true
811   end
812
813   ##
814   # return permitted user parameters
815   def user_params
816     params.require(:user).permit(:email, :email_confirmation, :display_name, :openid_url, :pass_crypt, :pass_crypt_confirmation)
817   end
818 end