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 get_object(self): path = self.request.GET.get("html_path", None) if path is None: raise ValidationError({"html_path": "Missing value"}) if not path.startswith("/"): path = "/" + path site = Site.find_for_request(self.request) if not site: raise Http404 root_page = site.root_page path_components = [ component for component in path.split("/") if component ] if getattr(settings, 'WAGTAIL_I18N_ENABLED', False): language_from_path = translation.get_language_from_path(path) if language_from_path: path_components.remove(language_from_path) translated_root_page = (root_page.get_translations( inclusive=True).filter( locale__language_code=language_from_path).first()) if not translated_root_page: raise Http404 root_page = translated_root_page page, args, kwargs = root_page.specific.route(self.request, path_components) return page, args, kwargs
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 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 = 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 = 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_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" % (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_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() # 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 render_page(request, url): '''Renders a cms.page object.''' if settings.USE_I18N and not translation.get_language_from_path(url): return redirect('/' + translation.get_language() + url) if hasattr(request, 'user') and request.user.has_module_perms("cms") or \ request.GET.get('cms_dummy_render', None) == public_key(): qs = Page.objects.all() else: qs = Page.objects.live() # don't try to render pages with no template (e.g. those who hold content # for a url resolved elsewhere in the project) qs = qs.exclude(template='') page = get_object_or_404(qs, url=strip_i18n_prefix(url), sites__site_id=settings.SITE_ID) tpl = get_template(page.template) content = tpl.render({ 'page': page, }, request=request) return HttpResponse(content)
def validate_local_url(self, value): value = self.clean_url(value) # If we have i18n pattern in the URLconf, by default it will be # resolved against default language by `LocaleRegexURLResolver`. In # this case, it won't resolve the path /de/catalogue/ when default # language code is "en-gb" and so that path validation won't pass, # which is incorrect. In order to work it around, we extract language # code from URL and override current locale within the locale prefix of # the URL. # # 如果我们在URLconf中有i18n模式,默认情况下它将通过`LocaleRegexURLResolver`解析 # 为默认语言。 在这种情况下,当默认语言代码为“en-gb”时,它将不会解析路 # 径/ de / catalog /,因此路径验证将不会通过,这是不正确的。 为了解决这个问题, # 我们从URL中提取语言代码并覆盖URL的语言环境前缀中的当前语言环境。 urlconf = get_urlconf() i18n_patterns_used, _ = is_language_prefix_patterns_used(urlconf) redefined_language = None if i18n_patterns_used: language = get_language_from_path(value) current_language = get_language() if language != current_language: redefined_language = language if redefined_language: with override(redefined_language): self._validate_url(value) else: self._validate_url(value)
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) 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_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 ( 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 path_translation_enabled(path): location_languages_mapping = get_location_languages_mapping() language_from_path = translation.get_language_from_path( path, supported=SortedDict(settings.LANGUAGES)) if language_from_path: path = path.replace('/%s' % language_from_path, '', 1) return bool(startswithany(path, location_languages_mapping.keys()))
def render_stats( request: HttpRequest, data_url_suffix: str, target_name: str, for_installation: bool = False, remote: bool = False, analytics_ready: bool = True, ) -> HttpResponse: assert request.user.is_authenticated page_params = dict( data_url_suffix=data_url_suffix, for_installation=for_installation, remote=remote, ) request_language = get_and_set_request_language( request, request.user.default_language, translation.get_language_from_path(request.path_info), ) page_params["translation_data"] = get_language_translation_data( request_language) return render( request, "analytics/stats.html", context=dict(target_name=target_name, page_params=page_params, analytics_ready=analytics_ready), )
def process_request(self, request): language = translation.get_language_from_path(request.path_info) if language: translation.activate(language) request.LANGUAGE_CODE = translation.get_language() if language == settings.LANGUAGE_CODE: raise Http404
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 get_language_from_request(request): """ Analyze 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. The URL path prefix will be checked for a language code. """ lang_code = get_language_from_path(request.path_info) if lang_code is not None: return lang_code 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: return None
def process_request(self, request): active_language = None language_from_path = translation.get_language_from_path(request.path) requested_languages = request.META.get('HTTP_ACCEPT_LANGUAGE') if language_from_path: active_language = language_from_path elif requested_languages: requested_languages = requested_languages.split(',') codes = tuple(Language.objects.live().values_list('code', flat=True)) for language in requested_languages: language = language.split(';')[0] active_language = (language if language in codes else None) if active_language is None and language.startswith(codes): active_language = [ code for code in codes if language.startswith(code) ][0] if active_language is not None: break lang_per_site = get_wagtailtrans_setting('LANGUAGES_PER_SITE') if active_language is None and lang_per_site and request.site: site_languages = SiteLanguages.for_site(request.site) if site_languages.default_language: active_language = site_languages.default_language.code if active_language is None: default_language = Language.objects.default() if default_language: active_language = default_language.code else: active_language = settings.LANGUAGE_CODE translation.activate(active_language) request.LANGUAGE_CODE = active_language
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) 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 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): """.""" # 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): 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: HttpRequest, response: HttpResponseBase) -> HttpResponseBase: # This is the same as the default LocaleMiddleware, minus the # logic that redirects 404's that lack a prefixed language in # the path into having a language. See # https://code.djangoproject.com/ticket/32005 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, _ = is_language_prefix_patterns_used(urlconf) if not (i18n_patterns_used and language_from_path): patch_vary_headers(response, ("Accept-Language", )) assert language is not None response.setdefault("Content-Language", language) # An additional responsibility of our override of this middleware is to save the user's language # preference in a cookie. That determination is made by code handling the request # and saved in the set_language flag so that it can be used here. set_language = get_request_notes(request).set_language if set_language is not None: response.set_cookie(settings.LANGUAGE_COOKIE_NAME, set_language) return response
def get_redirect_response(*, redirect: 'Redirect', request: 'HttpRequest', response: 'HttpResponse') -> 'HttpResponse': language_code: str = getattr(request, 'LANGUAGE_CODE', None) path_to_redirect = redirect.new_path if path_to_redirect == '': return HttpResponseGone() if redirect.to_language: language_code = redirect.to_language if language_code: is_default_language = language_code == LANGUAGE_CODE prefixed_default_language = (get_prefixed_default_language( request=request)) if not (is_default_language and not prefixed_default_language): path_to_redirect = f'/{language_code}{path_to_redirect}' # to avoid recursive redirects for same paths with or without specific language to redirect language_from_path = get_language_from_path(request.path_info) or '' if (request.path_info == path_to_redirect and language_from_path == redirect.to_language): return response return (REDIRECT_RESPONSE_CLASSES[redirect.status_code](path_to_redirect))
def process_response(self, request, response): """ Redirect to default tenant language if none is set. """ if response.status_code in [301, 302]: # No need to check for a locale redirect if the response is already a redirect. return response ignore_paths = getattr(settings, 'LOCALE_REDIRECT_IGNORE', None) # Get language from path urlconf = getattr(request, 'urlconf', settings.ROOT_URLCONF) if is_language_prefix_patterns_used(urlconf): language_from_path = translation.get_language_from_path( request.path_info) # If ignore paths or language set, then just pass the response if language_from_path or (ignore_paths and request.path.startswith(ignore_paths)): return response # Redirect to default tenant language lang_code = getattr(get_tenant_properties(), 'LANGUAGE_CODE', None) new_location = '/{0}{1}'.format(lang_code, request.get_full_path()) return http.HttpResponseRedirect(new_location)
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 get_language_from_url_or_default(url: str) -> str: """ Attempt to retrieve the language code from the given URL. If the given URL has no locale prefix, return the default language. """ return translation.get_language_from_path(url) or settings.LANGUAGE_CODE
def strip_language(self, path): language_prefix = get_language_from_path(path) if not language_prefix: return path # strip the language prefix by getting the length of the language # then slice the path return "/" + "/".join(path.split("/")[2:])
def strip_language(self, path): language_prefix = get_language_from_path(path) if not language_prefix: return path # strip the language prefix by getting the length of the language # then slice the path return "/" + "/".join(path.split("/")[len(language_prefix):])
def truncate_language_code_from_path(path): """ Truncates language code from URL-path. """ language_code = get_language_from_path(path) if language_code: return path.replace('/{}'.format(language_code), '', 1) or '/' return path
def process_request(self, request): if self.is_language_prefix_patterns_used(): lang_code = (get_language_from_path(request.path_info) or settings.LANGUAGE_CODE) translation.activate(lang_code) request.LANGUAGE_CODE = translation.get_language()
def process_request(self, request): urlconf = getattr(request, 'urlconf', settings.ROOT_URLCONF) i18n_patterns_used, prefixed_default_language = is_language_prefix_patterns_used(urlconf) language = translation.get_language_from_request(request, check_path=i18n_patterns_used) language_from_path = translation.get_language_from_path(request.path_info) if not language_from_path and i18n_patterns_used and not prefixed_default_language: language = settings.LANGUAGE_CODE translation.activate(language) request.LANGUAGE_CODE = translation.get_language()
def process_request(self, request): check_path = self.is_language_prefix_patterns_used() if check_path and not self.use_redirects: language = trans.get_language_from_path(request.path_info) language = language or self.default_lang else: language = trans.get_language_from_request(request, check_path) trans.activate(language) request.LANGUAGE_CODE = trans.get_language()
def strip_i18n_prefix(path): """Returns path stripped of the language code prefix - i.e. /en/ - if one exists. """ lang_code = translation.get_language_from_path(path) if lang_code: return path[len(lang_code) + 1:] return path
def clean_url(url): parsed = urlsplit(url) try: parts = parsed.path.split('/') except: return url lang = get_language_from_path(parsed.path) if len(parts) > 1 and parts[1] == lang: del parts[1] return urlunsplit((parsed.scheme, parsed.netloc, '/'.join(parts), parsed.query, parsed.fragment))
def get(self, request, *args, **kwargs): # This is a somewhat hackish way of getting the most specific # available language language = translation.get_language_from_path('/{}/'.format( request.user.settings.language)) translation.activate(language) if hasattr(request, 'session'): request.session[translation.LANGUAGE_SESSION_KEY] = language return HttpResponseRedirect(reverse('projects:main'))
def process_request(self, request): check_path = self.is_language_prefix_patterns_used language_path = trans.get_language_from_path(request.path_info) if check_path and not self.use_redirects: language = language_path or self.default_lang else: language = trans.get_language_from_request(request, check_path) if request.META.get('HTTP_USER_AGENT') and 'baiduspider' in request.META['HTTP_USER_AGENT'].lower() and not language_path: language = 'zh-hans' set_language_from_path(language_path) trans.activate(language) request.LANGUAGE_CODE = trans.get_language()
def path_to_slug(path): """ Removes everything from the given URL path, including language code and ``PAGES_SLUG`` if any is set, returning a slug that would match a ``Page`` instance's slug. """ from mezzanine.urls import PAGES_SLUG lang_code = translation.get_language_from_path(path) for prefix in (lang_code, settings.SITE_PREFIX, PAGES_SLUG): if prefix: path = path.replace(prefix, "", 1) return clean_slashes(path) or "/"
def clean_url(url): parsed = urlsplit(url) try: parts = parsed.path.split('/') except: return url lang = get_language_from_path(parsed.path) if len(parts) > 1 and parts[1] == lang: del parts[1] return urlunsplit(( parsed.scheme, parsed.netloc, '/'.join(parts), parsed.query, parsed.fragment))
def get_language_from_request(request, check_path=False): """ 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. """ if microsite.get_value('FORCE_LANG'): return microsite.get_value('FORCE_LANG') if check_path: # Note: django 1.4 implementation of get_language_from_path is OK to use lang_code = translation.get_language_from_path(request.path_info) if lang_code is not None: return lang_code supported_lang_codes = dict(settings.LANGUAGES) if hasattr(request, 'session'): lang_code = request.session.get(LANGUAGE_SESSION_KEY) # Note: django 1.4 implementation of check_for_language is OK to use if lang_code in supported_lang_codes and lang_code is not None and translation.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', '') # broken in 1.4, so defined above 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_operation_language(self, request): # Unfortunately the ?language GET query # has a special meaning on the CMS. # It allows users to see another language while maintaining # the same url. This complicates language detection. site = get_current_site(request) parsed_url = urlparse(request.GET['cms_path']) queries = dict(parse_qsl(parsed_url.query)) language = queries.get('language') if not language: language = translation.get_language_from_path(parsed_url.path) return get_language_code(language, site_id=site.pk)
def process_response(self, request, response): language = translation.get_language() translation.deactivate() if (response.status_code == 404 and not translation.get_language_from_path(request.path_info) and self.is_language_prefix_patterns_used()): return HttpResponseRedirect( '/%s%s' % (language, request.get_full_path())) patch_vary_headers(response, ('Accept-Language',)) if 'Content-Language' not in response: response['Content-Language'] = language return response
def get_admin_site_name(context): """ Get admin site name from request from context. Admin site name is taken from request path: * it is first part of path - between first and second slash if there is no lang prefix * or second part fo path - between second and third slash """ path = context.get('request').path lang = get_language_from_path(path) path = path.split('/') if lang and path[1] == lang: return path[2] return path[1]
def get_language_from_request(request, check_path=False): if check_path: lang_code = translation.get_language_from_path(request.path_info) if lang_code is not None: return lang_code try: lang_code = WriteItInstanceConfig.objects.get(writeitinstance__slug=request.subdomain).default_language except WriteItInstanceConfig.DoesNotExist: lang_code = None if lang_code is not None and translation.check_for_language(lang_code): return lang_code # Call with check_path False as we've already done that above! return translation.get_language_from_request(request, check_path=False)
def path_to_slug(path): """ Removes everything from the given URL path, including language code and ``PAGES_SLUG`` if any is set, returning a slug that would match a ``Page`` instance's slug. """ from mezzanine.urls import PAGES_SLUG lang_code = translation.get_language_from_path(path) for prefix in (lang_code, PAGES_SLUG): if prefix: path = path.replace(prefix, "", 1) if settings.SITE_PREFIX: path = re.sub(settings.SITE_PREFIX, "", path) path = path.strip("/") if settings.APPEND_SLASH else path.lstrip("/") return path or "/"
def path_to_slug(path): """ Removes everything from the given URL path, including language code and ``PAGES_SLUG`` if any is set, returning a slug that would match a ``Page`` instance's slug. """ from mezzanine.urls import PAGES_SLUG # If i18n is disabled Django uses a fake translation object, # returning None for every path. lang_code = translation.get_language_from_path(path) for prefix in (lang_code, settings.SITE_PREFIX, PAGES_SLUG): if prefix: path = path.replace(prefix, "", 1) return path.strip("/") or "/"
def process_request(self, request): # NOTE this is customization 1 --- see comment above. if ('HTTP_ACCEPT_LANGUAGE' in request.META and request.META['HTTP_ACCEPT_LANGUAGE'].lower().startswith('en')): del(request.META['HTTP_ACCEPT_LANGUAGE']) urlconf = getattr(request, 'urlconf', settings.ROOT_URLCONF) i18n_patterns_used, prefixed_default_language \ = backported_is_language_prefix_patterns_used(urlconf) language = translation.get_language_from_request( request, check_path=i18n_patterns_used) language_from_path = translation.get_language_from_path( request.path_info) if (not language and i18n_patterns_used and not prefixed_default_language): language = settings.LANGUAGE_CODE translation.activate(language) request.LANGUAGE_CODE = translation.get_language()
def process_request(self, request): """Redirect to selected language.""" if not request.rsr_page: return None if self.is_i18n_path(request.path): print "{} was i18n path".format(request.path) else: print "{} was not 18n path".format(request.path) language_from_path = translation.get_language_from_path(request.path_info) if not language_from_path: if request.rsr_page.default_language: lang = request.rsr_page.default_language return HttpResponseRedirect('/{}{}'.format(lang, request.path)) return HttpResponseRedirect('/en{}'.format(request.path)) return None
def url_resolves(path): '''Test whether a path resolves successfully, taking language prefixes into account if necessary. Strip url parameters since resolve doesn't account for them correctly. ''' resolved = None path = path.split('?')[0] try: resolved = resolve(path) except Resolver404: lang_code = translation.get_language() lang_from_path = translation.get_language_from_path(path) if not lang_from_path and language_prefix_patterns_used(): lang_path = '/%s%s' % (lang_code, path) try: resolved = resolve(lang_path) except Resolver404: pass return bool(resolved)