X-Git-Url: https://git.openstreetmap.org./rails.git/blobdiff_plain/a7628a942bf953ef338f9b8911f8174c3740945b..0db30c611a99d62381217d86c5a0bd9d104efb42:/app/controllers/application_controller.rb?ds=sidebyside diff --git a/app/controllers/application_controller.rb b/app/controllers/application_controller.rb index bc1fd488d..bee5e8169 100644 --- a/app/controllers/application_controller.rb +++ b/app/controllers/application_controller.rb @@ -12,6 +12,8 @@ class ApplicationController < ActionController::Base attr_accessor :current_user helper_method :current_user + private + def authorize_web if session[:user] self.current_user = User.where(:id => session[:user]).where("status IN ('active', 'confirmed', 'suspended')").first @@ -35,8 +37,8 @@ class ApplicationController < ActionController::Base elsif session[:token] session[:user] = current_user.id if self.current_user = User.authenticate(:token => session[:token]) end - rescue StandardError => ex - logger.info("Exception authorizing user: #{ex}") + rescue StandardError => e + logger.info("Exception authorizing user: #{e}") reset_session self.current_user = nil end @@ -52,7 +54,7 @@ class ApplicationController < ActionController::Base end def require_oauth - @oauth = current_user.access_token(OAUTH_KEY) if current_user && defined? OAUTH_KEY + @oauth = current_user.access_token(Settings.oauth_key) if current_user && Settings.key?(:oauth_key) end ## @@ -71,62 +73,8 @@ class ApplicationController < ActionController::Base end end - ## - # sets up the current_user for use by other methods. this is mostly called - # from the authorize method, but can be called elsewhere if authorisation - # is optional. - def setup_user_auth - # try and setup using OAuth - unless Authenticator.new(self, [:token]).allow? - username, passwd = get_auth_data # parse from headers - # authenticate per-scheme - self.current_user = if username.nil? - nil # no authentication provided - perhaps first connect (client should retry after 401) - elsif username == "token" - User.authenticate(:token => passwd) # preferred - random token for user from db, passed in basic auth - else - User.authenticate(:username => username, :password => passwd) # basic auth - end - end - - # have we identified the user? - if current_user - # check if the user has been banned - user_block = current_user.blocks.active.take - unless user_block.nil? - set_locale - if user_block.zero_hour? - report_error t("application.setup_user_auth.blocked_zero_hour"), :forbidden - else - report_error t("application.setup_user_auth.blocked"), :forbidden - end - end - - # if the user hasn't seen the contributor terms then don't - # allow editing - they have to go to the web site and see - # (but can decline) the CTs to continue. - if REQUIRE_TERMS_SEEN && !current_user.terms_seen && flash[:skip_terms].nil? - set_locale - report_error t("application.setup_user_auth.need_to_see_terms"), :forbidden - end - end - end - - def authorize(realm = "Web Password", errormessage = "Couldn't authenticate you") - # make the current_user object from any auth sources we have - setup_user_auth - - # handle authenticate pass/fail - unless current_user - # no auth, the user does not exist or the password was wrong - response.headers["WWW-Authenticate"] = "Basic realm=\"#{realm}\"" - render :plain => errormessage, :status => :unauthorized - return false - end - end - def check_database_readable(need_api = false) - if STATUS == :database_offline || (need_api && STATUS == :api_offline) + if Settings.status == "database_offline" || (need_api && Settings.status == "api_offline") if request.xhr? report_error "Database offline for maintenance", :service_unavailable else @@ -136,8 +84,8 @@ class ApplicationController < ActionController::Base end def check_database_writable(need_api = false) - if STATUS == :database_offline || STATUS == :database_readonly || - (need_api && (STATUS == :api_offline || STATUS == :api_readonly)) + if Settings.status == "database_offline" || Settings.status == "database_readonly" || + (need_api && (Settings.status == "api_offline" || Settings.status == "api_readonly")) if request.xhr? report_error "Database offline for maintenance", :service_unavailable else @@ -147,47 +95,41 @@ class ApplicationController < ActionController::Base end def check_api_readable - if api_status == :offline + if api_status == "offline" report_error "Database offline for maintenance", :service_unavailable false end end def check_api_writable - unless api_status == :online + unless api_status == "online" report_error "Database offline for maintenance", :service_unavailable false end end def database_status - if STATUS == :database_offline - :offline - elsif STATUS == :database_readonly - :readonly + if Settings.status == "database_offline" + "offline" + elsif Settings.status == "database_readonly" + "readonly" else - :online + "online" end end def api_status status = database_status - if status == :online - if STATUS == :api_offline - status = :offline - elsif STATUS == :api_readonly - status = :readonly + if status == "online" + if Settings.status == "api_offline" + status = "offline" + elsif Settings.status == "api_readonly" + status = "readonly" end end status end - def gpx_status - status = database_status - status = :offline if status == :online && STATUS == :gpx_offline - status - end - def require_public_data unless current_user.data_public? report_error "You must make your edits public to upload new data", :forbidden @@ -243,22 +185,22 @@ class ApplicationController < ActionController::Base def api_call_handle_error yield - rescue ActiveRecord::RecordNotFound => ex + rescue ActiveRecord::RecordNotFound => e head :not_found - rescue LibXML::XML::Error, ArgumentError => ex - report_error ex.message, :bad_request - rescue ActiveRecord::RecordInvalid => ex - message = "#{ex.record.class} #{ex.record.id}: " - ex.record.errors.each { |attr, msg| message << "#{attr}: #{msg} (#{ex.record[attr].inspect})" } + rescue LibXML::XML::Error, ArgumentError => e + report_error e.message, :bad_request + rescue ActiveRecord::RecordInvalid => e + message = "#{e.record.class} #{e.record.id}: " + e.record.errors.each { |attr, msg| message << "#{attr}: #{msg} (#{e.record[attr].inspect})" } report_error message, :bad_request - rescue OSM::APIError => ex - report_error ex.message, ex.status - rescue AbstractController::ActionNotFound => ex + rescue OSM::APIError => e + report_error e.message, e.status + rescue AbstractController::ActionNotFound => e raise - rescue StandardError => ex - logger.info("API threw unexpected #{ex.class} exception: #{ex.message}") - ex.backtrace.each { |l| logger.info(l) } - report_error "#{ex.class}: #{ex.message}", :internal_server_error + rescue StandardError => e + logger.info("API threw unexpected #{e.class} exception: #{e.message}") + e.backtrace.each { |l| logger.info(l) } + report_error "#{e.class}: #{e.message}", :internal_server_error end ## @@ -272,7 +214,7 @@ class ApplicationController < ActionController::Base ## # wrap an api call in a timeout def api_call_timeout - OSM::Timer.timeout(API_TIMEOUT, Timeout::Error) do + OSM::Timer.timeout(Settings.api_timeout, Timeout::Error) do yield end rescue Timeout::Error @@ -282,14 +224,14 @@ class ApplicationController < ActionController::Base ## # wrap a web page in a timeout def web_timeout - OSM::Timer.timeout(WEB_TIMEOUT, Timeout::Error) do + OSM::Timer.timeout(Settings.web_timeout, Timeout::Error) do yield end - rescue ActionView::Template::Error => ex - ex = ex.cause + rescue ActionView::Template::Error => e + e = e.cause - if ex.is_a?(Timeout::Error) || - (ex.is_a?(ActiveRecord::StatementInvalid) && ex.message =~ /execution expired/) + if e.is_a?(Timeout::Error) || + (e.is_a?(ActiveRecord::StatementInvalid) && e.message =~ /execution expired/) render :action => "timeout" else raise @@ -333,16 +275,14 @@ class ApplicationController < ActionController::Base append_content_security_policy_directives( :child_src => %w[http://127.0.0.1:8111 https://127.0.0.1:8112], :frame_src => %w[http://127.0.0.1:8111 https://127.0.0.1:8112], - :connect_src => [NOMINATIM_URL, OVERPASS_URL, OSRM_URL, GRAPHHOPPER_URL], + :connect_src => [Settings.nominatim_url, Settings.overpass_url, Settings.fossgis_osrm_url, Settings.graphhopper_url], :form_action => %w[render.openstreetmap.org], - :style_src => %w['unsafe-inline'], - :script_src => [MAPQUEST_DIRECTIONS_URL], - :img_src => %w[developer.mapquest.com] + :style_src => %w['unsafe-inline'] ) - if STATUS == :database_offline || STATUS == :api_offline + if Settings.status == "database_offline" || Settings.status == "api_offline" flash.now[:warning] = t("layouts.osm_offline") - elsif STATUS == :database_readonly || STATUS == :api_readonly + elsif Settings.status == "database_readonly" || Settings.status == "api_readonly" flash.now[:warning] = t("layouts.osm_read_only") end @@ -359,7 +299,7 @@ class ApplicationController < ActionController::Base elsif current_user&.preferred_editor current_user.preferred_editor else - DEFAULT_EDITOR + Settings.default_editor end editor @@ -368,9 +308,9 @@ class ApplicationController < ActionController::Base helper_method :preferred_editor def update_totp - if defined?(TOTP_KEY) + if Settings.key?(:totp_key) cookies["_osm_totp_token"] = { - :value => ROTP::TOTP.new(TOTP_KEY, :interval => 3600).now, + :value => ROTP::TOTP.new(Settings.totp_key, :interval => 3600).now, :domain => "openstreetmap.org", :expires => 1.hour.from_now } @@ -389,23 +329,10 @@ class ApplicationController < ActionController::Base end def current_ability - # Use capabilities from the oauth token if it exists and is a valid access token - if Authenticator.new(self, [:token]).allow? - Ability.new(nil).merge(Capability.new(current_token)) - else - Ability.new(current_user) - end + Ability.new(current_user) end - def deny_access(exception) - if @api_deny_access_handling - api_deny_access(exception) - else - web_deny_access(exception) - end - end - - def web_deny_access(_exception) + def deny_access(_exception) if current_token set_locale report_error t("oauth.permissions.missing"), :forbidden @@ -425,28 +352,6 @@ class ApplicationController < ActionController::Base end end - def api_deny_access(_exception) - if current_token - set_locale - report_error t("oauth.permissions.missing"), :forbidden - elsif current_user - head :forbidden - else - realm = "Web Password" - errormessage = "Couldn't authenticate you" - response.headers["WWW-Authenticate"] = "Basic realm=\"#{realm}\"" - render :plain => errormessage, :status => :unauthorized - end - end - - attr_accessor :api_access_handling - - def api_deny_access_handler - @api_deny_access_handling = true - end - - private - # extract authorisation credentials from headers, returns user = nil if none def get_auth_data if request.env.key? "X-HTTP_AUTHORIZATION" # where mod_rewrite might have put it