def process_request(self, request):
# First try to serve the static files (on /static/ and on /)
# which is relatively fast as files are stored in a self.files dict
if self.autorefresh: # debug mode
static_file = self.find_file(request.path_info)
else: # from the collected static files
static_file = self.files.get(request.path_info)
if static_file is not None:
return self.serve(static_file, request)
else:
# if no file was found there are two options:
# 1) the file is in one of the Django urls
# (e.g. a template or the Djangoadmin)
# so we'll let Django handle this
# (just return and let the normal middleware take its course)
urlconf = getattr(request, 'urlconf', None)
if is_valid_path(request.path_info, urlconf):
return
if (settings.APPEND_SLASH and not request.path_info.endswith('/')
and is_valid_path('%s/' % request.path_info, urlconf)):
return
# 2) the url is handled by frontend routing
# redirect all unknown files to the SPA root
try:
return self.serve(self.spa_root, request)
except AttributeError: # no SPA page stored yet
self.spa_root = self.find_file('/')
if self.spa_root:
return self.serve(self.spa_root, request)
def should_redirect_with_slash(self, request):
if request.path_info.endswith('/'):
return False
urlconf = getattr(request, 'urlconf', None)
return (not is_valid_path(request.path_info, urlconf)
and is_valid_path('%s/' % request.path_info, urlconf))
def process_response(self, request, response):
language = translation.get_language()
language_from_path = translation.get_language_from_path(request.path_info)
if response.status_code == 404 and not language_from_path and self.is_language_prefix_patterns_used:
urlconf = getattr(request, "urlconf", None)
language_path = "/%s%s" % (language, request.path_info)
path_valid = is_valid_path(language_path, urlconf)
path_needs_slash = not path_valid and (
settings.APPEND_SLASH
and not language_path.endswith("/")
and is_valid_path("%s/" % language_path, urlconf)
)
if path_valid or path_needs_slash:
script_prefix = get_script_prefix()
# Insert language after the script prefix and before the
# rest of the URL
language_url = request.get_full_path(force_append_slash=path_needs_slash).replace(
script_prefix, "%s%s/" % (script_prefix, language), 1
)
return self.response_redirect_class(language_url)
if not (self.is_language_prefix_patterns_used and language_from_path):
patch_vary_headers(response, ("Accept-Language",))
if "Content-Language" not in response:
response["Content-Language"] = language
return response
def process_exception(self, request, exception):
'''Rewrite the URL based on settings.APPEND_SLASH and the urlconf of the current page.'''
if isinstance(exception, Http404):
if settings.APPEND_SLASH and not request.path_info.endswith('/'):
page = request.pages.current
if page:
script_name = page.get_absolute_url()[:-1]
path_info = request.path[len(script_name):]
urlconf = getattr(page.content,
'urlconf', None) if hasattr(
page, 'content') else None
# Check if the URL with a slash appended is resolved by the current page's urlconf
if (is_valid_path(path_info, urlconf)
or not is_valid_path(f'{path_info}/', urlconf)):
# Check if the URL with a slash appended resolves for something other than a page
match = resolve(f'{path_info}/',
getattr(request, 'urlconf', None))
if getattr(match.func, 'view_class',
None) is PageDispatcherView:
# Couldn't find any view that would be resolved for this URL
# No point redirecting to a URL that will 404
return None
new_path = request.get_full_path(force_append_slash=True)
# Prevent construction of scheme relative urls.
new_path = escape_leading_slashes(new_path)
return HttpResponsePermanentRedirect(new_path)
def process_response(self, request, response):
language = translation.get_language()
language_from_path = translation.get_language_from_path(request.path_info)
urlconf = getattr(request, 'urlconf', settings.ROOT_URLCONF)
i18n_patterns_used, prefixed_default_language = is_language_prefix_patterns_used(urlconf)
if response.status_code == 404 and not language_from_path and i18n_patterns_used:
language_path = '/%s%s' % (language, request.path_info)
path_valid = is_valid_path(language_path, urlconf)
path_needs_slash = (
not path_valid and (
settings.APPEND_SLASH and not language_path.endswith('/')
and is_valid_path('%s/' % language_path, urlconf)
)
)
if path_valid or path_needs_slash:
script_prefix = get_script_prefix()
# Insert language after the script prefix and before the
# rest of the URL
language_url = request.get_full_path(force_append_slash=path_needs_slash).replace(
script_prefix,
'%s%s/' % (script_prefix, language),
1
)
return self.response_redirect_class(language_url)
if not (i18n_patterns_used and language_from_path):
patch_vary_headers(response, ('Accept-Language',))
if 'Content-Language' not in response:
response['Content-Language'] = language
return response
def process_request(self, request):
old_url = request.build_absolute_uri()
# match any / followed by ? (query string present)
# OR match / at the end of the string (no query string)
trailing_slash_regexp = r'(\/(?=\?))|(\/$)'
new_url = old_url
if getattr(settings, 'APPEND_SLASH') and getattr(settings, 'REMOVE_SLASH'):
raise ImproperlyConfigured("APPEND_SLASH and REMOVE_SLASH may not both be True.")
# Remove slash if REMOVE_SLASH is set and the URL has a trailing slash
# and there is no pattern for the current path
if getattr(settings, 'REMOVE_SLASH', False) and re.search(trailing_slash_regexp, old_url):
urlconf = getattr(request, 'urlconf', None)
if (not is_valid_path(request.path_info, urlconf)) and is_valid_path(request.path_info[:-1], urlconf):
new_url = re.sub(trailing_slash_regexp, '', old_url)
if settings.DEBUG and request.method == 'POST':
raise RuntimeError((""
"You called this URL via POST, but the URL ends in a "
"slash and you have REMOVE_SLASH set. Django can't "
"redirect to the non-slash URL while maintaining POST "
"data. Change your form to point to %s (without a "
"trailing slash), or set REMOVE_SLASH=False in your "
"Django settings.") % (new_url))
if new_url == old_url:
# No redirects required.
return
return HttpResponsePermanentRedirect(new_url)
def process_response(self, request, response):
language = translation.get_language()
language_from_path = translation.get_language_from_path(
request.path_info)
urlconf = getattr(request, 'urlconf', settings.ROOT_URLCONF)
i18n_patterns_used, prefixed_default_language = is_language_prefix_patterns_used(
urlconf)
if (response.status_code == 404 and not language_from_path
and i18n_patterns_used and prefixed_default_language):
# Maybe the language code is missing in the URL? Try adding the
# language prefix and redirecting to that URL.
language_path = '/%s%s' % (language, request.path_info)
path_valid = is_valid_path(language_path, urlconf)
path_needs_slash = (
not path_valid
and (settings.APPEND_SLASH and not language_path.endswith('/')
and is_valid_path('%s/' % language_path, urlconf)))
if path_valid or path_needs_slash:
script_prefix = get_script_prefix()
# Insert language after the script prefix and before the
# rest of the URL
language_url = request.get_full_path(
force_append_slash=path_needs_slash).replace(
script_prefix, '%s%s/' % (script_prefix, language), 1)
return self.response_redirect_class(language_url)
if not (i18n_patterns_used and language_from_path):
patch_vary_headers(response, ('Accept-Language', ))
if 'Content-Language' not in response:
response['Content-Language'] = language
return response
def set_language(request):
"""
Since this view changes how the user will see the rest of the site, it must
only be accessed as a POST request. If called as a GET request, it will
error.
"""
lang_code = request.POST.get(LANGUAGE_QUERY_PARAMETER)
next_url = urlsplit(request.POST.get("next")) if request.POST.get("next") else None
if lang_code and check_for_language(lang_code):
if next_url and is_valid_path(next_url.path):
# If it is a recognized Kolibri path, then translate it to the new language and return it.
next_path = urlunsplit(
(
next_url[0],
next_url[1],
translate_url(next_url[2], lang_code),
next_url[3],
next_url[4],
)
)
else:
next_path = translate_url(reverse("kolibri:core:redirect_user"), lang_code)
response = HttpResponse(next_path)
if hasattr(request, "session"):
request.session[LANGUAGE_SESSION_KEY] = lang_code
# Always set cookie
response.set_cookie(
settings.LANGUAGE_COOKIE_NAME,
lang_code,
max_age=settings.LANGUAGE_COOKIE_AGE,
path=settings.LANGUAGE_COOKIE_PATH,
domain=settings.LANGUAGE_COOKIE_DOMAIN,
)
else:
lang_code = (
get_device_language()
or get_accept_headers_language(request)
or get_settings_language()
)
if next_url and is_valid_path(next_url.path):
# If it is a recognized Kolibri path, then translate it using the default language code for this device
next_path = urlunsplit(
(
next_url[0],
next_url[1],
translate_url(next_url[2], lang_code),
next_url[3],
next_url[4],
)
)
else:
next_path = translate_url(reverse("kolibri:core:redirect_user"), lang_code)
response = HttpResponse(next_path)
if hasattr(request, "session"):
request.session.pop(LANGUAGE_SESSION_KEY, "")
response.delete_cookie(settings.LANGUAGE_COOKIE_NAME)
return response
def should_redirect_with_slash(self, request):
"""
Return True if settings.APPEND_SLASH is True and appending a slash to
the request path turns an invalid path into a valid one.
"""
if settings.APPEND_SLASH and not request.get_full_path().endswith("/"):
urlconf = getattr(request, "urlconf", None)
return not is_valid_path(request.path_info, urlconf) and is_valid_path("%s/" % request.path_info, urlconf)
return False
def should_redirect_with_slash(self, request):
path = request.path_info
# Avoid redirecting non GET requests, these would fail anyway
if path.endswith("/") or request.method != "GET":
return False
urlconf = getattr(request, "urlconf", None)
slash_path = f"{path}/"
return not is_valid_path(path, urlconf) and is_valid_path(
slash_path, urlconf)
def should_redirect_with_slash(self, request):
"""
Return True if settings.APPEND_SLASH is True and appending a slash to
the request path turns an invalid path into a valid one.
"""
if settings.APPEND_SLASH and not request.path_info.endswith('/'):
urlconf = getattr(request, 'urlconf', None)
return (not is_valid_path(request.path_info, urlconf)
and is_valid_path('%s/' % request.path_info, urlconf))
return False
def should_redirect_with_slash(self, request):
"""
Return True if settings.APPEND_SLASH is False and removing a slash from
the request path turns an invalid path into a valid one.
"""
if not settings.APPEND_SLASH and request.path_info.endswith('/'):
urlconf = getattr(request, 'urlconf', None)
return (not is_valid_path(request.path_info, urlconf)
and is_valid_path(request.path_info[:-1], urlconf))
return False
def process_response(self, request, response):
if (response.status_code == 404 and request.path_info.endswith('/')
and not is_valid_path(request.path_info)
and is_valid_path(request.path_info[:-1])):
# Use request.path because we munged app/locale in path_info.
newurl = request.path[:-1]
if request.GET:
with safe_query_string(request):
newurl += '?' + request.META['QUERY_STRING']
return HttpResponsePermanentRedirect(newurl)
return response
def should_redirect_with_slash(self, request):
"""
Return True if settings.APPEND_SLASH is False and removing a slash from
the request path turns an invalid path into a valid one.
"""
if not settings.APPEND_SLASH and request.path_info.endswith('/'):
urlconf = getattr(request, 'urlconf', None)
return (
not is_valid_path(request.path_info, urlconf) and
is_valid_path(request.path_info[:-1], urlconf)
)
return False
def should_redirect_with_slash(self, request):
"""
Return True if settings.APPEND_SLASH is True and appending a slash to
the request path turns an invalid path into a valid one.
"""
if settings.APPEND_SLASH and not request.path_info.endswith('/'):
urlconf = getattr(request, 'urlconf', None)
return (
not is_valid_path(request.path_info, urlconf) and
is_valid_path('%s/' % request.path_info, urlconf)
)
return False
def __call__(self, request):
# First get the language code, and whether this was calculated from the path
# i.e. was this a language-prefixed URL.
language, language_from_path = get_language_from_request_and_is_from_path(
request)
# If this URL has been resolved to a view, and the view is not on a language prefixed
# URL, then the function above will return None for the language code to indicate that
# no translation is necessary.
if language is not None:
# Only activate translation if there is a language code returned.
translation.activate(language)
request.LANGUAGE_CODE = translation.get_language()
response = self.get_response(request)
if language is not None:
language = translation.get_language()
if response.status_code == 404 and not language_from_path:
# Maybe the language code is missing in the URL? Try adding the
# language prefix and redirecting to that URL.
# First get any global prefix that is being used.
script_prefix = OPTIONS["Deployment"]["URL_PATH_PREFIX"]
# Replace the global prefix with the global prefix and the language prefix.
language_path = request.path_info.replace(
script_prefix, "%s%s/" % (script_prefix, language), 1)
# Get the urlconf from the request, default to the global settings ROOT_URLCONF
urlconf = getattr(request, "urlconf", settings.ROOT_URLCONF)
# Check if this is a valid path
path_valid = is_valid_path(language_path, urlconf)
# Check if the path is only invalid because it is missing a trailing slash
path_needs_slash = not path_valid and (
settings.APPEND_SLASH and not language_path.endswith("/")
and is_valid_path("%s/" % language_path, urlconf))
# If the constructed path is valid, or it would be valid with a trailing slash
# then redirect to the prefixed path, with a trailing slash added if needed.
if path_valid or path_needs_slash:
# Insert language after the script prefix and before the
# rest of the URL
language_url = request.get_full_path(
force_append_slash=path_needs_slash).replace(
script_prefix, "%s%s/" % (script_prefix, language),
1)
return HttpResponseRedirect(language_url)
# Add a content language header to the response if not already present.
if "Content-Language" not in response:
response["Content-Language"] = language
return response
def should_redirect_with_slash(self, request):
"""
Return True if settings.APPEND_SLASH is True and appending a slash to
the request path turns an invalid path into a valid one.
"""
if settings.APPEND_SLASH and not request.path_info.endswith("/"):
urlconf = getattr(request, "urlconf", None)
if not is_valid_path(request.path_info, urlconf):
match = is_valid_path("%s/" % request.path_info, urlconf)
if match:
view = match.func
return getattr(view, "should_append_slash", True)
return False
def should_redirect_with_slash(self, request):
path = request.path_info
# Avoid redirecting non GET requests, these would fail anyway due to
# missing parameters.
# Redirecting on API removes authentication headers in many cases,
# so avoid that as well.
if (path.endswith("/") or request.method != "GET"
or path.startswith(f"{settings.URL_PREFIX}/api")):
return False
urlconf = getattr(request, "urlconf", None)
slash_path = f"{path}/"
return not is_valid_path(path, urlconf) and is_valid_path(
slash_path, urlconf)
def process_response(self, request, response):
if (response.status_code == 404 and
request.path_info.endswith('/') and
not is_valid_path(request.path_info) and
is_valid_path(request.path_info[:-1])):
# Use request.path because we munged app/locale in path_info.
newurl = request.path[:-1]
if request.GET:
with safe_query_string(request):
newurl += '?' + request.META.get('QUERY_STRING', '')
return HttpResponsePermanentRedirect(newurl)
else:
return response
def _calculate_user_urlconf(self, request, user_settings):
"""
:param request:
:param user_settings:
:return:
"""
cache = caches[getattr(settings, 'HACS_CACHE_SETTING_NAME', HACS_CACHE_SETTING_NAME)]
if user_settings['urlconf'] and user_settings['has_own_rules']:
return user_settings['urlconf']
elif user_settings['groups']:
if user_settings['urlconf']:
# Already inherited from group, let's check if is usable
# otherwise will be trying from other groups
if is_valid_path(request.path_info, user_settings['urlconf']) or \
(settings.APPEND_SLASH and not request.get_full_path().endswith('/') and
is_valid_path(request.path_info, "%s/" % user_settings['urlconf'])):
return user_settings['urlconf']
_temp = None
for group_cache_key, group_natural_key in user_settings['groups']:
if not cache.get(group_cache_key, {}).get('urlconf', None):
continue
if cache.get(group_cache_key, {}).get('urlconf') == user_settings['urlconf']:
# already failed, so need to go further
continue
if is_valid_path(request.path_info, cache.get(group_cache_key).get('urlconf')) or \
(settings.APPEND_SLASH and not request.get_full_path().endswith('/') and
is_valid_path(request.path_info, "%s/" % cache.get(group_cache_key).get('urlconf'))):
user_settings.update({
'urlconf': cache.get(group_cache_key).get('urlconf'),
'allowed_http_methods': cache.get(group_cache_key).get('allowed_http_methods'),
'blacklisted_uri': cache.get(group_cache_key).get('blacklisted_uri'),
'whitelisted_uri': cache.get(group_cache_key).get('whitelisted_uri'),
})
# Update User's cache
cache.set(get_user_key(request), user_settings)
_temp = cache.get(group_cache_key).get('urlconf')
break
else:
continue
# @TODO: need some decision what should do if result is None
return _temp
else:
return None
def test_urls():
try:
from django.urls import is_valid_path
except ImportError:
from django.core.urlresolvers import is_valid_path
assert settings.ROOT_URLCONF == "pytest_django_test.urls_overridden"
assert is_valid_path("/overridden_url/")
def middleware(request):
# TODO: DISCLAIMER!!! THIS IS A TEMPORARY HACK TO ESCAPE FROM CURRENT "DDOS ATTACK"
# WE MUST IMPLEMENT RATE LIMIT CONTROL IN NGINX OR CLOUDFARE SO WE DON'T HAVE TO RELY ON DJANGO TO DO THAT
agent = request.META.get("HTTP_USER_AGENT", "").lower().strip()
if not agent or agent in settings.BLOCKED_WEB_AGENTS:
_raise_exception(request)
path = request.path
if settings.APPEND_SLASH and not path.endswith("/"):
path += "/"
if is_valid_path(path):
match = resolve(path)
if getattr(match.func, RATELIMITED_VIEW_ATTR, None):
# based in ratelimit decorator
# https://github.com/jsocol/django-ratelimit/blob/main/ratelimit/decorators.py#L13
if settings.RATELIMIT_ENABLE and is_ratelimited(
request=request,
group=None,
fn=match.func,
key=ratelimit_key,
rate=settings.RATELIMIT_RATE,
method=ALL,
increment=True,
):
_raise_exception(request)
return get_response(request)
def test_urls():
try:
from django.urls import is_valid_path
except ImportError:
from django.core.urlresolvers import is_valid_path
assert settings.ROOT_URLCONF == 'pytest_django_test.urls_overridden'
assert is_valid_path('/overridden_url/')
def test_urls():
try:
from django.urls import is_valid_path
except ImportError:
from django.core.urlresolvers import is_valid_path
assert settings.ROOT_URLCONF == 'django-rest-framework-api.urls'
assert is_valid_path('/')
def set_language(request):
"""
Since this view changes how the user will see the rest of the site, it must
only be accessed as a POST request. If called as a GET request, it will
error.
"""
payload = json.loads(request.body)
lang_code = payload.get(LANGUAGE_QUERY_PARAMETER)
next_url = urlsplit(payload.get("next")) if payload.get("next") else None
if lang_code and lang_code in SUPPORTED_LANGUAGES:
if next_url and is_valid_path(next_url.path):
# If it is a recognized path, then translate it to the new language and return it.
next_path = urlunsplit(
(
next_url[0],
next_url[1],
translate_url(next_url[2], lang_code),
next_url[3],
next_url[4],
)
)
else:
# Just redirect to the base URL w/ the lang_code
next_path = translate_url(reverse('base'), lang_code)
response = HttpResponse(next_path)
if hasattr(request, "session"):
request.session[LANGUAGE_SESSION_KEY] = lang_code
else:
lang_code = get_language()
if next_url and is_valid_path(next_url.path):
# If it is a recognized path, then translate it using the default language code for this device
next_path = urlunsplit(
(
next_url[0],
next_url[1],
translate_url(next_url[2], lang_code),
next_url[3],
next_url[4],
)
)
else:
# Just redirect to the base URL w/ the lang_code, likely the default language
next_path = translate_url(reverse('base'), lang_code)
response = HttpResponse(next_path)
if hasattr(request, "session"):
request.session.pop(LANGUAGE_SESSION_KEY, "")
return response
def process_response(self, request, response):
language = translation.get_language()
language_from_path = translation.get_language_from_path(request.path_info)
urlconf = getattr(request, "urlconf", settings.ROOT_URLCONF)
(
i18n_patterns_used,
prefixed_default_language,
) = is_language_prefix_patterns_used(urlconf)
if (
response.status_code == 404
and not language_from_path
and i18n_patterns_used
and prefixed_default_language
):
# Maybe the language code is missing in the URL? Try adding the
# language prefix and redirecting to that URL.
language_path = "/%s%s" % (language, request.path_info)
path_valid = is_valid_path(language_path, urlconf)
path_needs_slash = not path_valid and (
settings.APPEND_SLASH
and not language_path.endswith("/")
and is_valid_path("%s/" % language_path, urlconf)
)
if path_valid or path_needs_slash:
script_prefix = get_script_prefix()
# Insert language after the script prefix and before the
# rest of the URL
language_url = request.get_full_path(
force_append_slash=path_needs_slash
).replace(script_prefix, "%s%s/" % (script_prefix, language), 1)
# Redirect to the language-specific URL as detected by
# get_language_from_request(). HTTP caches may cache this
# redirect, so add the Vary header.
redirect = self.response_redirect_class(language_url)
patch_vary_headers(redirect, ("Accept-Language", "Cookie"))
return redirect
if not (i18n_patterns_used and language_from_path):
patch_vary_headers(response, ("Accept-Language",))
response.headers.setdefault("Content-Language", language)
return response
def post(self, request, *args, **kwargs):
view = self.get(request)
# 登录成功，view 的类型是 HttpResponseRedirect
# 帐号登录方式的用户名肯定是存在了，不然也不会成功登录，所以这里不用对用户是否存在做判断
if isinstance(view, HttpResponseRedirect):
# 如果当前就是登录页，那么就不要跳到登录页
url_path = request.path if is_valid_path(request.path) is True and request.path != reverse(
'xadmin:login') else reverse(settings.SITE_NAME)
return HttpResponseRedirect(url_path)
return view
def get_redirect_url(self, *args, **kwargs):
"""
重定向
:param args:
:param kwargs:
:return:
"""
if isinstance(self.request.user, AnonymousUser):
return reverse('xadmin:login')
self.url = self.request.user.home_page if is_valid_path(self.request.user.home_page) is True else self.url
return super().get_redirect_url(*args, **kwargs)
def process_response(self, request, response):
language_from_path = get_language_from_path(request.path_info)
if response.status_code == 404 and language_from_path == settings.LANGUAGE_CODE:
urlconf = getattr(request, 'urlconf', None)
new_path = self.strip_language(request.path_info)
path_valid = is_valid_path(new_path, urlconf)
if (not path_valid and settings.APPEND_SLASH
and not new_path.endswith('/')):
path_valid = is_valid_path("%s/" % new_path, urlconf)
if path_valid:
script_prefix = get_script_prefix()
old_path = get_script_prefix() + language_from_path + '/'
language_url = "%s://%s%s" % (
request.scheme,
request.get_host(),
# replace the old path which contains language code
# to the script prefix without language code
request.get_full_path().replace(old_path, script_prefix,
1))
return self.response_redirect_class(language_url)
return response
def middleware(request):
path = request.get_full_path()
if '//' in path:
path = re.sub(r'(/)\1+', r'\1', path)
return redirect(path, permanent=True)
if not settings.APPEND_SLASH:
return get_response(request)
is_url_exempt = any(
url.match(path.lstrip('/'))
for url in REDIRECTS_EXTRA_SLASHES_REDIRECT_EXEMPT_URLS)
if is_url_exempt:
return get_response(request)
is_url_to_redirect = all(
[not request.GET,
len(path) > 1, not str(path).endswith('/')])
if is_url_to_redirect:
urlconf = getattr(request, 'urlconf', None)
# if path without slash is not valid - append slash
if not is_valid_path(path, urlconf):
path += '/'
if is_valid_path(path, urlconf):
return redirect(path, permanent=True)
if path.endswith('?'):
path = path[:-1]
return redirect(path, permanent=True)
return get_response(request)
def __call__(self, request):
response = self.get_response(request)
if (response.status_code == 404
and not request.path_info.startswith("/u/")
and not is_valid_path(request.path_info)
and User.objects.filter(username__iexact=request.path_info[1:].
strip("/")).exists()
and request.user.is_authenticated
and request.user.userprofile.is_vouched):
newurl = "/u" + request.path_info
if request.GET:
with safe_query_string(request):
newurl += "?" + request.META["QUERY_STRING"]
return HttpResponseRedirect(newurl)
return response
def process_response(self, request, response):
language = translation.get_language()
if (response.status_code == 404 and
not translation.get_language_from_path(request.path_info)
and self.is_language_prefix_patterns_used()):
urlconf = getattr(request, 'urlconf', None)
language_path = '/%s%s' % (language, request.path_info)
if settings.APPEND_SLASH and not language_path.endswith('/'):
language_path = language_path + '/'
if is_valid_path(language_path, urlconf):
language_url = "%s://%s/%s%s" % (
request.is_secure() and 'https' or 'http',
request.get_host(), language, request.get_full_path())
return HttpResponsePermanentRedirect(language_url)
translation.deactivate()
patch_vary_headers(response, ('Accept-Language',))
if 'Content-Language' not in response:
response['Content-Language'] = language
return response
def process_request(self, request):
if settings.APPEND_SLASH:
return
if '/admin/' in request.path:
return
if '/utils/login_as' in request.path:
return
if '/sandbox/' in request.path:
return
if '/__debug__/' in request.path:
return
if request.path_info.endswith('/'):
urlconf = getattr(request, 'urlconf', None)
if is_valid_path(request.path_info[:-1], urlconf):
new_path = request.path_info[:-1]
if request.method == 'GET':
if request.META['QUERY_STRING']:
new_path += '?' + request.META['QUERY_STRING']
if settings.DEBUG and request.method in ('POST', 'PUT', 'PATCH'):
raise RuntimeError(
"You called this URL via %(method)s, but the URL doesn't end "
"in a slash and you have APPEND_SLASH set. Django can't "
"redirect to the slash URL while maintaining %(method)s data. "
"Change your form to point to %(url)s (note the trailing "
"slash), or set APPEND_SLASH=False in your Django settings." % {
'method': request.method,
'url': request.get_host() + new_path,
}
)
return self.response_redirect_class(new_path)
def test_urls():
assert settings.ROOT_URLCONF == "septic_check.urls"
assert is_valid_path("/sewage_info/")
def test_urls():
assert settings.ROOT_URLCONF == "pytest_django_test.urls_overridden"
assert is_valid_path("/overridden_url/")