protect_from_forgery :with => :exception
+ rescue_from CanCan::AccessDenied, :with => :deny_access
+
before_action :fetch_body
+ around_action :better_errors_allow_inline, :if => proc { Rails.env.development? }
attr_accessor :current_user
helper_method :current_user
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]
- if self.current_user = User.authenticate(:token => session[:token])
- session[:user] = current_user.id
- end
+ session[:user] = current_user.id if self.current_user = User.authenticate(:token => session[:token])
end
rescue StandardError => ex
logger.info("Exception authorizing user: #{ex}")
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
end
def authorize(realm = "Web Password", errormessage = "Couldn't authenticate you")
- # make the @user object from any auth sources we have
+ # make the current_user object from any auth sources we have
setup_user_auth
# handle authenticate pass/fail
# 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]}")
end
end
- def preferred_languages
- @languages ||= if params[:locale]
- Locale.list(params[:locale])
- elsif current_user
- current_user.preferred_languages
- else
- Locale.list(http_accept_language.user_preferred_languages)
- end
+ def preferred_languages(reset = false)
+ @preferred_languages = nil if reset
+ @preferred_languages ||= if params[:locale]
+ Locale.list(params[:locale])
+ elsif current_user
+ current_user.preferred_languages
+ else
+ Locale.list(http_accept_language.user_preferred_languages)
+ end
end
helper_method :preferred_languages
- def set_locale
- if current_user && current_user.languages.empty? && !http_accept_language.user_preferred_languages.empty?
+ def set_locale(reset = false)
+ 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
- I18n.locale = Locale.available.preferred(preferred_languages)
+ I18n.locale = Locale.available.preferred(preferred_languages(reset))
response.headers["Vary"] = "Accept-Language"
response.headers["Content-Language"] = I18n.locale.to_s
end
##
- # ensure that there is a "this_user" instance variable
- def lookup_this_user
- unless @this_user = User.active.find_by(:display_name => params[:display_name])
- render_unknown_user params[:display_name]
- end
+ # ensure that there is a "user" instance variable
+ def lookup_user
+ render_unknown_user params[:display_name] unless @user = User.active.find_by(:display_name => params[:display_name])
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
def map_layout
append_content_security_policy_directives(
- :child_src => %w[127.0.0.1:8111 127.0.0.1:8112],
- :connect_src => %w[nominatim.openstreetmap.org overpass-api.de router.project-osrm.org valhalla.mapzen.com],
- :script_src => %w[graphhopper.com open.mapquestapi.com],
+ :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],
+ :form_action => %w[render.openstreetmap.org],
+ :script_src => %w[open.mapquestapi.com],
: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
end
+ def better_errors_allow_inline
+ yield
+ rescue StandardError
+ append_content_security_policy_directives(
+ :script_src => %w['unsafe-inline'],
+ :style_src => %w['unsafe-inline']
+ )
+
+ raise
+ end
+
+ def current_ability
+ # Add in capabilities from the oauth token if it exists and is a valid access token
+ if Authenticator.new(self, [:token]).allow?
+ Ability.new(current_user).merge(Capability.new(current_token))
+ else
+ Ability.new(current_user)
+ end
+ end
+
+ def deny_access(_exception)
+ if current_token
+ set_locale
+ report_error t("oauth.permissions.missing"), :forbidden
+ elsif current_user
+ set_locale
+ report_error t("application.permission_denied"), :forbidden
+ elsif request.get?
+ redirect_to :controller => "users", :action => "login", :referer => request.fullpath
+ else
+ head :forbidden
+ end
+ end
+
private
# extract authorisation credentials from headers, returns user = nil if none
authdata = request.env["HTTP_AUTHORIZATION"].to_s.split
end
# only basic authentication supported
- if authdata && authdata[0] == "Basic"
- user, pass = Base64.decode64(authdata[1]).split(":", 2)
- end
+ user, pass = Base64.decode64(authdata[1]).split(":", 2) if authdata && authdata[0] == "Basic"
[user, pass]
end
projects / rails.git / blobdiff