X-Git-Url: https://git.openstreetmap.org./rails.git/blobdiff_plain/dc2a2c8ebd1a11e4a64555fda22c6859a51defff..dbe165bbb3d6eda37d9579f1ac767599f9055607:/app/controllers/user_controller.rb diff --git a/app/controllers/user_controller.rb b/app/controllers/user_controller.rb index 1a7f3810a..7c20c5111 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] - 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 @@ -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) @@ -89,7 +93,7 @@ class UserController < ApplicationController begin uri = URI(session[:referer]) - /map=(.*)\/(.*)\/(.*)/.match(uri.fragment) do |m| + %r{map=(.*)/(.*)/(.*)}.match(uri.fragment) do |m| editor = Rack::Utils.parse_query(uri.query).slice("editor") referer = welcome_path({ "zoom" => m[1], "lat" => m[2], @@ -119,24 +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_verify(params[:user][:openid_url], @user) - 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) - end - elsif using_open_id? - # The redirect from the OpenID provider reenters here - # again and we need to pass the parameters through to - # the open_id_authentication function - settings = session.delete(:new_user_settings) - openid_verify(nil, @user) do |user| - update_user(user, settings) + else + session[:new_user_settings] = params + redirect_to auth_url(params[:user][:auth_provider], params[:user][:auth_uid]) end end end @@ -205,23 +198,7 @@ class UserController < ApplicationController @title = t "user.new.title" @referer = params[:referer] || session[:referer] - if using_open_id? - # The redirect from the OpenID provider reenters here - # again and we need to pass the parameters through to - # the open_id_authentication function - @user = session.delete(:new_user) - - openid_verify(nil, @user) do |user, verified_email| - user.status = "active" if user.email == verified_email - end - - if @user.openid_url.nil? || @user.invalid? - render :action => "new" - else - session[:new_user] = @user - redirect_to :action => "terms" - end - elsif @user + if @user # The user is logged in already, so don't show them the signup # page, instead send them to the home page if @referer @@ -229,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] = t "user.new.auth association" else check_signup_allowed end @@ -249,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.auth_uid.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 @@ -259,10 +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? && @user.auth_uid.present? + # Verify external authenticator before moving on session[:new_user] = @user - openid_verify(@user.openid_url, @user) + redirect_to auth_url(@user.auth_provider, @user.auth_uid) else # Save the user record session[:new_user] = @user @@ -272,12 +250,12 @@ class UserController < ApplicationController end def login - if params[:username] || using_open_id? + if params[:username] || params[:openid_url] session[:referer] ||= params[:referer] - if using_open_id? + if params[:openid_url].present? session[:remember_me] ||= params[:remember_me_openid] - openid_authentication(params[:openid_url]) + redirect_to auth_url("openid", params[:openid_url]) else session[:remember_me] ||= params[:remember_me] password_authentication(params[:username], params[:password]) @@ -498,6 +476,64 @@ class UserController < ApplicationController end end + ## + # omniauth success callback + def auth_success + auth_info = env["omniauth.auth"] + + provider = auth_info[:provider] + uid = auth_info[:uid] + name = auth_info[:info][:name] + email = auth_info[:info][:email] + + case provider + when "openid" + email_verified = uid.match(%r{https://www.google.com/accounts/o8/id?(.*)}) || + uid.match(%r{https://me.yahoo.com/(.*)}) + else + email_verified = false + end + + if user = User.find_by_auth_provider_and_auth_uid(provider, uid) + case user.status + when "pending" then + unconfirmed_login(user) + when "active", "confirmed" then + successful_login(user) + 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.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].auth_provider = provider + session[:new_user].auth_uid = uid + + 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, + :auth_provider => provider, :auth_uid => uid + end + end + + ## + # omniauth failure callback + def auth_failure + flash[:error] = t("user.auth_failure." + params[:message]) + redirect_to params[:origin] + end + private ## @@ -515,92 +551,12 @@ class UserController < ApplicationController end ## - # handle OpenID authentication - def openid_authentication(openid_url) - # If we don't appear to have a user for this URL then ask the - # provider for some extra information to help with signup - if openid_url && User.find_by_openid_url(openid_url) - required = nil + # return the URL to use for authentication + def auth_url(provider, uid) + if provider == "openid" + auth_path(:provider => "openid", :openid_url => openid_expand_url(uid), :origin => request.path) else - required = [:nickname, :email, "http://axschema.org/namePerson/friendly", "http://axschema.org/contact/email"] - end - - # Start the authentication - authenticate_with_open_id(openid_expand_url(openid_url), :method => :get, :required => required) do |result, identity_url, sreg, ax| - if result.successful? - # We need to use the openid url passed back from the OpenID provider - # rather than the one supplied by the user, as these can be different. - # - # For example, you can simply enter yahoo.com in the login box rather - # than a user specific url. Only once it comes back from the provider - # provider do we know the unique address for the user. - if user = User.find_by_openid_url(identity_url) - case user.status - when "pending" then - unconfirmed_login(user) - when "active", "confirmed" then - successful_login(user) - 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 - else - # Guard against not getting any extension data - sreg = {} if sreg.nil? - ax = {} if ax.nil? - - # We don't have a user registered to this OpenID, so redirect - # to the create account page with username and email filled - # in if they have been given by the OpenID provider through - # the simple registration protocol. - nickname = sreg["nickname"] || ax["http://axschema.org/namePerson/friendly"].first - email = sreg["email"] || ax["http://axschema.org/contact/email"].first - - redirect_to :controller => "user", :action => "new", :nickname => nickname, :email => email, :openid => identity_url - end - elsif result.missing? - failed_login t("user.login.openid missing provider") - elsif result.invalid? - failed_login t("user.login.openid invalid") - else - failed_login t("user.login.auth failure") - end - end - end - - ## - # verify an OpenID URL - def openid_verify(openid_url, user) - user.openid_url = openid_url - - authenticate_with_open_id(openid_expand_url(openid_url), :method => :get, :required => [:email, "http://axschema.org/contact/email"]) do |result, identity_url, sreg, ax| - if result.successful? - # Do we trust the emails this provider returns? - if openid_email_verified(identity_url) - # Guard against not getting any extension data - sreg = {} if sreg.nil? - ax = {} if ax.nil? - - # Get the verified email - verified_email = sreg["email"] || ax["http://axschema.org/contact/email"].first - end - - # We need to use the openid url passed back from the OpenID provider - # rather than the one supplied by the user, as these can be different. - # - # For example, you can simply enter yahoo.com in the login box rather - # than a user specific url. Only once it comes back from the provider - # provider do we know the unique address for the user. - user.openid_url = identity_url - yield user, verified_email - elsif result.missing? - flash.now[:error] = t "user.login.openid missing provider" - elsif result.invalid? - flash.now[:error] = t "user.login.openid invalid" - else - flash.now[:error] = t "user.login.auth failure" - end + auth_path(:provider => provider, :origin => request.path) end end @@ -621,14 +577,6 @@ 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(/https:\/\/www.google.com\/accounts\/o8\/id?(.*)/) || - openid_url.match(/https:\/\/me.yahoo.com\/(.*)/) - end - ## # process a successful login def successful_login(user) @@ -714,7 +662,11 @@ class UserController < ApplicationController user.preferred_editor = 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? || + params[:user][:auth_uid].nil? || params[:user][:auth_uid].blank? + user.auth_provider = nil + user.auth_uid = nil + end if user.save set_locale @@ -793,7 +745,9 @@ 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 ##