Esempio n. 1
0
    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
Esempio n. 2
0
    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
Esempio n. 3
0
    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
Esempio n. 4
0
    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
Esempio n. 5
0
    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
Esempio n. 6
0
    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
Esempio n. 8
0
    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
Esempio n. 9
0
    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
Esempio n. 10
0
    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
Esempio n. 11
0
    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
Esempio n. 12
0
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)
Esempio n. 13
0
    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)
Esempio n. 14
0
    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
Esempio n. 15
0
    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
Esempio n. 16
0
    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
Esempio n. 17
0
    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()))
Esempio n. 19
0
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),
    )
Esempio n. 20
0
 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
Esempio n. 21
0
    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
Esempio n. 22
0
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
Esempio n. 23
0
    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
Esempio n. 24
0
    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
Esempio n. 25
0
    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
Esempio n. 26
0
    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
Esempio n. 27
0
    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
Esempio n. 28
0
    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
Esempio n. 29
0
    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
Esempio n. 30
0
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))
Esempio n. 31
0
    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)
Esempio n. 32
0
    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
Esempio n. 33
0
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
Esempio n. 34
0
    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:])
Esempio n. 35
0
    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):])
Esempio n. 36
0
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
Esempio n. 37
0
    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()
Esempio n. 38
0
 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()
Esempio n. 39
0
 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()
Esempio n. 40
0
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
Esempio n. 41
0
 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()
Esempio n. 42
0
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
Esempio n. 43
0
 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()
Esempio n. 44
0
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))
Esempio n. 45
0
    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'))
Esempio n. 46
0
 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()
Esempio n. 47
0
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 "/"
Esempio n. 48
0
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))
Esempio n. 49
0
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 "/"
Esempio n. 50
0
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)
Esempio n. 52
0
    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
Esempio n. 53
0
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]
Esempio n. 54
0
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)
Esempio n. 55
0
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 "/"
Esempio n. 56
0
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 "/"
Esempio n. 57
0
 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()
Esempio n. 58
0
    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
Esempio n. 59
0
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)