def process_request(self, request):
old_path = request.path
if not old_path.endswith("/") or old_path == "/":
return
urlconf = getattr(request, "urlconf", None)
if urlresolvers.is_valid_path(request.path_info, urlconf):
return
if not urlresolvers.is_valid_path(request.path_info.rstrip("/"), urlconf):
return
new_path = request.path.rstrip("/")
if s.DEBUG and request.method == 'POST':
raise RuntimeError((
"You called this URL via POST, but the URL should not end "
"in a slash and RemoveTrailingSlashMiddleware is active. "
"I can't redirect to the slash URL while maintaining POST data. "
"Change your form to point to %s (no trailing slash)."
) %(new_path, ))
query = request.environ.get("QUERY_STRING")
if query:
new_path += "?" + query
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, supported=self._supported_languages)
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)
if not path_valid and settings.APPEND_SLASH and not language_path.endswith("/"):
path_valid = is_valid_path("%s/" % language_path, urlconf)
if path_valid:
language_url = "%s://%s/%s%s" % (
"https" if request.is_secure() else "http",
request.get_host(),
language,
request.get_full_path(),
)
return HttpResponseRedirect(language_url)
# Store language back into session if it is not present
if hasattr(request, "session"):
request.session.setdefault("django_language", language)
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_response(self, request, response):
language = get_language(request, self.is_language_prefix_patterns_used())
supported_languages = supported_languages_for_path(request.path_info)['languages']
language_from_path = translation.get_language_from_path(
request.path_info, supported=self._supported_languages
)
if path_translation_enabled(request.path_info):
if not language_from_path:
return redirect(u'/%s%s' % (language, request.path_info))
elif language_from_path not in supported_languages:
response = HttpResponseNotFound()
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)
if (not path_valid and settings.APPEND_SLASH
and not language_path.endswith('/')):
path_valid = is_valid_path("%s/" % language_path, urlconf)
if path_valid and language in supported_languages:
language_url = "%s://%s/%s%s" % (
'https' if request.is_secure() else 'http',
request.get_host(), language, request.get_full_path())
return HttpResponseRedirect(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_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 urlresolvers.is_valid_path(request.path_info, urlconf)) and urlresolvers.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 http.HttpResponsePermanentRedirect(new_url)
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)
path_valid = is_valid_path(language_path, urlconf)
if (not path_valid and settings.APPEND_SLASH
and not language_path.endswith('/')):
path_valid = is_valid_path("%s/" % language_path, urlconf)
if path_valid:
path = request.get_full_path()
script_mount = request.META.get("SCRIPT_NAME", "")
if path.startswith(script_mount):
path = path.replace(script_mount, ("%s/%s" % (script_mount, language)), 1)
language_url = "%s://%s%s" % (
request.is_secure() and 'https' or 'http',
request.get_host(), path)
return HttpResponseRedirect(language_url)
translation.deactivate()
patch_vary_headers(response, ('Accept-Language',))
if 'Content-Language' not in response:
response['Content-Language'] = language
return response
def process_response(self, request, response):
language = translation.get_language()
language_from_path = translation.get_language_from_path(
request.path_info, supported=self._supported_languages
)
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)
if (not path_valid and settings.APPEND_SLASH
and not language_path.endswith('/')):
path_valid = is_valid_path("%s/" % language_path, urlconf)
if path_valid:
language_url = "%s://%s/%s%s" % (
request.scheme, request.get_host(), language,
request.get_full_path())
return self.response_redirect_class(language_url)
# Store language back into session if it is not present
if hasattr(request, 'session'):
request.session.setdefault('django_language', language)
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_response(self, request, response):
language = translation.get_language()
language_from_path = translation.get_language_from_path(
request.path_info, supported=self._supported_languages
)
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)
if (not path_valid and settings.APPEND_SLASH
and not language_path.endswith('/')):
path_valid = is_valid_path("%s/" % language_path, urlconf)
if path_valid:
language_url = "%s://%s/%s%s" % (
request.is_secure() and 'https' or 'http',
request.get_host(), language, request.get_full_path())
return HttpResponseRedirect(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_response(self, request, response):
language = translation.get_language()
# Check if app has i18n_patterns urlconf
is_i18n_pattern = hasattr(request, 'resolver_match') and getattr(request.resolver_match, 'app_name', None) in ('account',)
# If path is '/', resolver_match is errored and not provided
if request.path == '/' and request.user.is_anonymous():
# On home, if not anonymous -> tenant_root
is_i18n_pattern = True
if (response.status_code == 404 and
is_i18n_pattern
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)
path_valid = is_valid_path(language_path, urlconf)
if (not path_valid and settings.APPEND_SLASH
and not language_path.endswith('/')):
path_valid = is_valid_path("%s/" % language_path, urlconf)
if path_valid:
language_url = "%s://%s/%s%s" % (
request.is_secure() and 'https' or 'http',
request.get_host(), language, request.get_full_path())
return HttpResponseRedirect(language_url)
translation.deactivate()
patch_vary_headers(response, ('Accept-Language',))
if 'Content-Language' not in response:
response['Content-Language'] = language
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)
valid_language_path = language_path
path_valid = is_valid_path(language_path, urlconf)
if (not path_valid and settings.APPEND_SLASH
and not language_path.endswith('/')):
path_valid = is_valid_path("%s/" % language_path, urlconf)
if path_valid:
valid_language_path = "%s/" % language_path
if path_valid and is_valid_path(request.path_info):
# If the language path is valid and the request's original path
# is also valid, make sure we're not redirecting to a different view
path_valid = self._resolves_to_same_view(request.path_info, valid_language_path, urlconf)
if path_valid:
language_url = "%s://%s/%s%s" % (
request.is_secure() and 'https' or 'http',
request.get_host(), language, request.get_full_path())
return HttpResponseRedirect(language_url)
translation.deactivate()
patch_vary_headers(response, ('Accept-Language',))
if 'Content-Language' not in response:
response['Content-Language'] = language
return response
def process_response(self, request, response):
language = translation.get_language()
if self.use_redirects:
kwargs = {}
if django_root_version >= 16:
kwargs['supported'] = self._supported_languages
language_from_path = translation.get_language_from_path(
request.path_info, **kwargs)
if (response.status_code == 404 and not language_from_path
and self.is_language_prefix_patterns_used()
and language != self.default_lang):
urlconf = getattr(request, 'urlconf', None)
language_path = '/%s%s' % (language, request.path_info)
path_valid = is_valid_path(language_path, urlconf)
if (not path_valid and settings.APPEND_SLASH
and not language_path.endswith('/')):
path_valid = is_valid_path("%s/" % language_path, urlconf)
if path_valid:
language_url = "%s://%s/%s%s" % (
'https' if request.is_secure() else 'http',
request.get_host(), language, request.get_full_path())
return HttpResponseRedirect(language_url)
if not (self.is_language_prefix_patterns_used()
and language_from_path):
patch_vary_headers(response, ('Accept-Language', ))
if django_root_version < 16:
translation.deactivate()
if 'Content-Language' not in response:
response['Content-Language'] = language
return response
def process_response(self, request, response):
language = translation.get_language()
language_from_path = translation.get_language_from_path(
request.path_info, supported=self._supported_languages
)
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)
if (not path_valid and settings.APPEND_SLASH
and not language_path.endswith('/')):
path_valid = is_valid_path("%s/" % language_path, urlconf)
if path_valid:
language_url = "%s://%s/%s%s" % (
'https' if request.is_secure() else 'http',
request.get_host(), language, request.get_full_path())
return HttpResponseRedirect(language_url)
# Store language back into session if it is not present
if hasattr(request, 'session'):
request.session.setdefault('django_language', language)
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_request(self, request):
old_path = request.path
if not old_path.endswith("/") or old_path == "/":
return
urlconf = getattr(request, "urlconf", None)
if urlresolvers.is_valid_path(request.path_info, urlconf):
return
if not urlresolvers.is_valid_path(request.path_info.rstrip("/"),
urlconf):
return
new_path = request.path.rstrip("/")
if s.DEBUG and request.method == 'POST':
raise RuntimeError((
"You called this URL via POST, but the URL should not end "
"in a slash and RemoveTrailingSlashMiddleware is active. "
"I can't redirect to the slash URL while maintaining POST data. "
"Change your form to point to %s (no trailing slash).") %
(new_path, ))
query = request.environ.get("QUERY_STRING")
if query:
new_path += "?" + query
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)
ret = is_language_prefix_patterns_used(urlconf)
i18n_patterns_used, prefixed_default_language = ret
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()
language_url = backported_get_full_path(
request, 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_response(self, request, response):
language = translation.get_language()
if self.use_redirects:
kwargs = {}
if django_root_version == 16:
kwargs['supported'] = self._supported_languages
language_from_path = translation.get_language_from_path(
request.path_info, **kwargs)
if (response.status_code == 404 and not language_from_path
and self.is_language_prefix_patterns_used()
and language != self.default_lang):
urlconf = getattr(request, 'urlconf', None)
language_path = '/%s%s' % (language, request.path_info)
path_valid = is_valid_path(language_path, urlconf)
if (not path_valid and settings.APPEND_SLASH
and not language_path.endswith('/')):
path_valid = is_valid_path("%s/" % language_path, urlconf)
if path_valid:
language_url = "%s://%s/%s%s" % (
'https' if request.is_secure() else 'http',
request.get_host(), language, request.get_full_path())
return HttpResponseRedirect(language_url)
if not (self.is_language_prefix_patterns_used()
and language_from_path):
patch_vary_headers(response, ('Accept-Language',))
if django_root_version < 16:
translation.deactivate()
if 'Content-Language' not in response:
response['Content-Language'] = language
return response
def process_response(self, request, response):
language = translation.get_language()
# Check if app has i18n_patterns urlconf
is_i18n_pattern = hasattr(request, 'resolver_match') and getattr(
request.resolver_match, 'app_name', None) in ('account', )
# If path is '/', resolver_match is errored and not provided
if request.path == '/' and request.user.is_anonymous():
# On home, if not anonymous -> tenant_root
is_i18n_pattern = True
if (response.status_code == 404 and is_i18n_pattern
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)
path_valid = is_valid_path(language_path, urlconf)
if (not path_valid and settings.APPEND_SLASH
and not language_path.endswith('/')):
path_valid = is_valid_path("%s/" % language_path, urlconf)
if path_valid:
language_url = "%s://%s/%s%s" % (
request.is_secure() and 'https' or 'http',
request.get_host(), language, request.get_full_path())
return HttpResponseRedirect(language_url)
translation.deactivate()
patch_vary_headers(response, ('Accept-Language', ))
if 'Content-Language' not in response:
response['Content-Language'] = language
return response
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)
if (not path_valid and settings.APPEND_SLASH
and not language_path.endswith('/')):
path_valid = is_valid_path("%s/" % language_path, urlconf)
if path_valid:
script_prefix = get_script_prefix()
language_url = "%s://%s%s" % (
request.scheme,
request.get_host(),
# insert language after the script prefix and before the
# rest of the URL
request.get_full_path().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_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 perform_redirect(self, request, language, is_permanent=False):
# language can be empty string (in case of default language)
path_info = request.path_info
if not language:
path_info = self.remove_lang_from_path(path_info)
urlconf = getattr(request, 'urlconf', None)
language_path = '%s%s' % (language, path_info)
if not language_path.startswith('/'):
language_path = '/' + language_path
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()
if DJANGO_VERSION < (1, 9):
full_path = get_full_path(request,
force_append_slash=path_needs_slash)
else:
full_path = request.get_full_path(
force_append_slash=path_needs_slash)
if not language:
full_path = self.remove_lang_from_path(full_path)
language_url = full_path.replace(
script_prefix, '%s%s/' %
(script_prefix, language) if language else script_prefix, 1)
# return a 301 permanent redirect if on default language
if (is_permanent):
return self.response_default_language_redirect_class(
language_url)
else:
return self.response_redirect_class(language_url)
def redirectold(request, exception):
path = request.path_info.lower()
if path.endswith('index.html'):
path = path[:-10]
elif path.endswith('.html'):
path = path[:-5]
path = re.sub('^/fa-', '/fa/', path)
path = re.sub('__+', '_', path).replace('-', '')
path = settings.FORWARDS.get(path, path)
if path.startswith('/who/'):
nameslug = path[5:]
for n in ALIASES.keys():
from django.utils.text import slugify
if nameslug == slugify(n):
match = name_alias(n)
path = Creator.objects.get(name=match[0]).get_absolute_url()
urlconf = getattr(request, 'urlconf', None)
if (path != request.path_info and
urlresolvers.is_valid_path(path, urlconf)):
return HttpResponsePermanentRedirect("%s://%s%s" % (
'https' if request.is_secure() else 'http',
request.get_host(), path))
path = path + '/'
if (path != request.path_info and
urlresolvers.is_valid_path(path, urlconf)):
return HttpResponsePermanentRedirect("%s://%s%s" % (
'https' if request.is_secure() else 'http',
request.get_host(), path))
return page_not_found(request, exception)
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)
if (not path_valid and settings.APPEND_SLASH
and not language_path.endswith('/')):
path_valid = is_valid_path("%s/" % language_path, urlconf)
if path_valid:
script_prefix = get_script_prefix()
language_url = "%s://%s%s" % (
request.scheme,
request.get_host(),
# insert language after the script prefix and before the
# rest of the URL
request.get_full_path().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 translate_url(context, language):
request = context.get('request')
is_valid_path = urlresolvers.is_valid_path(request.path_info)
request_language = translation.get_language()
url = None
if is_valid_path:
view = resolve(
request.path_info)
translation.activate(language)
url = reverse(view.url_name, args=view.args, kwargs=view.kwargs)
translation.activate(request_language)
else:
is_valid_path = urlresolvers.is_valid_path(
request.path_info, 'static_pages.urls_i18n')
if is_valid_path:
view = resolve(
request.path_info, urlconf='static_pages.urls_i18n')
translation.activate(language)
url = reverse(
view.url_name,
args=view.args,
kwargs=view.kwargs,
urlconf='static_pages.urls_i18n')
translation.activate(request_language)
return url
def process_response(self, request, response):
country_code = get_country()
country_from_path = get_country_from_path(request.path_info)
if (response.status_code == 404 and not country_from_path
and self.is_language_prefix_patterns_used):
urlconf = getattr(request, 'urlconf', None)
country_path = '/%s%s' % (country_code, request.path_info)
path_valid = is_valid_path(country_path, urlconf)
path_needs_slash = (
not path_valid and (
settings.APPEND_SLASH and not country_path.endswith('/')
and is_valid_path('%s/' % country_path, urlconf)
)
)
if path_valid or path_needs_slash:
script_prefix = get_script_prefix()
language_url = request.get_full_path(force_append_slash=path_needs_slash).replace(
script_prefix,
'%s%s/' % (script_prefix, country_code),
1
)
return self.response_redirect_class(language_url)
return response
def perform_redirect(self, request, language):
# language can be empty string (in case of default language)
path_info = request.path_info
full_path = request.get_full_path()
if not language:
path_info = self.remove_lang_from_path(path_info)
full_path = self.remove_lang_from_path(full_path)
urlconf = getattr(request, 'urlconf', None)
language_path = '%s%s' % (language, path_info)
if not language_path.startswith('/'):
language_path = '/' + language_path
path_valid = is_valid_path(language_path, urlconf)
if (not path_valid and settings.APPEND_SLASH
and not language_path.endswith('/')):
path_valid = is_valid_path("%s/" % language_path, urlconf)
if path_valid:
if DJANGO_VERSION >= (1, 7):
scheme = request.scheme
else:
scheme = 'https' if request.is_secure() else 'http'
script_prefix = get_script_prefix()
language_url = "%s://%s%s" % (
scheme,
request.get_host(),
# insert language after the script prefix and before the
# rest of the URL
full_path.replace(
script_prefix,
'%s%s/' % (script_prefix, language) if language else script_prefix,
1
)
)
return self.response_redirect_class(language_url)
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)
valid_language_path = language_path
path_valid = is_valid_path(language_path, urlconf)
if not path_valid and settings.APPEND_SLASH and not language_path.endswith("/"):
path_valid = is_valid_path("%s/" % language_path, urlconf)
if path_valid:
valid_language_path = "%s/" % language_path
if path_valid and is_valid_path(request.path_info):
# If the language path is valid and the request's original path
# is also valid, make sure we're not redirecting to a different view
path_valid = self._resolves_to_same_view(request.path_info, valid_language_path, urlconf)
if path_valid:
language_url = "%s://%s/%s%s" % (
request.is_secure() and "https" or "http",
request.get_host(),
language,
request.get_full_path(),
)
return HttpResponseRedirect(language_url)
translation.deactivate()
patch_vary_headers(response, ("Accept-Language",))
if "Content-Language" not in response:
response["Content-Language"] = language
return response
def process_response(self, request, response):
language = translation.get_language()
language_from_path = translation.get_language_from_path(
request.path_info, supported=self._supported_languages)
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)
if (not path_valid and settings.APPEND_SLASH
and not language_path.endswith('/')):
path_valid = is_valid_path("%s/" % language_path, urlconf)
if path_valid:
language_url = "%s://%s/%s%s" % (request.scheme,
request.get_host(), language,
request.get_full_path())
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_request(self, request):
"""
Check for denied User-Agents and rewrite the URL based on
settings.APPEND_SLASH and settings.PREPEND_WWW
"""
# Check for denied User-Agents
if 'HTTP_USER_AGENT' in request.META:
for user_agent_regex in settings.DISALLOWED_USER_AGENTS:
if user_agent_regex.search(request.META['HTTP_USER_AGENT']):
logger.warning('Forbidden (User agent): %s',
request.path,
extra={
'status_code': 403,
'request': request
})
return http.HttpResponseForbidden('<h1>Forbidden</h1>')
# Check for a redirect based on settings.APPEND_SLASH
# and settings.PREPEND_WWW
host = request.get_host()
old_url = [host, request.get_full_path()]
new_url = old_url[:]
if (settings.PREPEND_WWW and old_url[0]
and not old_url[0].startswith('www.')):
new_url[0] = 'www.' + old_url[0]
# Append a slash if APPEND_SLASH is set and the URL doesn't have a
# trailing slash and there is no pattern for the current path
if settings.APPEND_SLASH and (not old_url[1].endswith('/')):
urlconf = getattr(request, 'urlconf', None)
if (not urlresolvers.is_valid_path(request.path_info, urlconf)
and urlresolvers.is_valid_path("%s/" % request.path_info,
urlconf)):
new_url[1] = request.get_full_path(force_append_slash=True)
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': ''.join(new_url)
})
if new_url == old_url:
# No redirects required.
return
if new_url[0] != old_url[0]:
newurl = "%s://%s%s" % (request.scheme, new_url[0], new_url[1])
else:
newurl = new_url[1]
return self.response_redirect_class(newurl)
def process_request(self, request):
"""
Check for denied User-Agents and rewrite the URL based on
settings.APPEND_SLASH and settings.PREPEND_WWW
"""
# Check for denied User-Agents
if 'HTTP_USER_AGENT' in request.META:
for user_agent_regex in settings.DISALLOWED_USER_AGENTS:
if user_agent_regex.search(request.META['HTTP_USER_AGENT']):
logger.warning('Forbidden (User agent): %s',
request.path,
extra={
'status_code': 403,
'request': request
})
return http.HttpResponseForbidden('<h1>Forbidden</h1>')
# Check for a redirect based on settings.APPEND_SLASH
# and settings.PREPEND_WWW
host = request.get_host()
old_url = [host, request.path]
new_url = old_url[:]
if (settings.PREPEND_WWW and old_url[0]
and not old_url[0].startswith('www.')):
new_url[0] = 'www.' + old_url[0]
# Append a slash if APPEND_SLASH is set and the URL doesn't have a
# trailing slash and there is no pattern for the current path
if settings.APPEND_SLASH and (not old_url[1].endswith('/')):
urlconf = getattr(request, 'urlconf', None)
if (not urlresolvers.is_valid_path(request.path_info, urlconf)
and urlresolvers.is_valid_path("%s/" % request.path_info,
urlconf)):
new_url[1] = new_url[1] + '/'
if settings.DEBUG and request.method == 'POST':
raise RuntimeError((
""
"You called this URL via POST, 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 POST data. "
"Change your form to point to %s%s (note the trailing "
"slash), or set APPEND_SLASH=False in your Django "
"settings.") % (new_url[0], new_url[1]))
if new_url == old_url:
# No redirects required.
return
if new_url[0]:
newurl = "%s://%s%s" % (request.is_secure() and 'https' or 'http',
new_url[0], urlquote(new_url[1]))
else:
newurl = urlquote(new_url[1])
if request.META.get('QUERY_STRING', ''):
newurl += '?' + request.META['QUERY_STRING']
return http.HttpResponsePermanentRedirect(newurl)
def process_request(self, request):
"""
Check for denied User-Agents and rewrite the URL based on
settings.APPEND_SLASH and settings.PREPEND_WWW
"""
# Check for denied User-Agents
if 'HTTP_USER_AGENT' in request.META:
for user_agent_regex in settings.DISALLOWED_USER_AGENTS:
if user_agent_regex.search(request.META['HTTP_USER_AGENT']):
logger.warning('Forbidden (User agent): %s', request.path,
extra={
'status_code': 403,
'request': request
}
)
return http.HttpResponseForbidden('<h1>Forbidden</h1>')
# Check for a redirect based on settings.APPEND_SLASH
# and settings.PREPEND_WWW
host = request.get_host()
old_url = [host, request.path]
new_url = old_url[:]
if (settings.PREPEND_WWW and old_url[0] and
not old_url[0].startswith('www.')):
new_url[0] = 'www.' + old_url[0]
# Append a slash if APPEND_SLASH is set and the URL doesn't have a
# trailing slash and there is no pattern for the current path
if settings.APPEND_SLASH and (not old_url[1].endswith('/')):
urlconf = getattr(request, 'urlconf', None)
if (not urlresolvers.is_valid_path(request.path_info, urlconf) and
urlresolvers.is_valid_path("%s/" % request.path_info, urlconf)):
new_url[1] = new_url[1] + '/'
if settings.DEBUG and request.method == 'POST':
raise RuntimeError((""
"You called this URL via POST, 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 POST data. "
"Change your form to point to %s%s (note the trailing "
"slash), or set APPEND_SLASH=False in your Django "
"settings.") % (new_url[0], new_url[1]))
if new_url == old_url:
# No redirects required.
return
if new_url[0]:
newurl = "%s://%s%s" % (
request.is_secure() and 'https' or 'http',
new_url[0], urlquote(new_url[1]))
else:
newurl = urlquote(new_url[1])
if request.META.get('QUERY_STRING', ''):
newurl += '?' + request.META['QUERY_STRING']
return http.HttpResponsePermanentRedirect(newurl)
def should_redirect_without_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 getattr(settings, 'REMOVE_SLASH', False) and trailing_slash_regexp.search(request.get_full_path()):
urlconf = getattr(request, 'urlconf', None)
return (not urlresolvers.is_valid_path(request.path_info, urlconf) and urlresolvers.is_valid_path(
request.path_info[:-1], urlconf))
return False
def should_redirect_without_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 getattr(settings, 'REMOVE_SLASH', False) and trailing_slash_regexp.search(request.get_full_path()):
urlconf = getattr(request, 'urlconf', None)
return (not urlresolvers.is_valid_path(request.path_info, urlconf) and urlresolvers.is_valid_path(
request.path_info[:-1], urlconf))
return False
def process_request(self, request):
"""
Check for denied User-Agents and rewrite the URL based on
settings.APPEND_SLASH and settings.PREPEND_WWW
"""
# Check for denied User-Agents
if 'HTTP_USER_AGENT' in request.META:
for user_agent_regex in settings.DISALLOWED_USER_AGENTS:
if user_agent_regex.search(request.META['HTTP_USER_AGENT']):
logger.warning('Forbidden (User agent): %s', request.path,
extra={
'status_code': 403,
'request': request
}
)
return http.HttpResponseForbidden('<h1>Forbidden</h1>')
# Check for a redirect based on settings.APPEND_SLASH
# and settings.PREPEND_WWW
host = request.get_host()
old_url = [host, request.get_full_path()]
new_url = old_url[:]
if (settings.PREPEND_WWW and old_url[0] and
not old_url[0].startswith('www.')):
new_url[0] = 'www.' + old_url[0]
# Append a slash if APPEND_SLASH is set and the URL doesn't have a
# trailing slash and there is no pattern for the current path
if settings.APPEND_SLASH and (not old_url[1].endswith('/')):
urlconf = getattr(request, 'urlconf', None)
if (not urlresolvers.is_valid_path(request.path_info, urlconf) and
urlresolvers.is_valid_path("%s/" % request.path_info, urlconf)):
new_url[1] = request.get_full_path(force_append_slash=True)
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': ''.join(new_url)})
if new_url == old_url:
# No redirects required.
return
if new_url[0] != old_url[0]:
newurl = "%s://%s%s" % (
request.scheme,
new_url[0], new_url[1])
else:
newurl = new_url[1]
return self.response_redirect_class(newurl)
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 urlresolvers.is_valid_path(request.path_info, urlconf)
and urlresolvers.is_valid_path('%s/' % request.path_info,
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.get_full_path().endswith("/"):
urlconf = getattr(request, "urlconf", None)
return not urlresolvers.is_valid_path(request.path_info, urlconf) and urlresolvers.is_valid_path(
"%s/" % request.path_info, 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 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 process_request(self, request):
# Check for a redirect based on settings.APPEND_SLASH
# and settings.PREPEND_WWW
host = request.get_host()
old_url = [host, request.path]
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 old_url[1].endswith('/'):
urlconf = getattr(request, 'urlconf', None)
if (not urlresolvers.is_valid_path(request.path_info, urlconf)
) and urlresolvers.is_valid_path(request.path_info[:-1],
urlconf):
new_url[1] = new_url[1][:-1]
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%s (without a "
"trailing slash), or set REMOVE_SLASH=False in your "
"Django settings.") % (new_url[0], new_url[1]))
if new_url == old_url:
# No redirects required.
return
if new_url[0]:
newurl = "%s://%s%s" % ('https' if request.is_secure() else 'http',
new_url[0], urlquote(new_url[1]))
else:
newurl = urlquote(new_url[1])
if request.META.get('QUERY_STRING', ''):
if six.PY3:
newurl += '?' + request.META['QUERY_STRING']
else:
# `query_string` is a bytestring. Appending it to the unicode
# string `newurl` will fail if it isn't ASCII-only. This isn't
# allowed; only broken software generates such query strings.
# Better drop the invalid query string than crash (#15152).
try:
newurl += '?' + request.META['QUERY_STRING'].decode()
except UnicodeDecodeError:
pass
return http.HttpResponsePermanentRedirect(newurl)
def process_request(self, request):
# Check for a redirect based on settings.APPEND_SLASH
# and settings.PREPEND_WWW
host = request.get_host()
old_url = [host, request.path]
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 old_url[1].endswith('/'):
urlconf = getattr(request, 'urlconf', None)
if (not urlresolvers.is_valid_path(request.path_info, urlconf)) and urlresolvers.is_valid_path(request.path_info[:-1], urlconf):
new_url[1] = new_url[1][:-1]
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%s (without a "
"trailing slash), or set REMOVE_SLASH=False in your "
"Django settings.") % (new_url[0], new_url[1]))
if new_url == old_url:
# No redirects required.
return
if new_url[0]:
newurl = "%s://%s%s" % (
'https' if request.is_secure() else 'http',
new_url[0], urlquote(new_url[1]))
else:
newurl = urlquote(new_url[1])
if request.META.get('QUERY_STRING', ''):
if six.PY3:
newurl += '?' + request.META['QUERY_STRING']
else:
# `query_string` is a bytestring. Appending it to the unicode
# string `newurl` will fail if it isn't ASCII-only. This isn't
# allowed; only broken software generates such query strings.
# Better drop the invalid query string than crash (#15152).
try:
newurl += '?' + request.META['QUERY_STRING'].decode()
except UnicodeDecodeError:
pass
return http.HttpResponsePermanentRedirect(newurl)
def process_response(self, request, response):
"""."""
# First set the default language, this will be used if there is none
# in the path
default_language = getattr(request, 'default_language', '')
if default_language:
translation.activate(default_language)
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(request)):
language_path = '/%s%s' % (language, request.path_info)
if settings.APPEND_SLASH and not language_path.endswith('/'):
language_path += '/'
if is_valid_path(language_path, settings.ROOT_URLCONF):
language_url = "%s://%s/%s%s" % (
request.is_secure() and 'https' or 'http',
request.get_host(), language, request.get_full_path())
return HttpResponseRedirect(language_url)
translation.deactivate()
patch_vary_headers(response, ('Accept-Language', ))
if 'Content-Language' not in response:
response['Content-Language'] = language
return response
def process_response(self, request, response):
# First set the default language, this will be used if there is none
# in the path
default_language = getattr(request, 'default_language', '')
if default_language:
translation.activate(default_language)
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(request)):
urlconf = getattr(request, 'urlconf', None)
language_path = '/%s%s' % (language, request.path_info)
if settings.APPEND_SLASH and not language_path.endswith('/'):
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 HttpResponseRedirect(language_url)
translation.deactivate()
patch_vary_headers(response, ('Accept-Language',))
if 'Content-Language' not in response:
response['Content-Language'] = language
return response
def test_urls(client):
assert settings.ROOT_URLCONF == 'tests.urls_overridden'
assert is_valid_path('/overridden_url/')
response = client.get('/overridden_url/')
assert response.content == 'Overridden urlconf works!'
def process_response(self, request, response):
"""
Override the original method to redirect permanently and facilitate
the :func.`translations.urls.translation_patterns` URL redirection
logic.
"""
language = translation.get_language()
default = get_default_language()
#redirect to the original default language URL
#if language prefix is used
if (response.status_code == 404 and
self.is_language_prefix_patterns_used() and default == language and
request.path_info.startswith('/%s/' % default)):
urlconf = getattr(request, 'urlconf', None)
language_path = re.sub(r'^/%s/' % default, '/', request.path_info)
if settings.APPEND_SLASH and not language_path.endswith('/'):
language_path = language_path + '/'
if is_valid_path(language_path, urlconf):
#we use a permanent redirect here.
#when changing the default language we need to let the world know
#that our links have permanently changed and transfer our seo juice
#to the new url
#http://blog.yawd.eu/2012/impact-django-page-redirects-seo/
return HttpResponsePermanentRedirect("%s://%s/%s" % (
request.is_secure() and 'https' or 'http',
request.get_host(), re.sub(r'^/%s/' % default, '', request.get_full_path())))
patch_vary_headers(response, ('Accept-Language',))
if 'Content-Language' not in response:
response['Content-Language'] = language
return response
def process_request(self, req):
scheme = 'http:' if settings.DEBUG else 'https:'
path = req.get_full_path()
if path.endswith('/') and is_valid_path(path[:-1]):
hostname = req.META.get('HTTP_HOST')
return HttpResponsePermanentRedirect('%s//%s%s' %
(scheme, hostname, path[:-1]))
return None
def process_request(self, req):
scheme = 'http:' if settings.DEBUG else 'https:'
path = req.get_full_path()
if path.endswith('/') and is_valid_path(path[:-1]):
hostname = req.META.get('HTTP_HOST')
return HttpResponsePermanentRedirect(
'%s//%s%s' % (scheme, hostname, path[:-1]))
return None
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 \
= backported_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()
language_url = backported_get_full_path(request,
force_append_slash=path_needs_slash).replace(
script_prefix,
'%s%s/' % (script_prefix, language),
1
)
return self.response_redirect_class(language_url)
# NOTE In Django 1.10 this is taken care of in other middleware
# and that is why this session update is not in the 1.10
# locale middleware.
if hasattr(request, 'session') and language_from_path:
request.session['_language'] = language
# NOTE customization 3:
if (hasattr(request, 'user') and request.user.is_authenticated()
and language != request.user.preferred_language):
request.user.set_preferred_language(language)
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):
host = request.get_host()
old_url = [host, request.path]
new_url = old_url[:]
if not settings.APPEND_SLASH and old_url[1].endswith("/"):
urlconf = getattr(request, "urlconf", None)
if not urlresolvers.is_valid_path(request.path_info, urlconf) and urlresolvers.is_valid_path(
request.path_info[:-1], urlconf
):
new_url[1] = new_url[1][:-1]
if settings.DEBUG and request.method == "POST":
raise RuntimeError(
(
""
"You called this URL via POST, but the URL ends "
"in a slash and you don't have APPEND_SLASH set. Django can't "
"redirect to the non-slash URL while maintaining POST data. "
"Change your form to point to %s%s (note no trailing "
"slash), or set APPEND_SLASH=True in your Django "
"settings."
)
% (new_url[0], new_url[1])
)
if new_url == old_url:
# No redirects required.
return
if new_url[0]:
newurl = "%s://%s%s" % (request.is_secure() and "https" or "http", new_url[0], urlquote(new_url[1]))
else:
newurl = urlquote(new_url[1])
if request.META.get("QUERY_STRING", ""):
if six.PY3:
newurl += "?" + request.META["QUERY_STRING"]
else:
# `query_string` is a bytestring. Appending it to the unicode
# string `newurl` will fail if it isn't ASCII-only. This isn't
# allowed; only broken software generates such query strings.
# Better drop the invalid query string than crash (#15152).
try:
newurl += "?" + request.META["QUERY_STRING"].decode()
except UnicodeDecodeError:
pass
return http.HttpResponsePermanentRedirect(newurl)
def append_slash(self, request, host):
old_url = [host, request.path]
new_url = old_url[:]
if not old_url[1].endswith('/'):
urlconf = getattr(request, 'urlconf', None)
if (not urlresolvers.is_valid_path(request.path_info, urlconf) and
urlresolvers.is_valid_path("%s/" % request.path_info, urlconf)):
new_url[1] = new_url[1] + '/'
if settings.DEBUG and request.method == 'POST':
raise RuntimeError((""
"You called this URL via POST, 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 POST data. "
"Change your form to point to %s%s (note the trailing "
"slash), or set APPEND_SLASH=False in your Django "
"settings.") % (new_url[0], new_url[1]))
if new_url == old_url:
# No redirects required.
return
if new_url[0]:
newurl = "%s://%s%s" % (
request.is_secure() and 'https' or 'http',
new_url[0], urlquote(new_url[1]))
else:
newurl = urlquote(new_url[1])
if request.META.get('QUERY_STRING', ''):
if six.PY3:
newurl += '?' + request.META['QUERY_STRING']
else:
# `query_string` is a bytestring. Appending it to the unicode
# string `newurl` will fail if it isn't ASCII-only. This isn't
# allowed; only broken software generates such query strings.
# Better drop the invalid query string than crash (#15152).
try:
newurl += '?' + request.META['QUERY_STRING'].decode()
except UnicodeDecodeError:
pass
return http.HttpResponsePermanentRedirect(newurl)
def process_request(self, request):
# Bail if we already have trailing slash.
if request.path.endswith('/'):
return
urlconf = getattr(request, 'urlconf', None)
old_is_valid = lambda: urlresolvers.is_valid_path(request.path_info, urlconf)
new_is_valid = lambda: urlresolvers.is_valid_path('%s/' % request.path_info, urlconf)
# Bail for valid urls or slash version not being valid.
if (old_is_valid() or not new_is_valid()):
return
if settings.DEBUG and request.method == 'POST':
raise RuntimeError("Can't redirect POST in AppendSlashMiddleware.")
# Redirect rest:
url = http_utils.urlquote('%s/' % request.path_info)
if request.META.get('QUERY_STRING', ''):
url += '?' + request.META['QUERY_STRING']
return http.HttpResponsePermanentRedirect(url)
def process_response(self, request, response):
if response.status_code == 404:
if settings.APPEND_SLASH and not request.path_info.endswith('/'):
return HttpResponseRedirect(f'{request.path_info}/')
is_valid_path = urlresolvers.is_valid_path(
request.path_info, 'static_pages.urls_i18n')
if is_valid_path:
view, args, kwargs = resolve(request.path_info,
urlconf='static_pages.urls_i18n')
kwargs['request'] = request
return view(*args, **kwargs)
return response
def process_response(self, request, response):
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()):
newurl = '/u' + request.path_info
if request.GET:
with safe_query_string(request):
newurl += '?' + request.META['QUERY_STRING']
return HttpResponseRedirect(newurl)
return response
def perform_redirect(self, request, language, is_permanent=False):
# language can be empty string (in case of default language)
path_info = request.path_info
if not language:
path_info = self.remove_lang_from_path(path_info)
urlconf = getattr(request, 'urlconf', None)
language_path = '%s%s' % (language, path_info)
if not language_path.startswith('/'):
language_path = '/' + language_path
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()
if DJANGO_VERSION < (1, 9):
full_path = get_full_path(request, force_append_slash=path_needs_slash)
else:
full_path = request.get_full_path(force_append_slash=path_needs_slash)
if not language:
full_path = self.remove_lang_from_path(full_path)
language_url = full_path.replace(
script_prefix,
'%s%s/' % (script_prefix, language) if language else script_prefix,
1
)
# set 301 permanent redirect for baidu spider
if request.META.get('HTTP_USER_AGENT') and 'baiduspider' in request.META['HTTP_USER_AGENT'].lower():
is_permanent = True
# return a 301 permanent redirect if on default language
if (is_permanent):
return self.response_default_language_redirect_class(language_url)
else:
return self.response_redirect_class(language_url)
def process_response(self, request, response):
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()):
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_request(request):
# Проверяем запрет авторедиректа через GET-параметр
if request.GET.get(options.MULTILANGUAGE_GET_PARAM):
request.disable_autoredirect = True
# Проверяем, что на текущем сайте есть такая страница,
# иначе, редиректим на MULTILANGUAGE_FALLBACK_URL
urlconf = getattr(request, 'urlconf', None)
if not is_valid_path(request.path_info, urlconf):
return redirect(options.MULTILANGUAGE_FALLBACK_URL)
return
# Проверяем запрет авторедиректа через куку
if request.COOKIES.get(options.MULTILANGUAGE_COOKIE_KEY, None):
return
# Проверяем запрет авторедиректа для определенных User-Agent
ua_string = request.META.get('HTTP_USER_AGENT', '').lower()
for pattern in options.ROBOTS_UA:
if pattern in ua_string:
return
# Получение информации о IP
ip = get_client_ip(request)
ip_info = info(ip, detailed=True)
if not ip_info:
request.disable_autoredirect = True
return
# Определение кода языка, на который нужно редиректить
current_code = settings.LANGUAGE_CODE
redirect_code = current_code
try:
ip_iso = ip_info.get('country').get('iso')
except AttributeError:
pass
else:
for code, opts in options.MULTILANGUAGE_SITES.items():
iso = opts.get('iso')
if iso and ip_iso in iso:
redirect_code = code
break
if current_code != redirect_code:
request.disable_autoredirect = True
language = options.MULTILANGUAGE_SITES.get(redirect_code)
if language:
redirect_url = noredirect_url(language['url'],
forced_path=request.path)
return redirect(redirect_url)
def process_request(self, request):
if getattr(settings, 'APPEND_SLASH') and getattr(
settings, 'REMOVE_SLASH'):
raise ImproperlyConfigured(
"APPEND_SLASH and REMOVE_SLASH may not both be True.")
old_url = request.path_info # path_info only includes path, query information
if getattr(settings, 'REMOVE_SLASH', False) and old_url[-1] == "/":
urlconf = getattr(request, 'urlconf', None)
new_url = old_url[:-1]
# If the url with a / would 404 and without a slash wouldn't
if (not urlresolvers.is_valid_path(
old_url, urlconf)) and urlresolvers.is_valid_path(
new_url, urlconf):
if settings.DEBUG and request.method == 'POST':
if old_url.startswith("/api/"):
return api.error(
"You made a POST request to a URL ending with a slash. Please repeat your request without the slash."
)
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))
# The ? and everything after
query_data = re.match(
r'^[^?]*(\?.*)?$',
request.build_absolute_uri()).group(1) or ""
return http.HttpResponsePermanentRedirect(new_url + query_data)
def perform_redirect(self, request, language, is_permanent=False):
# language can be empty string (in case of default language)
path_info = request.path_info
full_path = request.get_full_path()
if not language:
path_info = self.remove_lang_from_path(path_info)
full_path = self.remove_lang_from_path(full_path)
urlconf = getattr(request, 'urlconf', None)
language_path = '%s%s' % (language, path_info)
if not language_path.startswith('/'):
language_path = '/' + language_path
path_valid = is_valid_path(language_path, urlconf)
if (not path_valid and settings.APPEND_SLASH
and not language_path.endswith('/')):
path_valid = is_valid_path("%s/" % language_path, urlconf)
if path_valid:
if DJANGO_VERSION >= (1, 7):
scheme = request.scheme
else:
scheme = 'https' if request.is_secure() else 'http'
script_prefix = get_script_prefix()
language_url = "%s://%s%s" % (
scheme,
request.get_host(),
# insert language after the script prefix and before the
# rest of the URL
full_path.replace(
script_prefix, '%s%s/' %
(script_prefix, language) if language else script_prefix,
1))
# return a 301 permanent redirect if on default language
if (is_permanent):
return self.response_default_language_redirect_class(
language_url)
else:
return self.response_redirect_class(language_url)
def process_response(self, request, response):
language = translation.get_language()
language_from_path = translation.get_language_from_path(
request.path_info, supported=self._supported_languages)
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)
if (not path_valid and settings.APPEND_SLASH
and not language_path.endswith('/')):
path_valid = is_valid_path("%s/" % language_path, urlconf)
if path_valid:
language_url = "%s://%s/%s%s" % (request.scheme,
request.get_host(), language,
request.get_full_path())
return self.response_redirect_class(language_url)
# Store language back into session if it is not present
if hasattr(request, 'session') and '_language' not in request.session:
# Backwards compatibility check on django_language (remove in 1.8);
# revert to: `request.session.setdefault('_language', language)`.
if 'django_language' in request.session:
request.session['_language'] = request.session[
'django_language']
del request.session['django_language']
else:
request.session['_language'] = language
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_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 urlresolvers.is_valid_path(request.path_info, urlconf)
) and urlresolvers.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 http.HttpResponsePermanentRedirect(new_url)
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
