def post(request): """ Set a cookie to switch language of web site. Tutorial how to set language cookie at https://samulinatri.com/blog/django-translation/ :param request: :type request: :return: :rtype: """ lang = translation.get_language() logger.debug('current language: {}'.format(lang)) logger.debug('check_for_language: de {}, en-us {}, en-gb {}'.format( translation.check_for_language('de'), translation.check_for_language('en-us'), translation.check_for_language('en-gb'))) if lang == 'en-gb' or lang == 'en-us': translation.activate('de') request.session[translation.LANGUAGE_SESSION_KEY] = 'de' else: translation.activate('en-gb') if hasattr(request, 'session'): request.session[translation.LANGUAGE_SESSION_KEY] = 'en-gb' logger.debug('new language: {}'.format(translation.get_language())) logger.debug('translation test: {}'.format( translation.gettext("help"))) response = redirect(DEMO_VAR + '/') response.set_cookie(settings.LANGUAGE_COOKIE_NAME, request.session[translation.LANGUAGE_SESSION_KEY]) return response
def post(request): """ :param request: :type request: :return: :rtype: """ lang = translation.get_language() logger.debug('current language: {}'.format(lang)) logger.debug('check_for_language: de {}, en-us {}, en-gb {}'.format( translation.check_for_language('de'), translation.check_for_language('en-us'), translation.check_for_language('en-gb'))) if lang == 'en-gb' or lang == 'en-us': translation.activate('de') request.session[translation.LANGUAGE_SESSION_KEY] = 'de' else: translation.activate('en-gb') if hasattr(request, 'session'): request.session[translation.LANGUAGE_SESSION_KEY] = 'en-gb' logger.debug('new language: {}'.format(translation.get_language())) logger.debug('translation test: {}'.format( translation.gettext("help"))) return redirect('/')
def process_request(self, request): from django.utils import translation path_tuple = request.path_info.split("/") if len(path_tuple) > 1: if path_tuple[1] in settings.NOT_LANG_URLS: return if check_for_language(path_tuple[1]): lang = path_tuple[1] if hasattr(request, 'session'): request.session['django_language'] = lang request.COOKIES['django_language'] = lang set_default_language(lang) request.path_info = "/" + "/".join(path_tuple[2:]) return if hasattr(request, "session") and "django_language" in request.session: lang = request.session["django_language"] elif hasattr(request, "COOKIE") and "django_language" in request.COOKIE: lang = request.COOKIE["django_language"] elif check_for_language(get_language_from_request(request)): set_default_language(get_language_from_request(request)) lang = get_language_from_request(request) else: lang = settings.LANGUAGES[settings.DEFAULT_LANGUAGE][0] return HttpResponseRedirect('/%s%s' % (lang, request.path_info))
def get_language_from_request(request): global _accepted from django.conf import settings supported = dict(settings.LANGUAGES) # If a previous midleware has decided the language use it if hasattr(request, "LANGUAGE_CODE"): lang_code = request.LANGUAGE_CODE if lang_code in supported and lang_code is not None and translation.check_for_language(lang_code): return lang_code if hasattr(request, "session"): lang_code = request.session.get("django_language", None) if lang_code in supported and lang_code is not None and translation.check_for_language(lang_code): return lang_code lang_code = request.COOKIES.get("django_language") if lang_code and lang_code in supported and translation.check_for_language(lang_code): return lang_code take_browser_prefs = getattr(settings, "USE_BROWSER_LANGUAGE_PREFS", True) if take_browser_prefs: # try get it from browser preferences browser_pref_langs = get_browser_languages(request) for lang_code in browser_pref_langs: if lang_code in supported and translation.check_for_language(lang_code): return lang_code # Initially use the default language return settings.LANGUAGE_CODE
def javascript_catalog(request, domain='djangojs', packages=None): """ Returns the selected language catalog as a javascript library. Receives the list of packages to check for translations in the packages parameter either from an infodict or as a +-delimited string from the request. Default is 'django.conf'. Additionally you can override the gettext domain for this view, but usually you don't want to do that, as JavaScript messages go to the djangojs domain. But this might be needed if you deliver your JavaScript source from Django templates. """ locale = to_locale(get_language()) if request.session and 'django_language' in request.session: if check_for_language(request.session['django_language']): locale = to_locale(request.session['django_language']) if request.GET and 'language' in request.GET: if check_for_language(request.GET['language']): locale = to_locale(request.GET['language']) if packages is None: packages = ['django.conf'] if isinstance(packages, six.string_types): packages = packages.split('+') catalog, plural = get_javascript_catalog(locale, domain, packages) return render_javascript_catalog(catalog, plural)
def change_language(request): """ Redirect to a new hostname when the user wishes for a language change. The user will be redirected to the same page he was before. """ if request.method == 'POST': hostname = request.get_host().split(':')[0] previous_page = request.POST.get('previous-page', '/') # The News category may have articles available only for certain # languages, so we redirect to the News index instead. # BAD: the urls are coded in code, rather than to the sole knowledge # of the urls.py definition. news_url = re.match(r"^/news/.*$", previous_page) if news_url: previous_page = '/news/' news_url = re.match(r"^/blogs/.*$", previous_page) if news_url: previous_page = '/blogs/' news_url = re.match(r"^/blogarticle/.*$", previous_page) if news_url: previous_page = '/blogarticle/' news_url = re.match(r"^/article/.*$", previous_page) if news_url: previous_page = '/article/' new_language = request.POST.get('language') if new_language and translation.check_for_language(new_language): url_regex = re.compile("^(?P<protocol>http[s]?://).*$") uri = request.build_absolute_uri() protocol = url_regex.match(uri).group('protocol') # If the previous language is in the host remove it. # Also if the hostname starts with 'www.' (may appear in the # default language site) remove it so that the language prefix gets # applied to the domain name. previous_language = hostname.split('.', 1)[0] if (translation.check_for_language(previous_language) or previous_language == 'www'): no_language_host = request.get_host().replace( previous_language + '.', '', 1) else: no_language_host = request.get_host() language_prefix = new_language + '.' response = HttpResponseRedirect(protocol + language_prefix + no_language_host + previous_page) else: response = HttpResponseRedirect(previous_page) return response return HttpResponseRedirect('/')
def set_language(request): """ Redirect to a given url while setting the chosen language in the session or cookie. The url and the language code need to be specified in the request parameters. Since this view changes how the user will see the rest of the site, it must only be accessed as a POST request. If called as a GET request, it will redirect to the page in the request (the 'next' parameter) without changing any state. """ next = request.REQUEST.get("next", None) if not next: next = request.META.get("HTTP_REFERER", None) if not next: next = "/" old_lang = get_language() lang_code = request.GET.get("language", None) if lang_code and check_for_language(lang_code): if hasattr(request, "session"): request.session["django_language"] = lang_code else: response.set_cookie(settings.LANGUAGE_COOKIE_NAME, lang_code) path = urlparse(next).path if path[0 : len(old_lang) + 2] == "/%s/" % old_lang: next = re.sub(path, "/%s/" % lang_code + path[len(old_lang) + 2 :], next) path = "/%s/" % lang_code + path[len(old_lang) + 2 :] response = http.HttpResponseRedirect(next) return response
def GET(self): lang_code = self.param('language') next = self.param('next') if (not next) and os.environ.has_key('HTTP_REFERER'): next = os.environ['HTTP_REFERER'] if not next: next = '/' #os.environ['DJANGO_SETTINGS_MODULE'] = 'settings' from django.utils.translation import check_for_language, activate, to_locale, get_language #from django.conf import settings #settings._target = None if lang_code and check_for_language(lang_code): self.blog.language=lang_code ## set settings lang code, and session cookie settings.LANGUAGE_CODE = lang_code if hasattr(self.request, 'session'): self.request.session['django_language'] = lang_code #max_age = 60*60*24*365 #expires = datetime.strftime(datetime.utcnow() + timedelta(seconds=max_age), "%a, %d-%b-%Y %H:%M:%S GMT") #self.response.set_cookie(settings.LANGUAGE_COOKIE_NAME, lang_code, max_age, expires) #activate(self.blog.language) self.blog.save() self.redirect(next)
def handle(self, request, data): response = shortcuts.redirect(request.build_absolute_uri()) print "this is settings data: : '%s'" % data['language'] print "this is settings user_id :::: '%s'" % request.user.id print "this is settings response::::'%s'" % response # Language lang_code = data['language'] if lang_code and translation.check_for_language(lang_code): if hasattr(request, 'session'): request.session['django_language'] = lang_code response.set_cookie(settings.LANGUAGE_COOKIE_NAME, lang_code, expires=_one_year()) # Timezone request.session['django_timezone'] = pytz.timezone( data['timezone']).zone response.set_cookie('django_timezone', data['timezone'], expires=_one_year()) request.session['horizon_pagesize'] = data['pagesize'] response.set_cookie('horizon_pagesize', data['pagesize'], expires=_one_year()) with translation.override(lang_code): messages.success(request, encoding.force_unicode(_("Settings saved."))) return response
def translation_set_language(request, select_language): """ Set and activate a language, if that language is available. """ if translation.check_for_language(select_language): fallback = False else: # The page is in a language that Django has no messages for. # We display anyhow, but fall back to primary language for # other messages and other applications. It is *highly* recommended to # create a new django.po for the language instead of # using this behaviour. select_language = django_settings.LANGUAGES[0][0] fallback = True translation.activate(select_language) request.LANGUAGE_CODE = translation.get_language() if hasattr(request, 'session'): # User has a session, then set this language there if select_language != request.session.get('django_language'): request.session['django_language'] = select_language elif request.method == 'GET' and not fallback: # No session is active. We need to set a cookie for the language # so that it persists when the user changes his location to somewhere # not under the control of the CMS. # Only do this when request method is GET (mainly, do not abort # POST requests) response = HttpResponseRedirect(request.get_full_path()) response.set_cookie(django_settings.LANGUAGE_COOKIE_NAME, select_language) return response
def form_valid(self, form): # Create user instance with fixed username form.instance.username = create_username( form.instance.first_name, form.instance.last_name ) form.instance.is_active = False form.instance.set_password(form.cleaned_data['password1']) form.instance.save() # Create token for mobile API Token.objects.create(user=form.instance) # Create registration link and save along with request params salt = hashlib.md5() salt.update(settings.SECRET_KEY + str(datetime.datetime.now().time)) register_demand = RegisterDemand.objects.create( activation_link = salt.hexdigest(), ip_address = ip.get_ip(self.request), user = form.instance, email = form.instance.email, lang = translation.get_language_from_request(self.request) ) # Create full link to activation page for new user site_url = self.request.build_absolute_uri('/user/activate/') link = site_url + str(register_demand.activation_link) # Send email in user's own language if possible email = emails.ActivationLink() email_context = {'link': link} if translation.check_for_language(register_demand.lang): email_context.update({'lang': register_demand.lang}) email.send(register_demand.email, email_context) return render(self.request, 'userspace/register-success.html', {'title': _("Message send"),})
def set_language(request, next=None): """ Redirect to a given url while setting the chosen language in the session or cookie. The url and the language code need to be specified in the request parameters. Try to save the new language in the User's profile. """ next = next \ or request.REQUEST.get('next', None) \ or request.META.get('HTTP_REFERER', None) \ or '/' response = HttpResponseRedirect(next) if request.method == 'GET' or request.method == 'POST': lang_code = request.REQUEST.get('language', settings.LANGUAGE_CODE) if check_for_language(lang_code): # update the language in the url if it's in there next = change_language_in_path(next, lang_code) response = HttpResponseRedirect(next) set_language_on_response(request, response, lang_code) # try to save language in the user profile if request.user.is_authenticated(): try: user = request.user user.language = lang_code user.save() except: pass return response
def handle(self, request, data): response = shortcuts.redirect(request.build_absolute_uri()) # Language lang_code = data['language'] if lang_code and translation.check_for_language(lang_code): if hasattr(request, 'session'): request.session['django_language'] = lang_code response.set_cookie(settings.LANGUAGE_COOKIE_NAME, lang_code, expires=_one_year()) # Timezone request.session['django_timezone'] = pytz.timezone( data['timezone']).zone response.set_cookie('django_timezone', data['timezone'], expires=_one_year()) request.session['horizon_pagesize'] = data['pagesize'] response.set_cookie('horizon_pagesize', data['pagesize'], expires=_one_year()) request.session['instance_log_length'] = data['instance_log_length'] response.set_cookie('instance_log_length', data['instance_log_length'], expires=_one_year()) with translation.override(lang_code): messages.success(request, encoding.force_text(_("Settings saved."))) return response
def set_language(request, runinfo=None, next=None): """ Change the language, save it to runinfo if provided, and redirect to the provided URL (or the last URL). Can also be used by a url handler, w/o runinfo & next. """ if not next: next = request.REQUEST.get('next', None) if not next: next = request.META.get('HTTP_REFERER', None) if not next: next = '/' response = HttpResponseRedirect(next) response['Expires'] = "Thu, 24 Jan 1980 00:00:00 GMT" if request.method == 'GET': lang_code = request.GET.get('lang', None) if lang_code and translation.check_for_language(lang_code): if hasattr(request, 'session'): request.session['django_language'] = lang_code else: response.set_cookie(settings.LANGUAGE_COOKIE_NAME, lang_code) if runinfo: runinfo.subject.language = lang_code runinfo.subject.save() return response
def javascript_catalog(request, domain='djangojs', packages=None): """ Returns the selected language catalog as a javascript library. Receives the list of packages to check for translations in the packages parameter either from an infodict or as a +-delimited string from the request. Default is 'django.conf'. Additionally you can override the gettext domain for this view, but usually you don't want to do that, as JavaScript messages go to the djangojs domain. But this might be needed if you deliver your JavaScript source from Django templates. """ locale = to_locale(get_language()) if request.GET and 'language' in request.GET: if check_for_language(request.GET['language']): locale = to_locale(request.GET['language']) if packages is None: packages = ['django.conf'] if isinstance(packages, six.string_types): packages = packages.split('+') catalog = None try: catalog, plural = get_javascript_catalog(locale, domain, packages) except TranslationError as ex: # We know how to handle one specific type of error - so let's do # something useful there. if re.match(r'.*duplicate message definition', ex.args[0]): return render_duplicate_error_js(ex.args[0]) raise Exception(ex.msg) return render_javascript_catalog(catalog, plural)
def post(self, request, *args, **kwargs): form_class = self.get_form_class() form = self.get_form(form_class) if form.is_valid(): lang_code = request.POST.get('language', None) next = request.REQUEST.get('next', None) if request.is_ajax(): response = HttpResponse(json.dumps({'success': True}), mimetype='application/json') else: response = HttpResponseRedirect(next) if lang_code and check_for_language(lang_code): if hasattr(request, 'session'): request.session[settings.LANGUAGE_COOKIE_NAME] = lang_code else: response.set_cookie(settings.LANGUAGE_COOKIE_NAME, lang_code) return response if request.is_ajax(): errors = ' '.join(form.non_field_errors()) for fieldname, errorlist in form.errors.items(): if fieldname in form.fields: errors += ' ' + form.fields[fieldname].label + ': ' errors += ' '.join(errorlist) else: errors += ' '.join(errorlist) return HttpResponse(json.dumps({'success': False, 'error_message': errors}), mimetype='application/json') return self.form_invalid(form)
def set_language(request): """ Set_language view from Django. Redirect to a given url while setting the chosen language in the session or cookie. The url and the language code need to be specified in the request parameters. Since this view changes how the user will see the rest of the site, it must only be accessed as a POST request. If called as a GET request, it will redirect to the page in the request (the 'next' parameter) without changing any state. """ next = request.POST.get('next', request.GET.get('next')) if not is_safe_url(url=next, host=request.get_host()): next = request.META.get('HTTP_REFERER') if not is_safe_url(url=next, host=request.get_host()): next = '/' response = http.HttpResponseRedirect(next) if request.method == 'POST': lang_code = request.POST.get('language', None) try: user = get_object_or_404(InoxUser, email=request.user) if user.is_authenticated: user.lang = lang_code user.save() except: pass if lang_code and check_for_language(lang_code): if hasattr(request, 'session'): request.session['django_language'] = lang_code else: response.set_cookie(settings.LANGUAGE_COOKIE_NAME, lang_code) return response
def set_language(request): next = request.REQUEST.get("next", None) if not next: next = "/" url = urlparse(next) try: r = resolve(url.path) except: next = "/" response = http.HttpResponseRedirect(next) lang_code = request.GET.get("language", None) if lang_code and check_for_language(lang_code): translation.activate(lang_code) try: next = reverse("%s" % r.url_name, args=r.args, kwargs=r.kwargs) except: pass else: response = http.HttpResponseRedirect(next) translation.deactivate() if hasattr(request, "session"): request.session["django_language"] = lang_code else: response.set_cookie(settings.LANGUAGE_COOKIE_NAME, lang_code) return response
def set_language(request, language): """ Change the language of session of authenticated user. """ if check_for_language(language): request.session['django_language'] = language
def set_language(request): """ Redirect to a given url while setting the chosen language in the user setting. The url and the language code need to be specified in the request parameters. Since this view changes how the user will see the rest of the site, it must only be accessed as a POST request. If called as a GET request, it will redirect to the page in the request (the 'next' parameter) without changing any state. """ next = request.REQUEST.get('next', None) if not next: next = request.META.get('HTTP_REFERER', None) if not next: next = '/' response = http.HttpResponseRedirect(next) if request.method == 'POST': lang_code = request.POST.get('language', None) if lang_code and translation.check_for_language(lang_code): # We reload to make sure user object is recent request.user.reload() request.user.language = lang_code request.user.save() return response
def set_language(request): """ Redirect to a given url while setting the chosen language in the session or cookie. The url and the language code need to be specified in the request parameters. Since this view changes how the user will see the rest of the site, it must only be accessed as a POST request. If called as a GET request, it will redirect to the page in the request (the 'next' parameter) without changing any state. """ next = request.POST.get('next', request.GET.get('next')) if not is_safe_url(url=next, host=request.get_host()): next = request.META.get('HTTP_REFERER') if not is_safe_url(url=next, host=request.get_host()): next = '/' response = http.HttpResponseRedirect(next) if request.method == 'POST': lang_code = request.POST.get(LANGUAGE_QUERY_PARAMETER) if lang_code and check_for_language(lang_code): next_trans = translate_url(next, lang_code) if next_trans != next: response = http.HttpResponseRedirect(next_trans) if hasattr(request, 'session'): request.session[LANGUAGE_SESSION_KEY] = lang_code # Always set cookie response.set_cookie(settings.LANGUAGE_COOKIE_NAME, lang_code, max_age=settings.LANGUAGE_COOKIE_AGE, path=settings.LANGUAGE_COOKIE_PATH, domain=settings.LANGUAGE_COOKIE_DOMAIN) return response
def set_language(request, next=None): ''' Redirect to a given url while setting the chosen language in the session or cookie. The url and the language code need to be specified in the request parameters. Try to save the new language in the User's profile. ''' next = next \ or get_from_request(request, 'next', None) \ or request.META.get('HTTP_REFERER', None) \ or '/' response = HttpResponseRedirect(next) if request.method == 'GET' or request.method == 'POST': lang_code = get_from_request(request, 'language', settings.LANGUAGE_CODE) if check_for_language(lang_code): # update the language in the url if it's in there next = change_language_in_path(next, lang_code) response = HttpResponseRedirect(next) set_language_on_response(request, response, lang_code) # Try to save language in the user profile, # unless a staff user is logged in as that user (via django-token-auth) if request.user.is_authenticated() and not request.session.get('token_auth_impersonating', False): try: p = request.user.get_profile() p.language = lang_code p.save() except: pass return response
def set_lang(request, new_lang, old_lang=None): # old_langg = get_language_from_request(request, check_path=True) # old_langg = get_language() default_lang = settings.LANGUAGE_CODE splitted = request.META['HTTP_REFERER'].split('/') old_lang = default_lang if check_for_language(splitted[3]): old_lang = splitted[3] if new_lang == old_lang and new_lang == default_lang: print('1') elif new_lang == old_lang and new_lang != default_lang: print('2') splitted[3] = new_lang elif new_lang != old_lang and new_lang != default_lang: print('3') print(splitted) if old_lang == default_lang: splitted.insert(3, new_lang) else: splitted[3] = new_lang elif new_lang != old_lang and new_lang == default_lang: print('4') del splitted[3] elif new_lang != old_lang and new_lang != default_lang: print('5') splitted.insert(3, new_lang) translation.activate(new_lang) request.session[translation.LANGUAGE_SESSION_KEY] = new_lang return redirect('/'.join(splitted))
def local_login(request, redirect_field_name=REDIRECT_FIELD_NAME): """ login """ redirect_to = request.REQUEST.get(redirect_field_name, '') if request.method == 'POST': lang_code = request.POST.get('language', None) form = AuthenticationForm(data=request.POST) if form.is_valid(): if not redirect_to or '//' in redirect_to or ' ' in redirect_to: redirect_to = settings.LOGIN_REDIRECT_URL login(request, form.get_user()) if request.session.test_cookie_worked(): request.session.delete_test_cookie() set_user_addresses(request) if lang_code and check_for_language(lang_code): request.session['django_language'] = lang_code # load default filter if getattr(settings, 'LOAD_BARUWA_DEFAULT_FILTER', None): aday = datetime.timedelta(days=1) yesterday = datetime.date.today() - aday fitem = dict(field='date', filter=3, value=yesterday) if not 'filter_by' in request.session: request.session['filter_by'] = [] if not fitem in request.session['filter_by']: request.session['filter_by'].append(fitem) request.session.modified = True return HttpResponseRedirect(redirect_to) else: form = AuthenticationForm(request) request.session.set_test_cookie() return render_to_response('accounts/login.html', {'form': form, redirect_field_name: redirect_to}, context_instance=RequestContext(request))
def iter_format_modules(lang, format_module_path=None): """Find format modules.""" if not check_for_language(lang): return if format_module_path is None: format_module_path = settings.FORMAT_MODULE_PATH format_locations = [] if format_module_path: if isinstance(format_module_path, str): format_module_path = [format_module_path] for path in format_module_path: format_locations.append(path + ".%s") format_locations.append("django.conf.locale.%s") locale = to_locale(lang) locales = [locale] if "_" in locale: locales.append(locale.split("_")[0]) for location in format_locations: for loc in locales: try: yield import_module("%s.formats" % (location % loc)) except ImportError: pass
def process_request(self, request): """ This builds strongly on django's Locale middleware, so check if it's enabled. This middleware is only relevant with i18n_patterns. """ if self.enable_middleware(): if request.user.is_authenticated(): lang_code = request.user.primary_language if lang_code: # Early redirect based on language to prevent Ember from finding out and redirect after loading a complete page in the wrong language. expected_url_lang_prefix = '/{0}/'.format(lang_code) url_parts = request.path.split('/') if len(url_parts) >= 2: current_url_lang_prefix = url_parts[1] if current_url_lang_prefix in dict(settings.LANGUAGES).keys() and not request.path.startswith(expected_url_lang_prefix): new_location = request.get_full_path().replace('/{0}/'.format(current_url_lang_prefix), expected_url_lang_prefix) return http.HttpResponseRedirect(new_location) # End early redirect. if translation.check_for_language(lang_code): # activate the language translation.activate(lang_code) request.LANGUAGE_CODE = translation.get_language() else: pass #TODO
def set_language(self, code, response=None): if not (self._check_for_language(code) and check_for_language(code)): raise Exception(_("Given language code ({}) is not correct!".format(code))) self.browser_store_manager.set(self.SESSION_APP_LANGUAGE_KEY, code, response=response) self.browser_store_manager.set(LANGUAGE_SESSION_KEY, code, response=response) self.client.language = code self.client.language_obj = DataController.get_language(code)
def handle(self, request, data): response = shortcuts.redirect(request.build_absolute_uri()) lang_code = data['language'] if lang_code and translation.check_for_language(lang_code): response = functions.save_config_value( request, response, settings.LANGUAGE_COOKIE_NAME, lang_code) response = functions.save_config_value( request, response, 'django_timezone', pytz.timezone(data['timezone']).zone) response = functions.save_config_value(request, response, 'API_RESULT_PAGE_SIZE', data['pagesize']) response = functions.save_config_value(request, response, 'INSTANCE_LOG_LENGTH', data['instance_log_length']) with translation.override(lang_code): messages.success(request, encoding.force_text(_("Settings saved."))) return response
def set_language(request): """ Redirect to a given url while setting the chosen language in the session or cookie. The url and the language code need to be specified in the request parameters. Since this view changes how the user will see the rest of the site, it must only be accessed as a POST request. If called as a GET request, it will redirect to the page in the request (the 'next' parameter) without changing any state. """ next = request.POST.get('next', request.GET.get('next')) if not is_safe_url(url=next, host=request.get_host()): next = request.META.get('HTTP_REFERER') if not is_safe_url(url=next, host=request.get_host()): next = '/' response = http.HttpResponseRedirect(next) if request.method == 'POST': lang_code = request.POST.get('language', None) if lang_code and check_for_language(lang_code): next_trans = translate_url(next, lang_code) if next_trans != next: response = http.HttpResponseRedirect(next_trans) if hasattr(request, 'session'): request.session[LANGUAGE_SESSION_KEY] = lang_code else: response.set_cookie(settings.LANGUAGE_COOKIE_NAME, lang_code, max_age=settings.LANGUAGE_COOKIE_AGE, path=settings.LANGUAGE_COOKIE_PATH, domain=settings.LANGUAGE_COOKIE_DOMAIN) return response
def get_supported_language_variant(lang_code, strict=False): """ Returns the language-code that's listed in supported languages, possibly selecting a more generic variant. Raises LookupError if nothing found. If `strict` is False (the default), the function will look for an alternative country-specific variant when the currently checked is not found. lru_cache should have a maxsize to prevent from memory exhaustion attacks, as the provided language codes are taken from the HTTP request. See also <https://www.djangoproject.com/weblog/2007/oct/26/security-fix/>. """ if lang_code: # If 'fr-ca' is not supported, try special fallback or language-only 'fr'. possible_lang_codes = [lang_code] try: # TODO skip this, or import updated LANG_INFO format from __future__ # (fallback option wasn't added until # https://github.com/django/django/commit/5dcdbe95c749d36072f527e120a8cb463199ae0d) possible_lang_codes.extend(LANG_INFO[lang_code]['fallback']) except KeyError: pass generic_lang_code = lang_code.split('-')[0] possible_lang_codes.append(generic_lang_code) supported_lang_codes = dict(settings.LANGUAGES) for code in possible_lang_codes: # Note: django 1.4 implementation of check_for_language is OK to use if code in supported_lang_codes and translation.check_for_language( code): return code if not strict: # if fr-fr is not supported, try fr-ca. for supported_code in supported_lang_codes: if supported_code.startswith(generic_lang_code + '-'): return supported_code raise LookupError(lang_code)
def iter_format_modules(lang, format_module_path=None): """ Does the heavy lifting of finding format modules. """ if not check_for_language(lang): return if format_module_path is None: format_module_path = settings.FORMAT_MODULE_PATH format_locations = [] if format_module_path: if isinstance(format_module_path, six.string_types): format_module_path = [format_module_path] for path in format_module_path: format_locations.append(path + '.%s') format_locations.append('django.conf.locale.%s') locale = to_locale(lang) locales = [locale] if '_' in locale: locales.append(locale.split('_')[0]) for location in format_locations: for loc in locales: try: yield import_module('%s.formats' % (location % loc)) except ImportError: pass
def change_language(request): _next = request.REQUEST.get('next', None) if not _next: _next = request.META.get('HTTP_REFERER', None) if not _next: _next = '/' # если уже есть языковой префикс URL, надо убрать его for supported_language in settings.LANGUAGES: prefix = '/%s/' % supported_language[0] if _next.startswith(prefix): _next = _next[len(prefix):] break language = request.REQUEST.get(u'language', None) if language and check_for_language(language): if _next == '/': # response = HttpResponseRedirect('/') response = HttpResponseRedirect('/%s/' % language) else: response = HttpResponseRedirect('/%s/%s' % (language, _next)) if hasattr(request, 'session'): request.session['django_language'] = language else: response.set_cookie(settings.LANGUAGE_COOKIE_NAME, language) translation.activate(language) return response else: return HttpResponse(status=400)
def prepare_email_content(template, context, tz, language='en'): if not translation.check_for_language(language): language = 'en' with timezone.override(tz), translation.override(language): html_content = None try: html_template = get_template('{}.html.jinja2'.format(template)) html_content = html_template.render(context) except TemplateDoesNotExist: pass try: text_template = get_template('{}.text.jinja2'.format(template)) text_content = text_template.render(context) except TemplateDoesNotExist: if html_content: text_content = generate_plaintext_from_html(html_content) else: raise Exception( 'Nothing to use for text content, no text or html templates available.' ) subject = render_to_string('{}.subject.jinja2'.format(template), context).replace('\n', '') return subject, text_content, html_content
def lang(request, lang_code): next = request.POST.get('next', request.GET.get('next')) if (next or not request.is_ajax()) and not is_safe_url( url=next, host=request.get_host()): next = request.META.get('HTTP_REFERER') if next: next = urlunquote(next) # HTTP_REFERER may be encoded. if not is_safe_url(url=next, host=request.get_host()): next = '/' response = HttpResponseRedirect(next) if next else HttpResponse(status=204) if lang_code and check_for_language(lang_code): if next: # Ниже идёт пояснение MySettings.LANGUAGES for code_tuple in MySettings.LANGUAGES: settings_lang_code = "/" + code_tuple[0] parsed = urlsplit(next) if parsed.path.startswith(settings_lang_code): path = re.sub('^' + settings_lang_code, '', parsed.path) next = urlunsplit((parsed.scheme, parsed.netloc, path, parsed.query, parsed.fragment)) response = HttpResponseRedirect(next) if hasattr(request, 'session'): request.session[LANGUAGE_SESSION_KEY] = lang_code else: response.set_cookie( settings.LANGUAGE_COOKIE_NAME, lang_code, max_age=settings.LANGUAGE_COOKIE_AGE, path=settings.LANGUAGE_COOKIE_PATH, domain=settings.LANGUAGE_COOKIE_DOMAIN, ) return response
def validate_language_id(self, language_id): """ Check that the language_id is supported by Kolibri """ if not check_for_language(language_id): raise serializers.ValidationError(_("Language is not supported by Kolibri")) return language_id
def set_lang(request): next = request.POST.get('next', request.GET.get('next')) if ((next or not request.is_ajax()) and not is_safe_url(url=next, allowed_hosts={request.get_host()}, require_https=request.is_secure())): next = request.META.get('HTTP_REFERER') next = next and unquote(next) # HTTP_REFERER may be encoded. if not is_safe_url(url=next, allowed_hosts={request.get_host()}, require_https=request.is_secure()): next = '/' response = HttpResponseRedirect(next) if next else HttpResponse(status=204) if request.method == 'POST': lang_code = request.POST.get(LANGUAGE_QUERY_PARAMETER) if lang_code and check_for_language(lang_code): if next: next_trans = translate_url(next, lang_code) response = HttpResponseRedirect(next_trans + "position") if hasattr(request, 'session'): request.session[LANGUAGE_SESSION_KEY] = lang_code response.set_cookie( settings.LANGUAGE_COOKIE_NAME, lang_code, max_age=settings.LANGUAGE_COOKIE_AGE, path=settings.LANGUAGE_COOKIE_PATH, domain=settings.LANGUAGE_COOKIE_DOMAIN, ) return response
def changelang(request, code=False, category=False, goasubcategory=False): if code and check_for_language(code): request.session[LANGUAGE_SESSION_KEY] = code activate(code) if category and goasubcategory: return redirect(reverse('categoryandsub', kwargs={'goacategory':category, 'goasubcategory':goasubcategory})) elif category: return redirect(reverse('onlycategory', kwargs={'goacategory':category})) else: returned = request.META.get('HTTP_REFERER', False) if returned: if 'showbookmark' in returned: return redirect(reverse('showbookmark')) elif 'classifieds' in returned: return redirect(reverse('onlyclassifieds')) elif 'addclassified' in returned: return redirect(reverse('addclassif')) elif 'updatepassword' in returned: return redirect(reverse('updatepassword', args=[request.user])) elif 'updateuser' in returned: return redirect(reverse('updateuser', args=[request.user])) elif 'userpage' in returned: return redirect(reverse('userpage', args=[request.user])) elif 'login' in returned: return redirect(reverse('goalogin')) elif 'remind-password' in returned: return redirect(reverse('remind-password')) else: return redirect('/') else: return redirect('/')
def set_language(request): next = None if request.method == 'GET': next = request.GET.get('next', None) elif request.method == 'POST': next = request.POST.get('next', None) if not next: next = request.META.get('HTTP_REFERER', None) if not next: next = '/' response = HttpResponseRedirect(next) if request.method == 'GET': lang_code = request.GET.get('language', None) if lang_code and check_for_language(lang_code): if hasattr(request, 'session'): request.session["blueking_language"] = lang_code max_age = 60 * 60 * 24 * 365 expires = datetime.datetime.strftime( datetime.datetime.utcnow() + datetime.timedelta(seconds=max_age), "%a, %d-%b-%Y %H:%M:%S GMT") response.set_cookie(settings.LANGUAGE_COOKIE_NAME, lang_code, max_age, expires) return response
def set_language(self, request): """ Redirect to a given url while setting the chosen language in the session or cookie. The url and the language code need to be specified in the request parameters. Since this view changes how the user will see the rest of the site, it must only be accessed as a POST request. If called as a GET request, it will redirect to the page in the request (the 'next' parameter) without changing any state. """ from django.conf import settings as lazy_settings response = Response({'success': True}, status=status.HTTP_200_OK) lang_code = request.data['language'] if lang_code and check_for_language(lang_code): if hasattr(request, 'session'): request.session[LANGUAGE_SESSION_KEY] = lang_code else: response.set_cookie( lazy_settings.LANGUAGE_COOKIE_NAME, lang_code, max_age=lazy_settings.LANGUAGE_COOKIE_AGE, path=lazy_settings.LANGUAGE_COOKIE_PATH, domain=lazy_settings.LANGUAGE_COOKIE_DOMAIN) return response
def process_response(self, request, response): if request.method == 'POST': language = request.POST.get('language') action = request.POST.get('action') if action == 'set_language' and check_for_language(language): host = request.get_host() next_url = request.GET.get('next', None) referer = request.META.get('HTTP_REFERER', None) if next_url: if is_safe_url(url = next_url, host = host): response = HttpResponseRedirect(next_url) elif referer: if is_safe_url(url = referer, host = host): referer_url = urlparse(referer)[2] try: # http://wenda.soso.io/questions/275666/django-templates-get-current-url-in-another-language view = resolve(referer_url) with translation.override(language): next_url = reverse(view.view_name, args = view.args, kwargs = view.kwargs) response = HttpResponseRedirect(next_url) except (Resolver404, NoReverseMatch): pass if hasattr(request, 'session'): request.session[translation.LANGUAGE_SESSION_KEY] = language else: response.set_cookie(settings.LANGUAGE_COOKIE_NAME, language, max_age = settings.LANGUAGE_COOKIE_AGE, path = settings.LANGUAGE_COOKIE_PATH, domain = settings.LANGUAGE_COOKIE_DOMAIN) return response
def set_language(request): """ It does everything in the django set_language, plus assigning language to request.user.profile. Below is the behavior of django set_languate: Redirect to a given url while setting the chosen language in the session or cookie. The url and the language code need to be specified in the request parameters. Since this view changes how the user will see the rest of the site, it must only be accessed as a POST request. If called as a GET request, it will redirect to the page in the request (the 'next' parameter) without changing any state. """ if not settings.USE_I18N: raise Http404 response = dj_set_language(request) if request.method == 'POST': lang_code = request.POST.get('language', None) if lang_code and check_for_language(lang_code): profile = request.user.profile profile.language = lang_code profile.save() return response
def index(request, sitemaps, template_name='sitemap_index.xml', content_type='application/xml', sitemap_url_name='civmaps.views.sitemap'): req_protocol = request.scheme req_site = get_current_site(request) code = request.META.get('HTTP_HOST', '').split('.')[0] if translation.check_for_language(code): code = code + '.' else: code = '' sites = [] for section, site in sitemaps.items(): if callable(site): site = site() protocol = req_protocol if site.protocol is None else site.protocol sitemap_url = urlresolvers.reverse( sitemap_url_name, kwargs={'section': section}) absolute_url = '%s://%s%s%s' % (protocol, code, req_site.domain, sitemap_url) sites.append(absolute_url) for page in range(2, site.paginator.num_pages + 1): sites.append('%s?p=%s' % (absolute_url, page)) return TemplateResponse(request, template_name, {'sitemaps': sites}, content_type=content_type)
def set_language(request): """ Redirect to a given url while setting the chosen language in the session or cookie. The url and the language code need to be specified in the request parameters. Since this view changes how the user will see the rest of the site, it must only be accessed as a POST request. If called as a GET request, it will redirect to the page in the request (the 'next' parameter) without changing any state. """ next = request.REQUEST.get('next', None) if not next: next = request.META.get('HTTP_REFERER', None) if not next: next = '/' response = http.HttpResponseRedirect(next) if request.method == 'POST': lang_code = request.POST.get('language', None) if lang_code and check_for_language(lang_code): if hasattr(request, 'session'): request.session['django_language'] = lang_code else: response.set_cookie(settings.LANGUAGE_COOKIE_NAME, lang_code) return response
def language_for_user(user): language = user.language if not translation.check_for_language(language): language = 'en' return language
def get_format_modules(reverse=False): """ Returns an iterator over the format modules found in the project and Django """ modules = [] if not check_for_language(get_language()) or not settings.USE_L10N: return modules locale = to_locale(get_language()) if settings.FORMAT_MODULE_PATH: format_locations = [settings.FORMAT_MODULE_PATH + '.%s'] else: format_locations = [] format_locations.append('django.conf.locale.%s') for location in format_locations: for l in (locale, locale.split('_')[0]): try: mod = import_module('.formats', location % l) except ImportError: pass else: # Don't return duplicates if mod not in modules: modules.append(mod) if reverse: modules.reverse() return modules
def setlang_custom(request): """ In this React app, I'm using fetch API to do AJAX requests, and in this particular case I have to use a custom i18n function because: - For some reason I can't make 'request.POST.get(LANGUAGE_QUERY_PARAMETER)' work with fetch - I need to set the 'django_language' cookie, even if I have a session. This code is based on set_language(): https://github.com/django/django/blob/stable/1.10.x/django/views/i18n.py#L28 """ lang_code = request.GET.get('lang') current_page = request.META.get('HTTP_REFERER') log.debug(lang_code) log.debug(current_page) response = HttpResponseRedirect(current_page) if check_for_language(lang_code): # I need both session... request.session[LANGUAGE_SESSION_KEY] = lang_code # AND cookies ! response.set_cookie(settings.LANGUAGE_COOKIE_NAME, lang_code, max_age=settings.LANGUAGE_COOKIE_AGE, path=settings.LANGUAGE_COOKIE_PATH, domain=settings.LANGUAGE_COOKIE_DOMAIN) return response
def __setitem__(self, item, value): """ 修改一个系统配置项的值到用户个性化设置中,这主要用于系统运行期保存一些个性化的参数设置。 """ if self.__getitem__(item) == value: return if item in self._cache: self._cache.pop(item) op = threadlocals.get_current_user() if op and op.is_anonymous(): op = None items = item.split(".", 1) opt = Option.objects.get(app_label=items[0], name=items[1]) try: p_opt = PersonalOption.objects.get(option=opt, user=op) except ObjectDoesNotExist: p_opt = PersonalOption(option=opt, user=op) #create it if not exists if not (p_opt.value == value): p_opt.value = value p_opt.save() if item == 'base.language': from django.utils.translation import check_for_language, activate, get_language request = threadlocals.get_current_request() if request: lang_code = value if lang_code and check_for_language(lang_code): if hasattr(request, 'session'): request.session['django_language'] = lang_code activate(lang_code) request.LANGUAGE_CODE = get_language() self._cache[item] = value
def lang(request, code): next = request.META.get('HTTP_REFERER', '/') response = HttpResponseRedirect(next) if code and translation.check_for_language(code): request.session[translation.LANGUAGE_SESSION_KEY] = code translation.activate(code) return response
def notify_message_push_subscribers_with_language(message, subscriptions, language): conversation = message.conversation if not translation.check_for_language(language): language = 'en' with translation.override(language): message_title = get_message_title(message, language) if message.is_thread_reply(): click_action = frontend_urls.thread_url(message.thread) else: click_action = frontend_urls.conversation_url(conversation, message.author) notify_subscribers_by_device( subscriptions, click_action=click_action, fcm_options={ 'message_title': message_title, 'message_body': Truncator(message.content).chars(num=1000), # this causes each notification for a given conversation to replace previous notifications # fancier would be to make the new notifications show a summary not just the latest message 'tag': 'conversation:{}'.format(conversation.id), })
def set_language_ex(request): next = request.POST.get('next', request.GET.get('next')) if not is_safe_url(url=next, host=request.get_host()): next = request.META.get('HTTP_REFERER') if not is_safe_url(url=next, host=request.get_host()): next = '/' # remove lang from query scheme, netloc, path, query, fragment = urlparse.urlsplit(next) parsed_query = urlparse.parse_qsl(query) altered = False for k, v in parsed_query[:]: if LANG_GET_KEY == k: parsed_query.remove((k, v)) altered = True if altered: query = urllib.urlencode(parsed_query) next = urlparse.urlunsplit((scheme, netloc, path, query, fragment)) response = http.HttpResponseRedirect(next) if request.method == 'POST': lang_code = request.POST.get('language', None) if lang_code and check_for_language(lang_code): if hasattr(request, 'session'): request.session[LANGUAGE_SESSION_KEY] = lang_code else: response.set_cookie(settings.LANGUAGE_COOKIE_NAME, lang_code, max_age=settings.LANGUAGE_COOKIE_AGE, path=settings.LANGUAGE_COOKIE_PATH, domain=settings.LANGUAGE_COOKIE_DOMAIN) return response
def set_language(request): """ Redirect to a given url while setting the chosen language in the session and cookie. The url and the language code need to be specified in the request parameters. The cookie will have a long expiration date (1 year) for future visits Since this view changes how the user will see the rest of the site, it must only be accessed as a POST request. If called as a GET request, it will redirect to the page in the request (the 'next' parameter) without changing any state. """ next = request.GET.get('next', None) if not next: next = request.POST.get('next', None) if not next: next = request.META.get('HTTP_REFERER', None) if not next: next = '/' response = http.HttpResponseRedirect(next) if request.method == 'POST': lang_code = request.POST.get('language', None) if lang_code and check_for_language(lang_code): response.set_cookie(settings.LANGUAGE_COOKIE_NAME, lang_code, 365*24*60*60) return response
def get_supported_content_language_variant(lang_code, strict=False): """ Return the language code that's listed in supported languages, possibly selecting a more generic variant. Raise LookupError if nothing is found. If `strict` is False (the default), look for a country-specific variant when neither the language code nor its generic variant is found. lru_cache should have a maxsize to prevent from memory exhaustion attacks, as the provided language codes are taken from the HTTP request. See also <https://www.djangoproject.com/weblog/2007/oct/26/security-fix/>. This is equvilant to Django's `django.utils.translation.get_supported_content_language_variant` but reads the `WAGTAIL_CONTENT_LANGUAGES` setting instead. """ if lang_code: # If 'fr-ca' is not supported, try special fallback or language-only 'fr'. possible_lang_codes = [lang_code] try: possible_lang_codes.extend(LANG_INFO[lang_code]["fallback"]) except KeyError: pass generic_lang_code = lang_code.split("-")[0] possible_lang_codes.append(generic_lang_code) supported_lang_codes = get_content_languages() for code in possible_lang_codes: if code in supported_lang_codes and check_for_language(code): return code if not strict: # if fr-fr is not supported, try fr-ca. for supported_code in supported_lang_codes: if supported_code.startswith(generic_lang_code + "-"): return supported_code raise LookupError(lang_code)
def get_supported_language_variant(lang_code, supported=None, strict=False): """ Returns the language-code that's listed in supported languages, possibly selecting a more generic variant. Raises LookupError if nothing found. If `strict` is False (the default), the function will look for an alternative country-specific variant when the currently checked is not found. """ if supported is None: from django.conf import settings supported = SortedDict(settings.LANGUAGES) if lang_code: # if fr-CA is not supported, try fr-ca; if that fails, fallback to fr. generic_lang_code = lang_code.split("-")[0] variants = ( lang_code, lang_code.lower(), generic_lang_code, generic_lang_code.lower(), ) for code in variants: if code in supported and translation.check_for_language( code): return code if not strict: # if fr-fr is not supported, try fr-ca. for supported_code in supported: if supported_code.startswith( (generic_lang_code + "-", generic_lang_code.lower() + "-")): return supported_code raise LookupError(lang_code)
def javascript_catalog(request, domain='djangojs', packages=None): """ Returns the selected language catalog as a javascript library. Receives the list of packages to check for translations in the packages parameter either from an infodict or as a +-delimited string from the request. Default is 'django.conf'. Additionally you can override the gettext domain for this view, but usually you don't want to do that, as JavaScript messages go to the djangojs domain. But this might be needed if you deliver your JavaScript source from Django templates. """ locale = to_locale(get_language()) if request.GET and 'language' in request.GET: if check_for_language(request.GET['language']): locale = to_locale(request.GET['language']) if packages is None: packages = ['django.conf'] if isinstance(packages, six.string_types): packages = packages.split('+') catalog, plural = get_javascript_catalog(locale, domain, packages) return render_javascript_catalog(catalog, plural)
def get(self, request): next = "/" if "next" in request.GET: next = request.GET.get("next") response = HttpResponseRedirect(next) if not request.GET: return response form = forms.LanguageCodeForm(data=request.GET) if not form.is_valid(): return response language = form.cleaned_data['language'] if not translation.check_for_language(language): return response if hasattr(request, "session"): request.session[translation.LANGUAGE_SESSION_KEY] = language else: response.set_cookie(settings.LANGUAGE_COOKIE_NAME, language) translation.activate(language) return response