def get_language_from_request(request):
"""
Analyzes the request to find what language the user wants the system to
show. Only languages listed in settings.LANGUAGES are taken into account.
If the user requests a sublanguage where we have a main language, we send
out the main language.
"""
global _supported
if _supported is None:
_supported = OrderedDict(settings.LANGUAGES)
# Priority 1: User settings
if request.user.is_authenticated():
lang_code = request.user.locale
if lang_code in _supported and lang_code is not None and check_for_language(lang_code):
return lang_code
# Priority 2: Anonymous user settings (session, cookie)
if hasattr(request, 'session'):
lang_code = request.session.get(LANGUAGE_SESSION_KEY)
if lang_code in _supported and lang_code is not None and check_for_language(lang_code):
return lang_code
lang_code = request.COOKIES.get(settings.LANGUAGE_COOKIE_NAME)
try:
return get_supported_language_variant(lang_code)
except LookupError:
pass
# Priority 3: Event default
if hasattr(request, 'event'):
lang_code = request.event.locale
try:
return get_supported_language_variant(lang_code)
except LookupError:
pass
# Priority 4: Browser default
accept = request.META.get('HTTP_ACCEPT_LANGUAGE', '')
for accept_lang, unused in parse_accept_lang_header(accept):
if accept_lang == '*':
break
if not language_code_re.search(accept_lang):
continue
try:
return get_supported_language_variant(accept_lang)
except LookupError:
continue
try:
return get_supported_language_variant(settings.LANGUAGE_CODE)
except LookupError:
return settings.LANGUAGE_CODE
def _get_language_from_request(request, user):
"""从请求中获取需要同步到用户个人信息的语言
"""
supported_lang_codes = get_languages()
# session 有language，说明在登录页面有进行修改或设置，则需要同步到用户个人信息中
lang_code = request.session.get(translation.LANGUAGE_SESSION_KEY)
if lang_code in supported_lang_codes and lang_code is not None and check_for_language(
lang_code):
return lang_code
# 个人信息中已有language
if user.language:
return None
# session 情况不满足同步到用户个人信息，且目前个人信息中无language设置
# 查询header头
accept = request.META.get('HTTP_ACCEPT_LANGUAGE', '')
for accept_lang, unused in parse_accept_lang_header(accept):
if accept_lang == '*':
break
if not language_code_re.search(accept_lang):
continue
try:
return get_supported_language_variant(accept_lang)
except LookupError:
continue
# 使用settings默认设置
try:
return get_supported_language_variant(settings.LANGUAGE_CODE)
except LookupError:
return settings.LANGUAGE_CODE
def get_language_from_request(self, request):
supported = dict(settings.LANGUAGES)
accept = request.META.get('HTTP_ACCEPT_LANGUAGE', '')
for accept_lang, unused in parse_accept_lang_header(accept):
if accept_lang == '*':
break
# We have a very restricted form for our language files
# (no encoding specifier, since they all must be UTF-8 and
# only one possible language each time. So we avoid the
# overhead of gettext.find() and work out the MO file
# manually.
# 'normalized' is the root name of the locale in POSIX
# format (which is the format used for the directories
# holding the MO files).
normalized = locale.locale_alias.get(to_locale(accept_lang, True))
if not normalized:
continue
# Remove the default encoding from locale_alias.
normalized = normalized.split('.')[0]
for lang_code in (accept_lang, accept_lang.split('-')[0]):
lang_code = lang_code.lower()
if lang_code in supported and check_for_language(lang_code):
return lang_code
return None
def get_language_from_request_and_is_from_path(request): # noqa complexity-16
"""
Analyzes the request to find what language the user wants the system to
show. Only languages listed in settings.LANGUAGES are taken into account.
If the user requests a sublanguage where we have a main language, we send
out the main language. It also returns a value to determine if the language code
was derived from a language code in the URL, or inferred from some other source.
:returns: tuple of language code, boolean. The former can be None if the url being
requested does not require translation, otherwise it should be a language code
from the values in settings.LANGUAGES. The boolean should indicate whether the
language code was calculated by reading a language code from the requested URL.
In the case that it was, True should be returned, in the case where the URL language
code was not used or not present, False is returned.
"""
try:
# If this is not a view that needs to be translated, return None, and be done with it!
if not getattr(resolve(request.path_info).func, "translated", False):
return None, False
except Resolver404:
# If this is an unrecognized URL, it may be redirectable to a language prefixed
# URL, so let the language code setting carry on from here.
pass
supported_lang_codes = get_languages()
lang_code = get_language_from_path(request.path_info)
if lang_code in supported_lang_codes and lang_code is not None:
return lang_code, True
if hasattr(request, "session"):
lang_code = request.session.get(LANGUAGE_SESSION_KEY)
if (
lang_code in supported_lang_codes
and lang_code is not None
and check_for_language(lang_code)
):
return lang_code, False
lang_code = request.COOKIES.get(settings.LANGUAGE_COOKIE_NAME)
try:
return get_supported_language_variant(lang_code), False
except LookupError:
pass
device_language = get_device_language()
if device_language is not None:
return device_language, False
headers_language = get_accept_headers_language(request)
if headers_language is not None:
return headers_language, False
return get_settings_language(), False
def get_language_from_session_or_cookie(request: HttpRequest) -> str:
if hasattr(request, 'session'):
lang_code = request.session.get(LANGUAGE_SESSION_KEY)
if lang_code in _supported and lang_code is not None and check_for_language(lang_code):
return lang_code
lang_code = request.COOKIES.get(settings.LANGUAGE_COOKIE_NAME)
try:
return get_supported_language_variant(lang_code)
except LookupError:
pass
def get_language_from_session_or_cookie(request) -> str:
if hasattr(request, 'session'):
lang_code = request.session.get(LANGUAGE_SESSION_KEY)
if lang_code in _supported and lang_code is not None and check_for_language(lang_code):
return lang_code
lang_code = request.COOKIES.get(settings.LANGUAGE_COOKIE_NAME)
try:
return get_supported_language_variant(lang_code)
except LookupError:
pass
def get_supported_language_variant(raw_lang_code):
"""
Returns the language-code that's listed in supported languages, possibly
selecting a more generic variant. Raises LookupError if nothing found.
The function will look for an alternative country-specific variant when the
currently checked language code is not found. In Django, this behaviour can
be avoided with the strict=True parameter, removed in this code.
lru_cache should have a maxsize to prevent from memory exhaustion attacks,
as the provided language codes are taken from the HTTP request. See also
<https://www.djangoproject.com/weblog/2007/oct/26/security-fix/>.
Based on Django 1.11.16's get_supported_language_variant from
django/utils/translation/trans_real.py, with changes:
* Language code can also be a Kuma language code
* Return Kuma languge codes
* Force strict=False to always allow fuzzy matching (zh-CHS gets zh-CN)
"""
if raw_lang_code:
# Kuma: Convert Kuma to Django language code
lang_code = kuma_language_code_to_django(raw_lang_code)
# Kuma: Check for known override
if lang_code in settings.LOCALE_ALIASES:
return settings.LOCALE_ALIASES[lang_code]
# If 'fr-ca' is not supported, try special fallback or language-only 'fr'.
possible_lang_codes = [lang_code]
try:
possible_lang_codes.extend(LANG_INFO[lang_code]['fallback'])
except KeyError:
pass
generic_lang_code = lang_code.split('-')[0]
possible_lang_codes.append(generic_lang_code)
supported_lang_codes = get_django_languages()
# Look for exact match
for code in possible_lang_codes:
if code in supported_lang_codes and check_for_language(code):
# Kuma: Convert to Kuma language code
return django_language_code_to_kuma(code)
# If fr-fr is not supported, try fr-ca.
for supported_code in supported_lang_codes:
if supported_code.startswith(generic_lang_code + '-'):
# Kuma: Convert to Kuma language code
return django_language_code_to_kuma(supported_code)
raise LookupError(raw_lang_code)
def get_supported_language_variant(raw_lang_code):
"""
Returns the language-code that's listed in supported languages, possibly
selecting a more generic variant. Raises LookupError if nothing found.
The function will look for an alternative country-specific variant when the
currently checked language code is not found. In Django, this behaviour can
be avoided with the strict=True parameter, removed in this code.
lru_cache should have a maxsize to prevent from memory exhaustion attacks,
as the provided language codes are taken from the HTTP request. See also
<https://www.djangoproject.com/weblog/2007/oct/26/security-fix/>.
Based on Django 1.11.16's get_supported_language_variant from
django/utils/translation/trans_real.py, with changes:
* Language code can also be a Kuma language code
* Return Kuma languge codes
* Force strict=False to always allow fuzzy matching (zh-CHS gets zh-CN)
"""
if raw_lang_code:
# Kuma: Convert Kuma to Django language code
lang_code = kuma_language_code_to_django(raw_lang_code)
# Kuma: Check for known override
if lang_code in settings.LOCALE_ALIASES:
return settings.LOCALE_ALIASES[lang_code]
# If 'fr-ca' is not supported, try special fallback or language-only 'fr'.
possible_lang_codes = [lang_code]
try:
possible_lang_codes.extend(LANG_INFO[lang_code]['fallback'])
except KeyError:
pass
generic_lang_code = lang_code.split('-')[0]
possible_lang_codes.append(generic_lang_code)
supported_lang_codes = get_django_languages()
# Look for exact match
for code in possible_lang_codes:
if code in supported_lang_codes and check_for_language(code):
# Kuma: Convert to Kuma language code
return django_language_code_to_kuma(code)
# If fr-fr is not supported, try fr-ca.
for supported_code in supported_lang_codes:
if supported_code.startswith(generic_lang_code + '-'):
# Kuma: Convert to Kuma language code
return django_language_code_to_kuma(supported_code)
raise LookupError(raw_lang_code)
def get_language_from_request(request): # noqa complexity-16
"""
Analyzes the request to find what language the user wants the system to
show. Only languages listed in settings.LANGUAGES are taken into account.
If the user requests a sublanguage where we have a main language, we send
out the main language.
If check_path is True, the URL path prefix will be checked for a language
code, otherwise this is skipped for backwards compatibility.
"""
global DEVICE_LANGUAGE
supported_lang_codes = get_languages()
if hasattr(request, 'session'):
lang_code = request.session.get(LANGUAGE_SESSION_KEY)
if lang_code in supported_lang_codes and lang_code is not None and check_for_language(lang_code):
return lang_code
lang_code = request.COOKIES.get(settings.LANGUAGE_COOKIE_NAME)
try:
return get_supported_language_variant(lang_code)
except LookupError:
pass
accept = request.META.get('HTTP_ACCEPT_LANGUAGE', '')
for accept_lang, unused in parse_accept_lang_header(accept):
if accept_lang == '*':
break
if not language_code_re.search(accept_lang):
continue
try:
return get_supported_language_variant(accept_lang)
except LookupError:
continue
try:
if DEVICE_LANGUAGE is None:
DEVICE_LANGUAGE = DeviceSettings.objects.get().language_id
return get_supported_language_variant(DEVICE_LANGUAGE)
except (DeviceSettings.DoesNotExist, LookupError):
pass
try:
return get_supported_language_variant(settings.LANGUAGE_CODE)
except LookupError:
return settings.LANGUAGE_CODE
def set_language(request):
lang_code = request.GET.get('LANGUAGES', 'ru')
lang = get_language()
if not lang_code:
lang_code = request.GET.get('LANGUAGE_CODE', settings.LANGUAGE_CODE)
next_url = request.META.get('HTTP_REFERER', None)
if not is_safe_url:
next_url = '/'
response = http.HttpResponseRedirect(next_url)
if lang_code and check_for_language(lang_code):
if hasattr(request, 'session'):
request.session['django_language'] = lang_code
response.set_cookie(settings.LANGUAGE_COOKIE_NAME, lang_code)
translation.activate(lang_code)
return response
def get_language_from_request(request, check_path=False):
"""
Replacement for django.utils.translation.get_language_from_request.
The portion of code that is modified is identified below with a comment.
"""
if check_path:
lang_code = get_language_from_path(request.path_info)
if lang_code is not None:
return lang_code
lang_code = request.COOKIES.get(settings.LANGUAGE_COOKIE_NAME)
if lang_code is not None and lang_code in get_languages(
) and check_for_language(lang_code):
return lang_code
try:
return get_supported_language_variant(lang_code)
except LookupError:
pass
accept = request.META.get('HTTP_ACCEPT_LANGUAGE', '')
for accept_lang, unused in parse_accept_lang_header(accept):
if accept_lang == '*':
break
# Convert lowercase region to uppercase before attempting to find a variant.
# This is the only portion of code that is modified from the core function.
accept_lang = language_code_to_iso_3166(accept_lang)
if not language_code_re.search(accept_lang):
continue
try:
return get_supported_language_variant(accept_lang)
except LookupError:
continue
try:
return get_supported_language_variant(settings.LANGUAGE_CODE)
except LookupError:
return settings.LANGUAGE_CODE
def get_language_from_user_settings(request: HttpRequest) -> str:
if request.user.is_authenticated:
lang_code = request.user.locale
if lang_code in _supported and lang_code is not None and check_for_language(lang_code):
return lang_code
def get_language_from_user_settings(request) -> str:
if request.user.is_authenticated():
lang_code = request.user.locale
if lang_code in _supported and lang_code is not None and check_for_language(lang_code):
return lang_code
def get_language_from_customer_settings(request: HttpRequest) -> str:
if getattr(request, 'customer', None):
lang_code = request.customer.locale
if lang_code in _supported and lang_code is not None and check_for_language(
lang_code):
return lang_code
