app/controllers/user_controller.rb

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