Python HttpRequest.LANGUAGE_CODE方法代码示例

# 需要导入模块: from django.http import HttpRequest [as 别名]
# 或者: from django.http.HttpRequest import LANGUAGE_CODE [as 别名]
def expire_view_cache(view_name, args=[], namespace=None, key_prefix=None, method="GET"):
    """
    This function allows you to invalidate any view-level cache.
        view_name: view function you wish to invalidate or it's named url pattern
        args: any arguments passed to the view function
        namepace: optioal, if an application namespace is needed
        key prefix: for the @cache_page decorator for the function (if any)

        from: http://stackoverflow.com/questions/2268417/expire-a-view-cache-in-django
        added: method to request to get the key generating properly
    """
    from django.core.urlresolvers import reverse
    from django.http import HttpRequest
    from django.utils.cache import get_cache_key
    from django.core.cache import cache
    from django.conf import settings
    # create a fake request object
    request = HttpRequest()
    request.method = method
    if settings.USE_I18N:
        request.LANGUAGE_CODE = settings.LANGUAGE_CODE
    # Loookup the request path:
    if namespace:
        view_name = namespace + ":" + view_name
    request.path = reverse(view_name, args=args)
    # get cache key, expire if the cached item exists:
    key = get_cache_key(request, key_prefix=key_prefix)
    if key:
        if cache.get(key):
            cache.set(key, None, 0)
        return True
    return False

# 需要导入模块: from django.http import HttpRequest [as 别名]
# 或者: from django.http.HttpRequest import LANGUAGE_CODE [as 别名]
    def process_request(self, request: HttpRequest):
        language = get_language_from_request(request)
        if hasattr(request, 'event') and not request.path.startswith(get_script_prefix() + 'control'):
            if language not in request.event.settings.locales:
                firstpart = language.split('-')[0]
                if firstpart in request.event.settings.locales:
                    language = firstpart
                else:
                    language = request.event.settings.locale
                    for lang in request.event.settings.locales:
                        if lang.startswith(firstpart + '-'):
                            language = lang
                            break
        translation.activate(language)
        request.LANGUAGE_CODE = translation.get_language()

        tzname = None
        if request.user.is_authenticated():
            tzname = request.user.timezone
        if hasattr(request, 'event'):
            tzname = request.event.settings.timezone
        if tzname:
            try:
                timezone.activate(pytz.timezone(tzname))
                request.timezone = tzname
            except pytz.UnknownTimeZoneError:
                pass
        else:
            timezone.deactivate()

# 需要导入模块: from django.http import HttpRequest [as 别名]
# 或者: from django.http.HttpRequest import LANGUAGE_CODE [as 别名]
 def make_request(self, path, query=None):
     request = HttpRequest()
     request.method = "GET"
     request.path = path
     request.user = AnonymousUser()
     request.session = {}
     request.LANGUAGE_CODE = settings.LANGUAGE_CODE
     request.META['QUERY_STRING'] = query
     return request

# 需要导入模块: from django.http import HttpRequest [as 别名]
# 或者: from django.http.HttpRequest import LANGUAGE_CODE [as 别名]
def js_templates(language, templates):
    compiled_js = "var underscore_vars={};"
    activate(language)
    request = HttpRequest()
    request.LANGUAGE_CODE = language
    context = RequestContext(request, {'LANGUAGE_CODE': language})
    for (name, template) in templates.iteritems():
        template = loader.get_template(template_name=template)
        text = template.render(context)
        compiled_js += "underscore_vars['%s'] = '%s';\r\n" % (name, escapejs(text))
    return http.HttpResponse(compiled_js, 'text/javascript')

# 需要导入模块: from django.http import HttpRequest [as 别名]
# 或者: from django.http.HttpRequest import LANGUAGE_CODE [as 别名]
    def __call__(self, request: HttpRequest) -> HttpResponseBase:
        domain = request.META.get('HTTP_HOST', '')

        if (not (domain == domain.lower())):
            url = '//{domain}{path}'.format(
                domain=domain.lower(),
                path=request.get_full_path(),
            )
            return redirect(to=url, permanent=(not (django_settings.DEBUG)))

        site = Site.objects.get_current()

        for language_code, language_name in django_settings.LANGUAGES:
            if (domain == "{language_code}.{domain}".format(language_code=language_code, domain=site.domain)):
                translation.activate(language_code)
                request.LANGUAGE_CODE = translation.get_language()
                return self.get_response(request=request)

        try:
            if (request.path == reverse('accounts:set_session')):
                return self.get_response(request=request)
        except NoReverseMatch:
            pass

        if (not (domain == "www.{domain}".format(domain=site.domain))):
            for _site in Site.objects.all().order_by("pk"):
                if (_site.domain in domain):
                    other_site = _site
                    return redirect_to_www(site=other_site)
            other_site = None
            if ("match" in domain):
                other_site = Site.objects.get(pk=django_settings.SPEEDY_MATCH_SITE_ID)
            elif ("composer" in domain):
                other_site = Site.objects.get(pk=django_settings.SPEEDY_COMPOSER_SITE_ID)
            elif ("mail" in domain):
                other_site = Site.objects.get(pk=django_settings.SPEEDY_MAIL_SOFTWARE_SITE_ID)
            else:
                other_site = Site.objects.get(pk=django_settings.SPEEDY_NET_SITE_ID)
            if ((other_site is not None) and (other_site.id in [_site.id for _site in Site.objects.all().order_by("pk")])):
                return redirect_to_www(site=other_site)
            else:
                raise Exception("Unexpected: other_site={}".format(other_site))

        if (not (request.get_full_path() == '/')):
            return redirect_to_www(site=site)

        return language_selector(request=request)

# 需要导入模块: from django.http import HttpRequest [as 别名]
# 或者: from django.http.HttpRequest import LANGUAGE_CODE [as 别名]
def expire_cache(path, args=[], GET={}, HOSTNAME="127.0.0.1:8000", cache_name=None, isview=True, lang_code=None, method='GET'):
    if cache_name is None:
        cache_name = DEFAULT_CACHE_ALIAS
    cache = get_cache(cache_name)
    key_prefix = settings.CACHE_MIDDLEWARE_KEY_PREFIX
    print(key_prefix)
    request = HttpRequest()
    fake_meta = {'HTTP_HOST':HOSTNAME,}
    print(fake_meta['HTTP_HOST'])
    request.META = fake_meta
    request.GET = GET
    if isview:
        request.path = reverse(path, args=args)
    else:
        request.path = path

    language_code = lang_code or getattr(settings, 'LANGUAGE_CODE')
    if language_code:
        request.LANGUAGE_CODE = language_code

    header_key = _generate_cache_header_key(key_prefix, request)

    if not header_key:
        return False

    print(header_key)
    headerlist = cache.get(header_key, None)
    print(headerlist)
    if headerlist is not None:
        cache.set(header_key, None, 0)
        page_key = _generate_cache_key(request, method, headerlist, key_prefix)

        if not page_key:
            return False
        print(cache.get(page_key))
        cache.set(page_key, None, 0)
    return True

# 需要导入模块: from django.http import HttpRequest [as 别名]
# 或者: from django.http.HttpRequest import LANGUAGE_CODE [as 别名]
def language_selector(request: HttpRequest) -> HttpResponseBase:
    translation.activate('en')
    request.LANGUAGE_CODE = translation.get_language()
    return render(request=request, template_name='www/welcome.html')