class ApplicationController < ActionController::Base
include SessionPersistence
- # check_authorization
protect_from_forgery :with => :exception
rescue_from CanCan::AccessDenied, :with => :deny_access
+ check_authorization
before_action :fetch_body
around_action :better_errors_allow_inline, :if => proc { Rails.env.development? }
session.delete(:user)
session_expires_automatically
- redirect_to :controller => "user", :action => "suspended"
+ redirect_to :controller => "users", :action => "suspended"
# don't allow access to any auth-requiring part of the site unless
# the new CTs have been seen (and accept/decline chosen).
elsif !current_user.terms_seen && flash[:skip_terms].nil?
- flash[:notice] = t "user.terms.you need to accept or decline"
+ flash[:notice] = t "users.terms.you need to accept or decline"
if params[:referer]
- redirect_to :controller => "user", :action => "terms", :referer => params[:referer]
+ redirect_to :controller => "users", :action => "terms", :referer => params[:referer]
else
- redirect_to :controller => "user", :action => "terms", :referer => request.fullpath
+ redirect_to :controller => "users", :action => "terms", :referer => request.fullpath
end
end
elsif session[:token]
def require_user
unless current_user
if request.get?
- redirect_to :controller => "user", :action => "login", :referer => request.fullpath
+ redirect_to :controller => "users", :action => "login", :referer => request.fullpath
else
head :forbidden
end
@oauth = current_user.access_token(OAUTH_KEY) if current_user && defined? OAUTH_KEY
end
- ##
- # requires the user to be logged in by the token or HTTP methods, or have an
- # OAuth token with the right capability. this method is a bit of a pain to call
- # directly, since it's cumbersome to call filters with arguments in rails. to
- # make it easier to read and write the code, there are some utility methods
- # below.
- def require_capability(cap)
- # when the current token is nil, it means the user logged in with a different
- # method, otherwise an OAuth token was used, which has to be checked.
- unless current_token.nil?
- unless current_token.read_attribute(cap)
- set_locale
- report_error t("oauth.permissions.missing"), :forbidden
- false
- end
- end
- end
-
##
# require the user to have cookies enabled in their browser
def require_cookies
end
end
- # Utility methods to make the controller filter methods easier to read and write.
- def require_allow_read_prefs
- require_capability(:allow_read_prefs)
- end
-
- def require_allow_write_prefs
- require_capability(:allow_write_prefs)
- end
-
- def require_allow_write_diary
- require_capability(:allow_write_diary)
- end
-
- def require_allow_write_api
- require_capability(:allow_write_api)
-
- if REQUIRE_TERMS_AGREED && current_user.terms_agreed.nil?
- report_error "You must accept the contributor terms before you can edit.", :forbidden
- return false
- end
- end
-
- def require_allow_read_gpx
- require_capability(:allow_read_gpx)
- end
-
- def require_allow_write_gpx
- require_capability(:allow_write_gpx)
- end
-
- def require_allow_write_notes
- require_capability(:allow_write_notes)
- end
-
- ##
- # require that the user is a moderator, or fill out a helpful error message
- # and return them to the index for the controller this is wrapped from.
- def require_moderator
- unless current_user.moderator?
- if request.get?
- flash[:error] = t("application.require_moderator.not_a_moderator")
- redirect_to :action => "index"
- else
- head :forbidden
- end
- 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
end
end
- ##
- # to be used as a before_filter *after* authorize. this checks that
- # the user is a moderator and, if not, returns a forbidden error.
- #
- # NOTE: this isn't a very good way of doing it - it duplicates logic
- # from require_moderator - but what we really need to do is a fairly
- # drastic refactoring based on :format and respond_to? but not a
- # good idea to do that in this branch.
- def authorize_moderator(errormessage = "Access restricted to moderators")
- # check user is a moderator
- unless current_user.moderator?
- render :plain => errormessage, :status => :forbidden
- false
- end
- end
-
def check_database_readable(need_api = false)
if STATUS == :database_offline || (need_api && STATUS == :api_offline)
if request.xhr?
# TODO: some sort of escaping of problem characters in the message
response.headers["Error"] = message
- if request.headers["X-Error-Format"] &&
- request.headers["X-Error-Format"].casecmp("xml").zero?
+ if request.headers["X-Error-Format"]&.casecmp("xml")&.zero?
result = OSM::API.new.get_xml_doc
result.root.name = "osmError"
result.root << (XML::Node.new("status") << "#{Rack::Utils.status_code(status)} #{Rack::Utils::HTTP_STATUS_CODES[status]}")
helper_method :preferred_languages
def set_locale(reset = false)
- if current_user && current_user.languages.empty? && !http_accept_language.user_preferred_languages.empty?
+ if current_user&.languages&.empty? && !http_accept_language.user_preferred_languages.empty?
current_user.languages = http_accept_language.user_preferred_languages
current_user.save
end
##
# render a "no such user" page
def render_unknown_user(name)
- @title = t "user.no_such_user.title"
+ @title = t "users.no_such_user.title"
@not_found_user = name
respond_to do |format|
- format.html { render :template => "user/no_such_user", :status => :not_found }
+ format.html { render :template => "users/no_such_user", :status => :not_found }
format.all { head :not_found }
end
end
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 => %w[nominatim.openstreetmap.org overpass-api.de router.project-osrm.org graphhopper.com],
+ :connect_src => [NOMINATIM_URL, OVERPASS_URL, OSRM_URL, GRAPHHOPPER_URL],
:form_action => %w[render.openstreetmap.org],
- :script_src => %w[open.mapquestapi.com],
+ :style_src => %w['unsafe-inline'],
+ :script_src => [MAPQUEST_DIRECTIONS_URL],
:img_src => %w[developer.mapquest.com]
)
def preferred_editor
editor = if params[:editor]
params[:editor]
- elsif current_user && current_user.preferred_editor
+ elsif current_user&.preferred_editor
current_user.preferred_editor
else
DEFAULT_EDITOR
end
def current_ability
- Ability.new(current_user, current_token)
+ # 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
end
def deny_access(exception)
- if current_user
- raise "Access denied on #{exception.action} #{exception.subject.inspect}"
- # ...
+ if @api_deny_access_handling
+ api_deny_access(exception)
+ else
+ web_deny_access(exception)
+ end
+ end
+
+ def web_deny_access(_exception)
+ if current_token
+ set_locale
+ report_error t("oauth.permissions.missing"), :forbidden
+ elsif current_user
+ set_locale
+ respond_to do |format|
+ format.html { redirect_to :controller => "errors", :action => "forbidden" }
+ format.any { report_error t("application.permission_denied"), :forbidden }
+ end
+ elsif request.get?
+ respond_to do |format|
+ format.html { redirect_to :controller => "users", :action => "login", :referer => request.fullpath }
+ format.any { head :forbidden }
+ end
+ else
+ head :forbidden
+ 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
- require_user
+ 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
projects / rails.git / blobdiff