X-Git-Url: https://git.openstreetmap.org/rails.git/blobdiff_plain/b0150caee632110eb5b305f9937b94473101645a..f0fa701563ee40723380f4f26a3eedc83b541cc9:/app/controllers/user_controller.rb diff --git a/app/controllers/user_controller.rb b/app/controllers/user_controller.rb index b1d6c86f7..766ab37d1 100644 --- a/app/controllers/user_controller.rb +++ b/app/controllers/user_controller.rb @@ -1,23 +1,23 @@ class UserController < ApplicationController layout "site", :except => [:api_details] - skip_before_filter :verify_authenticity_token, :only => [:api_read, :api_details, :api_gpx_files, :auth_success] - before_filter :disable_terms_redirect, :only => [:terms, :save, :logout, :api_details] - before_filter :authorize, :only => [:api_details, :api_gpx_files] - before_filter :authorize_web, :except => [:api_read, :api_details, :api_gpx_files] - before_filter :set_locale, :except => [:api_read, :api_details, :api_gpx_files] - before_filter :require_user, :only => [:account, :go_public, :make_friend, :remove_friend] - before_filter :require_self, :only => [:account] - before_filter :check_database_readable, :except => [:login, :api_read, :api_details, :api_gpx_files] - before_filter :check_database_writable, :only => [:new, :account, :confirm, :confirm_email, :lost_password, :reset_password, :go_public, :make_friend, :remove_friend] - before_filter :check_api_readable, :only => [:api_read, :api_details, :api_gpx_files] - before_filter :require_allow_read_prefs, :only => [:api_details] - before_filter :require_allow_read_gpx, :only => [:api_gpx_files] - before_filter :require_cookies, :only => [:new, :login, :confirm] - before_filter :require_administrator, :only => [:set_status, :delete, :list] - around_filter :api_call_handle_error, :only => [:api_read, :api_details, :api_gpx_files] - before_filter :lookup_user_by_id, :only => [:api_read] - before_filter :lookup_user_by_name, :only => [:set_status, :delete] + skip_before_action :verify_authenticity_token, :only => [:api_read, :api_details, :api_gpx_files, :auth_success] + before_action :disable_terms_redirect, :only => [:terms, :save, :logout, :api_details] + before_action :authorize, :only => [:api_details, :api_gpx_files] + before_action :authorize_web, :except => [:api_read, :api_details, :api_gpx_files] + before_action :set_locale, :except => [:api_read, :api_details, :api_gpx_files] + before_action :require_user, :only => [:account, :go_public, :make_friend, :remove_friend] + before_action :require_self, :only => [:account] + before_action :check_database_readable, :except => [:login, :api_read, :api_details, :api_gpx_files] + before_action :check_database_writable, :only => [:new, :account, :confirm, :confirm_email, :lost_password, :reset_password, :go_public, :make_friend, :remove_friend] + before_action :check_api_readable, :only => [:api_read, :api_details, :api_gpx_files] + before_action :require_allow_read_prefs, :only => [:api_details] + before_action :require_allow_read_gpx, :only => [:api_gpx_files] + before_action :require_cookies, :only => [:new, :login, :confirm] + before_action :require_administrator, :only => [:set_status, :delete, :list] + around_action :api_call_handle_error, :only => [:api_read, :api_details, :api_gpx_files] + before_action :lookup_user_by_id, :only => [:api_read] + before_action :lookup_user_by_name, :only => [:set_status, :delete] def terms @legale = params[:legale] || OSM.ip_to_country(request.remote_ip) || DEFAULT_LEGALE @@ -45,7 +45,7 @@ class UserController < ApplicationController @user.terms_seen = true if @user.save - flash[:notice] = t "user.new.terms declined", :url => t("user.new.terms declined url") + flash[:notice] = t("user.new.terms declined", :url => t("user.new.terms declined url")).html_safe end if params[:referer] @@ -80,7 +80,11 @@ class UserController < ApplicationController @user.languages = http_accept_language.user_preferred_languages @user.terms_agreed = Time.now.getutc @user.terms_seen = true - @user.openid_url = nil if @user.openid_url && @user.openid_url.empty? + + if @user.auth_uid.nil? || @user.auth_uid.empty? + @user.auth_provider = nil + @user.auth_uid = nil + end if @user.save flash[:piwik_goal] = PIWIK["goals"]["signup"] if defined?(PIWIK) @@ -119,17 +123,13 @@ class UserController < ApplicationController @tokens = @user.oauth_tokens.authorized if params[:user] && params[:user][:display_name] && params[:user][:description] - if params[:user][:openid_url] && - params[:user][:openid_url].length > 0 && - params[:user][:openid_url] != @user.openid_url - # If the OpenID has changed, we want to check that it is a - # valid OpenID and one the user has control over before saving - # it as a password equivalent for the user. - session[:new_user_settings] = params - openid_url = openid_expand_url(params[:user][:openid_url]) - redirect_to auth_path(:provider => "openid", :openid_url => openid_url, :origin => request.path) - else + if params[:user][:auth_provider].blank? || + (params[:user][:auth_provider] == @user.auth_provider && + params[:user][:auth_uid] == @user.auth_uid) update_user(@user, params) + else + session[:new_user_settings] = params + redirect_to auth_url(params[:user][:auth_provider], params[:user][:auth_uid]) end end end @@ -182,7 +182,7 @@ class UserController < ApplicationController if @user.save token.destroy flash[:notice] = t "user.reset_password.flash changed" - redirect_to :action => "login" + successful_login(@user) end end else @@ -206,13 +206,14 @@ class UserController < ApplicationController else redirect_to :controller => "site", :action => "index" end - elsif params.key?(:openid) + elsif params.key?(:auth_provider) && params.key?(:auth_uid) @user = User.new(:email => params[:email], :email_confirmation => params[:email], :display_name => params[:nickname], - :openid_url => params[:openid]) + :auth_provider => params[:auth_provider], + :auth_uid => params[:auth_uid]) - flash.now[:notice] = t "user.new.openid association" + flash.now[:notice] = render_to_string :partial => "auth_association" else check_signup_allowed end @@ -226,9 +227,9 @@ class UserController < ApplicationController @user.status = "pending" - if @user.openid_url.present? && @user.pass_crypt.empty? - # We are creating an account with OpenID and no password - # was specified so create a random one + if @user.auth_provider.present? && @user.pass_crypt.empty? + # We are creating an account with external authentication and + # no password was specified so create a random one @user.pass_crypt = SecureRandom.base64(16) @user.pass_crypt_confirmation = @user.pass_crypt end @@ -236,11 +237,10 @@ class UserController < ApplicationController if @user.invalid? # Something is wrong with a new user, so rerender the form render :action => "new" - elsif @user.openid_url.present? - # Verify OpenID before moving on + elsif @user.auth_provider.present? + # Verify external authenticator before moving on session[:new_user] = @user - openid_url = openid_expand_url(@user.openid_url) - redirect_to auth_path(:provider => "openid", :openid_url => openid_url, :origin => request.path) + redirect_to auth_url(@user.auth_provider, @user.auth_uid) else # Save the user record session[:new_user] = @user @@ -250,17 +250,14 @@ class UserController < ApplicationController end def login - if params[:username] || params[:openid_url] - session[:referer] ||= params[:referer] - - if params[:openid_url].present? - session[:remember_me] ||= params[:remember_me_openid] - openid_url = openid_expand_url(params[:openid_url]) - redirect_to auth_path(:provider => "openid", :openid_url => openid_url, :origin => request.path) - else - session[:remember_me] ||= params[:remember_me] - password_authentication(params[:username], params[:password]) - end + session[:referer] = params[:referer] if params[:referer] + + if params[:username].present? && params[:password].present? + session[:remember_me] ||= params[:remember_me] + password_authentication(params[:username], params[:password]) + elsif params[:openid_url].present? + session[:remember_me] ||= params[:remember_me_openid] + redirect_to auth_url("openid", params[:openid_url], params[:referer]) end end @@ -321,16 +318,19 @@ class UserController < ApplicationController else user = User.find_by_display_name(params[:display_name]) - redirect_to root_path if !user || user.active? + redirect_to root_path if user.nil? || user.active? end end def confirm_resend - if user = User.find_by_display_name(params[:display_name]) - Notifier.signup_confirm(user, user.tokens.create).deliver_now - flash[:notice] = t "user.confirm_resend.success", :email => user.email + user = User.find_by_display_name(params[:display_name]) + token = UserToken.find_by_token(session[:token]) + + if user.nil? || token.nil? || token.user != user + flash[:error] = t "user.confirm_resend.failure", :name => params[:display_name] else - flash[:notice] = t "user.confirm_resend.failure", :name => params[:display_name] + Notifier.signup_confirm(user, user.tokens.create).deliver_now + flash[:notice] = t("user.confirm_resend.success", :email => user.email).html_safe end redirect_to :action => "login" @@ -352,26 +352,32 @@ class UserController < ApplicationController token.destroy session[:user] = @user.id redirect_to :action => "account", :display_name => @user.display_name - else + elsif token flash[:error] = t "user.confirm_email.failure" - redirect_to :action => "account", :display_name => @user.display_name + redirect_to :action => "account", :display_name => token.user.display_name + else + flash[:error] = t "user.confirm_email.unknown_token" end end end def api_read - render :text => "", :status => :gone unless @this_user.visible? + if @this_user.visible? + render :action => :api_read, :content_type => "text/xml" + else + render :text => "", :status => :gone + end end def api_details @this_user = @user - render :action => :api_read + render :action => :api_read, :content_type => "text/xml" end def api_gpx_files doc = OSM::API.new.get_xml_doc - @user.traces.each do |trace| - doc.root << trace.to_xml_node if trace.public? || trace.user == @user + @user.traces.reload.each do |trace| + doc.root << trace.to_xml_node end render :text => doc.to_s, :content_type => "text/xml" end @@ -397,13 +403,11 @@ class UserController < ApplicationController friend.friend_user_id = @new_friend.id if @user.is_friends_with?(@new_friend) flash[:warning] = t "user.make_friend.already_a_friend", :name => @new_friend.display_name + elsif friend.save + flash[:notice] = t "user.make_friend.success", :name => @new_friend.display_name + Notifier.friend_notification(friend).deliver_now else - if friend.save - flash[:notice] = t "user.make_friend.success", :name => @new_friend.display_name - Notifier.friend_notification(friend).deliver_now - else - friend.add_error(t("user.make_friend.failed", :name => @new_friend.display_name)) - end + friend.add_error(t("user.make_friend.failed", :name => @new_friend.display_name)) end if params[:referer] @@ -461,8 +465,8 @@ class UserController < ApplicationController if request.post? ids = params[:user].keys.collect(&:to_i) - User.update_all("status = 'confirmed'", :id => ids) if params[:confirm] - User.update_all("status = 'deleted'", :id => ids) if params[:hide] + User.where(:id => ids).update_all(:status => "confirmed") if params[:confirm] + User.where(:id => ids).update_all(:status => "deleted") if params[:hide] redirect_to url_for(:status => params[:status], :ip => params[:ip], :page => params[:page]) else @@ -482,37 +486,59 @@ class UserController < ApplicationController def auth_success auth_info = env["omniauth.auth"] - openid_url = auth_info[:uid] + provider = auth_info[:provider] + uid = auth_info[:uid] name = auth_info[:info][:name] email = auth_info[:info][:email] - if user = User.find_by_openid_url(openid_url) + case provider + when "openid" + email_verified = uid.match(%r{https://www.google.com/accounts/o8/id?(.*)}) || + uid.match(%r{https://me.yahoo.com/(.*)}) + when "google", "facebook" + email_verified = true + else + email_verified = false + end + + user = User.find_by_auth_provider_and_auth_uid(provider, uid) + + if user.nil? && provider == "google" + openid_url = auth_info[:extra][:id_info]["openid_id"] + user = User.find_by_auth_provider_and_auth_uid("openid", openid_url) if openid_url + user.update(:auth_provider => provider, :auth_uid => uid) if user + end + + if user case user.status when "pending" then unconfirmed_login(user) when "active", "confirmed" then - successful_login(user) + successful_login(user, env["omniauth.params"]["referer"]) when "suspended" then failed_login t("user.login.account is suspended", :webmaster => "mailto:webmaster@openstreetmap.org") else failed_login t("user.login.auth failure") end elsif settings = session.delete(:new_user_settings) - @user.openid_url = openid_url + @user.auth_provider = provider + @user.auth_uid = uid update_user(@user, settings) redirect_to :action => "account", :display_name => @user.display_name elsif session[:new_user] - session[:new_user].openid_url = openid_url + session[:new_user].auth_provider = provider + session[:new_user].auth_uid = uid - if email == session[:new_user].email && openid_email_verified(email) + if email_verified && email == session[:new_user].email session[:new_user].status = "active" end redirect_to :action => "terms" else - redirect_to :action => "new", :nickname => name, :email => email, :openid => openid_url + redirect_to :action => "new", :nickname => name, :email => email, + :auth_provider => provider, :auth_uid => uid end end @@ -520,7 +546,7 @@ class UserController < ApplicationController # omniauth failure callback def auth_failure flash[:error] = t("user.auth_failure." + params[:message]) - redirect_to params[:origin] + redirect_to params[:origin] || login_url end private @@ -533,19 +559,36 @@ class UserController < ApplicationController elsif user = User.authenticate(:username => username, :password => password, :pending => true) unconfirmed_login(user) elsif User.authenticate(:username => username, :password => password, :suspended => true) - failed_login t("user.login.account is suspended", :webmaster => "mailto:webmaster@openstreetmap.org") + failed_login t("user.login.account is suspended", :webmaster => "mailto:webmaster@openstreetmap.org"), username else - failed_login t("user.login.auth failure") + failed_login t("user.login.auth failure"), username end end + ## + # return the URL to use for authentication + def auth_url(provider, uid, referer = nil) + params = { :provider => provider } + + params[:openid_url] = openid_expand_url(uid) if provider == "openid" + + if referer.nil? + params[:origin] = request.path + else + params[:origin] = request.path + "?referer=" + CGI.escape(referer) + params[:referer] = referer + end + + auth_path(params) + end + ## # special case some common OpenID providers by applying heuristics to # try and come up with the correct URL based on what the user entered def openid_expand_url(openid_url) if openid_url.nil? return nil - elsif openid_url.match(/(.*)gmail.com(\/?)$/) || openid_url.match(/(.*)googlemail.com(\/?)$/) + elsif openid_url.match(%r{(.*)gmail.com(/?)$}) || openid_url.match(%r{(.*)googlemail.com(/?)$}) # Special case gmail.com as it is potentially a popular OpenID # provider and, unlike yahoo.com, where it works automatically, Google # have hidden their OpenID endpoint somewhere obscure this making it @@ -556,21 +599,13 @@ class UserController < ApplicationController end end - ## - # check if we trust an OpenID provider to return a verified - # email, so that we can skpi verifying it ourselves - def openid_email_verified(openid_url) - openid_url.match(%r{https://www.google.com/accounts/o8/id?(.*)}) || - openid_url.match(%r{https://me.yahoo.com/(.*)}) - end - ## # process a successful login - def successful_login(user) + def successful_login(user, referer = nil) session[:user] = user.id session_expires_after 28.days if session[:remember_me] - target = session[:referer] || url_for(:controller => :site, :action => :index) + target = referer || session[:referer] || url_for(:controller => :site, :action => :index) # The user is logged in, so decide where to send them: # @@ -592,10 +627,11 @@ class UserController < ApplicationController ## # process a failed login - def failed_login(message) + def failed_login(message, username = nil) flash[:error] = message - redirect_to :action => "login", :referer => session[:referer] + redirect_to :action => "login", :referer => session[:referer], + :username => username, :remember_me => session[:remember_me] session.delete(:remember_me) session.delete(:referer) @@ -604,6 +640,8 @@ class UserController < ApplicationController ## # def unconfirmed_login(user) + session[:token] = user.tokens.create.token + redirect_to :action => "confirm", :display_name => user.display_name session.delete(:remember_me) @@ -616,7 +654,7 @@ class UserController < ApplicationController user.display_name = params[:user][:display_name] user.new_email = params[:user][:new_email] - if params[:user][:pass_crypt].length > 0 || params[:user][:pass_crypt_confirmation].length > 0 + unless params[:user][:pass_crypt].empty? && params[:user][:pass_crypt_confirmation].empty? user.pass_crypt = params[:user][:pass_crypt] user.pass_crypt_confirmation = params[:user][:pass_crypt_confirmation] end @@ -643,13 +681,16 @@ class UserController < ApplicationController user.home_lat = params[:user][:home_lat] user.home_lon = params[:user][:home_lon] - if params[:user][:preferred_editor] == "default" - user.preferred_editor = nil - else - user.preferred_editor = params[:user][:preferred_editor] - end + user.preferred_editor = if params[:user][:preferred_editor] == "default" + nil + else + params[:user][:preferred_editor] + end - user.openid_url = nil if params[:user][:openid_url].blank? + if params[:user][:auth_provider].nil? || params[:user][:auth_provider].blank? + user.auth_provider = nil + user.auth_uid = nil + end if user.save set_locale @@ -728,17 +769,19 @@ class UserController < ApplicationController ## # return permitted user parameters def user_params - params.require(:user).permit(:email, :email_confirmation, :display_name, :openid_url, :pass_crypt, :pass_crypt_confirmation) + params.require(:user).permit(:email, :email_confirmation, :display_name, + :auth_provider, :auth_uid, + :pass_crypt, :pass_crypt_confirmation) end ## # check signup acls def check_signup_allowed(email = nil) - if email.nil? - domain = nil - else - domain = email.split("@").last - end + domain = if email.nil? + nil + else + email.split("@").last + end if blocked = Acl.no_account_creation(request.remote_ip, domain) logger.info "Blocked signup from #{request.remote_ip} for #{email}"