def get_day(self): if translation.get_language() == 'sr-latn': return self.day.day_sr if translation.get_language() == 'hu': return self.day.day_hu if translation.get_language() == 'en': return self.day.day_en
def test_rule3(self): """ Basic CharField/TextField test. Could as well call _test_field, just kept for reference. """ title1_de = "title de" title1_en = "title en" n = TestModel.objects.create(title_de=title1_de, title_en=title1_en) self.failUnlessEqual(get_language(), "de") self.failUnlessEqual(n.title, title1_de) self.failUnlessEqual(n.title_de, title1_de) self.failUnlessEqual(n.title_en, title1_en) n.title_de = "Neuer Titel" n.save() self.failUnlessEqual(n.title, n.title_de) # Now switch to "en" trans_real.activate("en") self.failUnlessEqual(get_language(), "en") n.title_en = "New title" # the n.title field is not updated before the instance is saved n.save() self.failUnlessEqual(n.title, n.title_en) trans_real.deactivate()
def test_rule2(self): """ Basic CharField/TextField test. Could as well call _test_field, just kept for reference. """ self.failUnlessEqual(get_language(), "de") title1_de = "title de" title1_en = "title en" n = TestModel.objects.create(title_de=title1_de, title_en=title1_en) self.failUnlessEqual(n.title, title1_de) self.failUnlessEqual(n.title_de, title1_de) self.failUnlessEqual(n.title_en, title1_en) title2 = "Neuer Titel" n.title = title2 n.save() self.failUnlessEqual(n.title, title2) self.failUnlessEqual(n.title, n.title_de) trans_real.activate("en") self.failUnlessEqual(get_language(), "en") title3 = "new title" n.title = title3 n.title_de = title1_de n.save() self.failUnlessEqual(n.title, title3) self.failUnlessEqual(n.title, n.title_en) self.failUnlessEqual(title1_de, n.title_de) trans_real.deactivate()
def get_meeting_type(self): if translation.get_language() == 'sr-latn': return u'%s' % (self.meeting_type.meeting_name_sr, ) if translation.get_language() == 'hu': return u'%s' % (self.meeting_type.meeting_name_hu, ) if translation.get_language() == 'en': return u'%s' % (self.meeting_type.meeting_name_en, )
def _test_field(self, field_name, value1_de, value1_en, value2, value3, deactivate=True): field_name_de = '%s_de' % field_name field_name_en = '%s_en' % field_name params = {'title_de': 'title de', 'title_en': 'title en'} params[field_name_de] = value1_de params[field_name_en] = value1_en n = TestModel.objects.create(**params) self.failUnlessEqual(get_language(), "de") self.failUnlessEqual(getattr(n, field_name), value1_de) self.failUnlessEqual(getattr(n, field_name_de), value1_de) self.failUnlessEqual(getattr(n, field_name_en), value1_en) setattr(n, field_name, value2) n.save() self.failUnlessEqual(getattr(n, field_name), getattr(n, field_name_de)) # Now switch to "en" trans_real.activate("en") self.failUnlessEqual(get_language(), "en") setattr(n, field_name_en, value3) # the n.title field is not updated before the instance is saved n.save() self.failUnlessEqual(getattr(n, field_name), getattr(n, field_name_en)) if deactivate: trans_real.deactivate()
def _test_field(self, field_name, value_de, value_en, deactivate=True): field_name_de = '%s_de' % field_name field_name_en = '%s_en' % field_name params = {'title_de': 'title de', 'title_en': 'title en'} params[field_name_de] = value_de params[field_name_en] = value_en n = TestModel.objects.create(**params) # Language is set to "de" at this point self.failUnlessEqual(get_language(), "de") self.failUnlessEqual(getattr(n, field_name), value_de) self.failUnlessEqual(getattr(n, field_name_de), value_de) self.failUnlessEqual(getattr(n, field_name_en), value_en) # Now switch to "en" trans_real.activate("en") self.failUnlessEqual(get_language(), "en") # Should now be return the english one (just by switching the language) self.failUnlessEqual(getattr(n, field_name), value_en) n = TestModel.objects.create(**params) n.save() # Language is set to "en" at this point self.failUnlessEqual(getattr(n, field_name), value_en) self.failUnlessEqual(getattr(n, field_name_de), value_de) self.failUnlessEqual(getattr(n, field_name_en), value_en) trans_real.activate("de") self.failUnlessEqual(get_language(), "de") self.failUnlessEqual(getattr(n, field_name), value_de) if deactivate: trans_real.deactivate()
def _test_field(self, field_name, value1_de, value1_en, value2, value3, deactivate=True): field_name_de = '%s_de' % field_name field_name_en = '%s_en' % field_name params = {'title_de': 'title de', 'title_en': 'title en'} params[field_name_de] = value1_de params[field_name_en] = value1_en self.failUnlessEqual(get_language(), "de") n = TestModel.objects.create(**params) self.failUnlessEqual(getattr(n, field_name), value1_de) self.failUnlessEqual(getattr(n, field_name_de), value1_de) self.failUnlessEqual(getattr(n, field_name_en), value1_en) setattr(n, field_name, value2) n.save() self.failUnlessEqual(getattr(n, field_name), value2) self.failUnlessEqual(getattr(n, field_name), getattr(n, field_name_de)) trans_real.activate("en") self.failUnlessEqual(get_language(), "en") setattr(n, field_name, value3) setattr(n, field_name_de, value1_de) n.save() self.failUnlessEqual(getattr(n, field_name), value3) self.failUnlessEqual(getattr(n, field_name), getattr(n, field_name_en)) self.failUnlessEqual(value1_de, getattr(n, field_name_de)) if deactivate: trans_real.deactivate()
def i18n(request): return { 'LANGUAGES': settings.LANGUAGES, 'LANG': (settings.LANGUAGE_URL_MAP.get(translation.get_language()) or translation.get_language()), 'DIR': 'rtl' if translation.get_language_bidi() else 'ltr', }
def get_template_sources(self, template_name, template_dirs=None): """ Returns the absolute paths to "template_name", when appended to each directory in "template_dirs". Any paths that don't lie inside one of the template dirs are excluded from the result set, for security reasons. If current language is not default, prepend each path with language name. E.g. 'include/banner.html' would become 'de/include/banner.html' """ if not template_dirs: template_dirs = settings.TEMPLATE_DIRS if get_language() != settings.LANGUAGE_CODE: lang = get_language() new_dirs = [] for i in template_dirs: new_dirs.extend([safe_join(i, lang), i]) template_dirs = new_dirs for template_dir in template_dirs: try: yield safe_join(template_dir, template_name) except UnicodeDecodeError: # The template dir name was a bytestring that wasn't valid UTF-8. raise except ValueError: # The joined path was located outside of this particular # template_dir (it might be inside another one, so this isn't # fatal). pass
def test_activate_locale(self): eq_(translation.get_language(), 'en-us') with UserProfile(username='******').activate_lang(): eq_(translation.get_language(), 'en-us') with UserProfile(username='******', lang='fr').activate_lang(): eq_(translation.get_language(), 'fr')
def translate_commit_desc(value): """Translate commit description.""" if value.startswith('Reverted repo'): # Change 'repo' to 'library' in revert commit msg, since 'repo' is # only used inside of seafile system. value = value.replace('repo', 'library') # Do nothing if current language is English. if translation.get_language() == 'en': return value if value.startswith('Reverted library'): return value.replace('Reverted library to status at', _('Reverted library to status at')) elif value.startswith('Reverted file'): def repl(matchobj): return _('Reverted file "%(file)s" to status at %(time)s.') % \ {'file':matchobj.group(1), 'time':matchobj.group(2)} return re.sub('Reverted file "(.*)" to status at (.*)', repl, value) elif value.startswith('Recovered deleted directory'): return value.replace('Recovered deleted directory', _('Recovered deleted directory')) elif value.startswith('Changed library'): return value.replace('Changed library name or description', _('Changed library name or description')) elif value.startswith('Merged') or value.startswith('Auto merge'): return _('Auto merge by seafile system') else: # Use regular expression to translate commit description. # Commit description has two forms, e.g., 'Added "foo.txt" and 3 more files.' or 'Added "foo.txt".' operations = '|'.join(COMMIT_MSG_TRANSLATION_MAP.keys()) patt = r'(%s) "(.*)"\s?(and ([0-9]+) more (files|directories))?' % operations ret_list = [] for e in value.split('\n'): if not e: continue m = re.match(patt, e) if not m: ret_list.append(e) continue op = m.group(1) # e.g., "Added" op_trans = _(op) file_name = m.group(2) # e.g., "foo.txt" has_more = m.group(3) # e.g., "and 3 more files" n_files = m.group(4) # e.g., "3" more_type = m.group(5) # e.g., "files" if has_more: if translation.get_language() == 'zh-cn': typ = u'文件' if more_type == 'files' else u'目录' ret = op_trans + u' "' + file_name + u'"以及另外' + n_files + u'个' + typ + '.' # elif translation.get_language() == 'ru': # ret = ... else: ret = e else: ret = op_trans + u' "' + file_name + u'".' ret_list.append(ret) return '\n'.join(ret_list)
def save(self, commit=True): ''' Saves the model If will always use the language specified in self.cleaned_data, with the usual None meaning 'call get_language()'. If instance has another language loaded, it gets reloaded with the new language. If no language is specified in self.cleaned_data, assume the instance is preloaded with correct language. ''' assert self.is_valid(), ('Method save() must not be called on an invalid ' 'form. Check the result of .is_valid() before ' 'calling save().') # Get the right translation for object and language # It should have been done in _post_clean, but instance may have been # changed since. enforce = 'language_code' in self.cleaned_data if getattr(self, 'is_edit', False): language = self.language or get_language() else: language = self.cleaned_data.get('language_code') or get_language() translation = load_translation(self.instance, language, enforce) # Fill the translated fields with values from the form excludes = list(self._meta.exclude) + ['master', 'language_code'] translation = construct_instance(self, translation, self._meta.fields, excludes) if getattr(self, 'is_edit', False): translation.language_code = \ self.cleaned_data.get('language_code', None) or self.new_lang set_cached_translation(self.instance, translation) # Delegate shared fields to super() return super(BaseTranslatableModelForm, self).save(commit=commit)
def preferences(request): if request.method == 'POST': form = PreferencesForm(request.POST) if form.is_valid(): try: newdata = form.cleaned_data request.user.language = newdata['language'] request.user.theme = newdata['theme'] request.user.pagesize = newdata['pagesize'] request.user.save() # Switch to the new theme and language immediately request.theme = newdata['theme'] if newdata['language'] == 'auto': newdata['language'] = translation.get_language_from_request(request) if translation.get_language() != newdata['language']: translation.activate(newdata['language']) request.LANGUAGE_CODE = translation.get_language() messages.add_message(request, messages.INFO, force_unicode(_('Successfully updated preferences'))) except Exception as e: logger.error("Failure updating preferences: %s" % e) messages.add_message(request, messages.ERROR, force_unicode(_('Failure updating preferences'))) else: pref = request.user form = PreferencesForm({ 'language': pref.language, 'theme': pref.theme, 'pagesize': pref.pagesize, }) return render_to_response('common/preferences.html', { 'title': _('Edit my preferences'), 'form': form, }, context_instance=RequestContext(request))
def _get_placeholder(current_page, page, context, name): placeholder_cache = getattr(current_page, '_tmp_placeholders_cache', {}) if page.pk in placeholder_cache: placeholder = placeholder_cache[page.pk].get(name, None) if placeholder: return placeholder placeholder_cache[page.pk] = {} placeholders = page.rescan_placeholders().values() fetch_placeholders = [] request = context['request'] if not get_cms_setting('PLACEHOLDER_CACHE') or (hasattr(request, 'toolbar') and request.toolbar.edit_mode): fetch_placeholders = placeholders else: for placeholder in placeholders: cached_value = get_placeholder_cache(placeholder, get_language()) if cached_value is not None: restore_sekizai_context(context, cached_value['sekizai']) placeholder.content_cache = cached_value['content'] else: fetch_placeholders.append(placeholder) placeholder.cache_checked = True if fetch_placeholders: assign_plugins(context['request'], fetch_placeholders, page.get_template(), get_language()) for placeholder in placeholders: placeholder_cache[page.pk][placeholder.slot] = placeholder placeholder.page = page current_page._tmp_placeholders_cache = placeholder_cache placeholder = placeholder_cache[page.pk].get(name, None) if page.application_urls and not placeholder: raise PlaceholderNotFound( '"%s" placeholder not found in an apphook application. Please use a static placeholder instead.' % name) return placeholder
def traverse_object(request, path): """Returns the the object with the given path. """ language = translation.get_language() # CACHE cache_key = "%s-traverse-obj-%s-%s-%s" % (settings.CACHE_MIDDLEWARE_KEY_PREFIX, path, request.user.id, language) obj = cache.get(cache_key) if obj: return obj paths = path.split("/") language = translation.get_language() try: obj = lfc.utils.get_content_object(request, slug=paths[0], parent=None, language__in = ("0", language)) except lfc.models.BaseContent.DoesNotExist: raise Http404 for path in paths[1:]: try: obj = obj.children.get(slug=path, language__in = ("0", obj.language)).get_content_object() except lfc.models.BaseContent.DoesNotExist: raise Http404 cache.set(cache_key, obj) return obj
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 test_activate_locale(self): assert translation.get_language() == 'en-us' with UserProfile(username='******').activate_lang(): assert translation.get_language() == 'en-us' with UserProfile(username='******', lang='fr').activate_lang(): assert translation.get_language() == 'fr'
def when_text(d,t=None): """ Return a string with a concise representation of the given date and time combination. Examples: >>> when_text(datetime.date(2013,12,25)) u'2013 Dec 25 (Wed)' >>> when_text(datetime.date(2013,12,25),datetime.time(17,15,00)) u'2013 Dec 25 (Wed) 17:15' >>> when_text(None) u'' """ if d is None: return '' fmt = 'yyyy MMM dd (EE)' if t is None: return format_date(d,fmt,locale=to_locale(translation.get_language())) #~ if d.year == datetime.date.today().year: #~ fmt = "%a" + settings.SITE.time_format_strftime #~ else: #~ fmt = "%a %y %b %d" + settings.SITE.time_format_strftime #~ fmt = "%a %Y %b %d " + settings.SITE.time_format_strftime #~ return datetime.datetime.combine(d,t).strftime(fmt) fmt += " HH:mm" return format_datetime(datetime.datetime.combine(d,t),fmt,locale=to_locale(translation.get_language()))
def get_best_locale(request, locale): """ Returns the most appropriate locale from the list of supported locales. This can either be the locale itself (if it's supported), the main locale for that language if any or failing any of that the default `en-US`. Adapted from `activate_locale` in https://github.com/mozilla/affiliates/blob/master/apps/facebook/utils.py """ # HACK: It's not totally clear to me where Django or tower do the matching # that equates locales like es-LA to es, and I'm scared enough of getting it # wrong to want to avoid it for the first release. So instead, we'll # activate the requested locale, and then check what locale got chosen by # django as the usable locale, and match that against our locale whitelist. # TODO: Properly filter out locales prior to calling activate. old_locale = get_language() tower.activate(locale) lang = get_language() if lang not in settings.FACEBOOK_LOCALES: lang_prefix = lang.split('-')[0] tower.activate(lang_prefix) lang = get_language() if lang not in settings.FACEBOOK_LOCALES: try: lang = next(locale for locale in settings.FACEBOOK_LOCALES if locale.startswith(lang_prefix)) except TypeError: lang = 'en-US' tower.activate(old_locale) return lang
def edit_item(request, item_id): if not request.user.is_staff: raise Http403 item = Item.objects.get(pk=item_id) revision = item.get_latest(lang=get_language()) if request.method == "POST": form = NewRevisionForm(request.POST, instance=revision) args = {"form": form, "item": item} if form.is_valid(): # We want to save a new one form.instance.id = None # For now just assume that missing revision == missing content if revision is None: content = Content(item=item, language=get_language()) content.save() revision = form.save(commit=False) revision.content = content revision.save() else: form.save() # First iteration, at least news are shown on main page return redirect("/") else: form = NewRevisionForm(instance=revision) args = {"revision": revision, "item": item, "form": form} return render_to_response("edit_item.html", args, context_instance=RequestContext(request))
def get_description(self): """ Returns the first available text from either the excerpt or content placeholder. """ content = '' for plugin in self.excerpt.get_plugins(): try: if plugin.text.language == get_language(): content = plugin.text.body except: pass if content: break if not content: for plugin in self.content.get_plugins(): try: if plugin.text.language == get_language(): content = plugin.text.body except: pass if content: break # remove html tags and escape the rest pattern = re.compile('<.*?>') content = pattern.sub('', content) text = escape(content) return text
def to_python(self, value): if isinstance(value, TransDbValue): return value if isinstance(value, dict): # formfield method makes this function be called with value as a dict python_value = value else: try: python_value = eval(value) for k,v in python_value.items(): python_value[k] = smart_unicode(v) except Exception: python_value = None if isinstance(python_value, dict): if python_value.has_key(get_language()) and python_value[get_language()]: result = TransDbValue(python_value[get_language()]) elif python_value.has_key(settings.LANGUAGE_CODE) and python_value[settings.LANGUAGE_CODE]: result = TransDbValue(python_value[settings.LANGUAGE_CODE]) else: val = "bal" for item in python_value.items(): try: val = item[1] except: pass if val: break result = TransDbValue(python_value.items()[0][1]) result.raw_data = python_value else: result = TransDbValue(value) result.raw_data = {settings.LANGUAGE_CODE: value} return result
def __unicode__(self): if translation.get_language() == 'sr-latn': return self.title_sr elif translation.get_language() == 'hu': return self.title_hu elif translation.get_language() == 'en': return self.title_en
def test_message_catalog_translations(self): """ Test: Message catalog from FakeTranslation should return required translations. """ _translator = FakeTranslations.translator( { 'es': {'Hello': 'es-hello-world'}, 'fr': {'Hello': 'fr-hello-world'}, }, ) localedir = '/translations' translation.activate("es") with mock.patch('gettext.translation', return_value=_translator(domain='text', localedir=localedir, languages=[get_language()])): i18n_service = self.get_module_i18n_service(self.descriptor) self.assertEqual(i18n_service.ugettext('Hello'), 'es-hello-world') translation.activate("ar") with mock.patch('gettext.translation', return_value=_translator(domain='text', localedir=localedir, languages=[get_language()])): i18n_service = self.get_module_i18n_service(self.descriptor) self.assertEqual(i18n_service.ugettext('Hello'), 'Hello') self.assertNotEqual(i18n_service.ugettext('Hello'), 'fr-hello-world') self.assertNotEqual(i18n_service.ugettext('Hello'), 'es-hello-world') translation.activate("fr") with mock.patch('gettext.translation', return_value=_translator(domain='text', localedir=localedir, languages=[get_language()])): i18n_service = self.get_module_i18n_service(self.descriptor) self.assertEqual(i18n_service.ugettext('Hello'), 'fr-hello-world')
def test_applied_attributes(): product = get_default_product() for spec in ATTR_SPECS: # This loop sets each attribute twice. That's okay. attr = Attribute.objects.get(identifier=spec["identifier"]) pa, _ = ProductAttribute.objects.get_or_create(product=product, attribute=attr) _populate_applied_attribute(pa) pa.save() if not attr.is_translated: product.set_attribute_value(attr.identifier, pa.value) assert product.get_attribute_value("bogomips") == 320, "integer attribute loaded neatly" product.set_attribute_value("bogomips", 480) assert product.get_attribute_value("bogomips") == 480, "integer attribute updated neatly" Product.cache_attributes_for_targets( applied_attr_cls=ProductAttribute, targets=[product], attribute_identifiers=[a["identifier"] for a in ATTR_SPECS], language=get_language() ) assert (get_language(), "bogomips",) in product._attr_cache, "integer attribute in cache" assert product.get_attribute_value("bogomips") == 480, "integer attribute value in cache" assert product.get_attribute_value("ba:gelmips", default="Britta") == "Britta", "non-existent attributes return default value" assert product._attr_cache[(get_language(), "ba:gelmips")] is NoSuchAttributeHere, "cache miss saved" attr_info = product.get_all_attribute_info(language=get_language(), visibility_mode=AttributeVisibility.SHOW_ON_PRODUCT_PAGE) assert set(attr_info.keys()) <= set(a["identifier"] for a in ATTR_SPECS), "get_all_attribute_info gets all attribute info"
def test_rule2(self): """ Rule 2: Assigning a value to the original field also updates the value in the associated translation field of the default language """ self.failUnlessEqual(get_language(), "de") title1_de = "title de" title1_en = "title en" n = TestModel.objects.create(title_de=title1_de, title_en=title1_en) self.failUnlessEqual(n.title, title1_de) self.failUnlessEqual(n.title_de, title1_de) self.failUnlessEqual(n.title_en, title1_en) title2 = "Neuer Titel" n.title = title2 n.save() self.failUnlessEqual(n.title, title2) self.failUnlessEqual(n.title, n.title_de) trans_real.activate("en") self.failUnlessEqual(get_language(), "en") title3 = "new title" n.title = title3 n.title_de = title1_de n.save() self.failUnlessEqual(n.title, title3) self.failUnlessEqual(n.title, n.title_en) self.failUnlessEqual(title1_de, n.title_de) trans_real.deactivate()
def test_rule3(self): """ Rule 3: Assigning a value to a translation field of the default language also updates the original field - note that the value of the original field will not be updated until the model instance is saved. """ title1_de = "title de" title1_en = "title en" n = TestModel.objects.create(title_de=title1_de, title_en=title1_en) self.failUnlessEqual(get_language(), "de") self.failUnlessEqual(n.title, title1_de) self.failUnlessEqual(n.title_de, title1_de) self.failUnlessEqual(n.title_en, title1_en) n.title_de = "Neuer Titel" n.save() self.failUnlessEqual(n.title, n.title_de) # Now switch to "en" trans_real.activate("en") self.failUnlessEqual(get_language(), "en") n.title_en = "New title" # the n.title field is not updated before the instance is saved n.save() self.failUnlessEqual(n.title, n.title_en) trans_real.deactivate()
def login(request, template_name='registration/login.html', redirect_field_name=REDIRECT_FIELD_NAME, authentication_form=LoginForm): ''' Displays the login form and handles the login action. When the User is logged on, we'll try to read the language from his/her profile and update the current language accordingly. ''' if django.VERSION < (1, 2): response = auth_views.login(request, template_name=template_name, redirect_field_name=redirect_field_name) else: response = auth_views.login(request, template_name=template_name, redirect_field_name=redirect_field_name, authentication_form=authentication_form) if request.method == 'POST': try: p = request.user.get_profile() except AttributeError: lang_code = translation.get_language() except ObjectDoesNotExist: lang_code = translation.get_language() else: lang_code = p.language if lang_code == '': lang_code = translation.get_language() p.language = lang_code p.save() set_language_on_response(request, response, lang_code) return response
def __unicode__(self): if translation.get_language() == 'sr-latn': return self.intro_sr if translation.get_language() == 'hu': return self.intro_hu if translation.get_language() == 'en': return self.intro_en
def language_chooser(context, template=NOT_PROVIDED, i18n_mode="raw"): """ Displays a language chooser - template: template used to render the language chooser """ if template in MARKERS: i18n_mode = template template = NOT_PROVIDED if template is NOT_PROVIDED: template = "menu/language_chooser.html" if not i18n_mode in MARKERS: i18n_mode = "raw" try: # If there's an exception (500), default context_processors may not be called. request = context["request"] except KeyError: return {"template": "cms/content.html"} marker = MARKERS[i18n_mode] cms_languages = dict(settings.CMS_LANGUAGES) current_lang = get_language() site = Site.objects.get_current() cache_key = "%s-language-chooser-%s-%s-%s" % (settings.CMS_CACHE_PREFIX, site.pk, current_lang, i18n_mode) languages = cache.get(cache_key, []) if not languages: for lang in settings.CMS_FRONTEND_LANGUAGES: if lang in cms_languages: languages.append((lang, marker(cms_languages[lang], lang))) if current_lang != get_language(): activate(current_lang) cache.set(cache_key, languages) lang = get_language_from_request(request, request.current_page) context.update({"languages": languages, "current_language": lang, "template": template}) return context
def get_extra_restriction(self, where_class, alias, related_alias): return ColConstraint(alias, 'lang', get_language())
class Video(models.Model): video = models.FileField( _('Video'), upload_to=get_storage_path, max_length=255) allow_downloading = models.BooleanField( _('allow downloading'), default=False) is_360 = models.BooleanField(_('video 360'), default=False) title = models.CharField(_('Title'), max_length=250) slug = models.SlugField(_('Slug'), unique=True, max_length=255, help_text=_( 'Used to access this instance, the "slug" is a short label containing only letters, numbers, underscore or dash top.'), editable=False) owner = models.ForeignKey(User, verbose_name=_('Owner')) date_added = models.DateField(_('Date added'), default=datetime.now) date_evt = models.DateField( _(u'Date of event'), default=datetime.now, blank=True, null=True) cursus = models.CharField( _('University course'), max_length=1, choices=settings.CURSUS_CODES, default="0") main_lang = models.CharField( _('Main language'), max_length=2, choices=MAIN_LANG_CHOICES, default=get_language()) description = RichTextField( _('Description'), config_name='complete', blank=True) view_count = models.PositiveIntegerField( _('View count'), default=0, editable=False) encoding_in_progress = models.BooleanField( _('Encoding in progress'), default=False, editable=False) encoding_status = models.CharField( _('Encoding status'), max_length=250, editable=False, blank=True, null=True) thumbnail = FilerImageField( null=True, blank=True, verbose_name=_('Thumbnail')) to_encode = models.BooleanField(default=False, editable=False) overview = models.ImageField( _('Overview'), null=True, upload_to=get_storage_path, blank=True, max_length=255, editable=False) duration = models.IntegerField( _('Duration'), default=0, editable=False, blank=True) infoVideo = models.TextField(null=True, blank=True, editable=False) class Meta: ordering = ['-date_added', '-id'] get_latest_by = 'date_added' verbose_name = _("video") verbose_name_plural = _("videos") abstract = True def __unicode__(self): return u"Titre:%s - Prop:%s - Date:%s" % (self.title, self.owner, self.date_added) def __str__(self): return "%s" % (self.title) def filename(self): return os.path.basename(self.video.name) def admin_thumbnail(self): try: if self.thumbnail is None: return "" else: return "<img src=\"%s\" alt=\"%s\" />" % (self.thumbnail.icons['64'], self.title) except: return "" admin_thumbnail.short_description = _('Thumbnail') admin_thumbnail.allow_tags = True def duration_in_time(self): return time.strftime('%H:%M:%S', time.gmtime(self.duration)) duration_in_time.short_description = _('Duration') duration_in_time.allow_tags = True
def _get_locale_analyzer(): analyzer = amo.SEARCH_LANGUAGE_TO_ANALYZER.get(translation.get_language()) if not settings.ES_USE_PLUGINS and analyzer in amo.SEARCH_ANALYZER_PLUGINS: return None return analyzer
('THANKS', 'Thanks'), ('SUPPORTER', 'Seisho student'), ('LOVER', 'Revue performer'), ('AMBASSADOR', 'Play stage manager'), ('PRODUCER', 'Revue producer'), ('DEVOTEE', 'Starlight reached'), ) ############################################################ # Activities MINIMUM_LIKES_POPULAR = 5 ACTIVITY_TAGS = [ # Revue Starlight ('revuestarlight', lambda: LICENSE_NAME_PER_LANGUAGE.get(get_language(), LICENSE_NAME)), ('stagegirls', _('Stage girls')), ('voiceactresses', _('Voice actresses')), ('anime', lambda: u'{} / {} / {} ({})'.format( _('Anime'), _('Manga'), _('Movie'), LICENSE_NAME_PER_LANGUAGE.get(get_language(), LICENSE_NAME), )), ('irlevent', lambda: u'{} / {} ({})'.format( _('Meetups'), _('Events'), LICENSE_NAME_PER_LANGUAGE.get(get_language(), LICENSE_NAME), )), # Relive
def inner(*args, **kwargs): prev_language = translation.get_language() if prev_language != settings.LANGUAGE_CODE: translation.activate(settings.LANGUAGE_CODE) return func(*args, **kwargs)
from django.shortcuts import get_object_or_404, redirect, render from django.utils import timezone from django.utils.translation import get_language, ugettext as _ from django.views.decorators.cache import cache_page from django.views.decorators.http import last_modified from django.views.i18n import javascript_catalog from shibboleth.views import ShibbolethLogoutView, LOGOUT_SESSION_KEY from contrib.mcp.client import MCPClient from main import models from lxml import etree from components import helpers from archivematicaFunctions import escape @cache_page(86400, key_prefix="js18n-%s" % get_language()) @last_modified(lambda req, **kw: timezone.now()) def cached_javascript_catalog(request, domain="djangojs", packages=None): return javascript_catalog(request, domain, packages) """ @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@ Home @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@ """ def home(request): # clean up user's session-specific data if "user_temp_data_cleanup_ran" not in request.session: # create all transfer metadata sets created by user transfer_metadata_sets = models.TransferMetadataSet.objects.filter(
def get_extra_descriptor_filter(self): return {'lang': get_language()}
def post(self, request, *args, **kwargs): return self.do(self.request.event.id, get_or_create_cart_id(self.request), translation.get_language())
def create_account_with_params(request, params): """ Given a request and a dict of parameters (which may or may not have come from the request), create an account for the requesting user, including creating a comments service user object and sending an activation email. This also takes external/third-party auth into account, updates that as necessary, and authenticates the user for the request's session. Does not return anything. Raises AccountValidationError if an account with the username or email specified by params already exists, or ValidationError if any of the given parameters is invalid for any other reason. Issues with this code: * It is non-transactional except where explicitly wrapped in atomic to alleviate deadlocks and improve performance. This means failures at different places in registration can leave users in inconsistent states. * Third-party auth passwords are not verified. There is a comment that they are unused, but it would be helpful to have a sanity check that they are sane. * The user-facing text is rather unfriendly (e.g. "Username must be a minimum of two characters long" rather than "Please use a username of at least two characters"). * Duplicate email raises a ValidationError (rather than the expected AccountValidationError). Duplicate username returns an inconsistent user message (i.e. "An account with the Public Username '{username}' already exists." rather than "It looks like {username} belongs to an existing account. Try again with a different username.") The two checks occur at different places in the code; as a result, registering with both a duplicate username and email raises only a ValidationError for email only. """ # Copy params so we can modify it; we can't just do dict(params) because if # params is request.POST, that results in a dict containing lists of values params = dict(list(params.items())) # allow to define custom set of required/optional/hidden fields via configuration extra_fields = configuration_helpers.get_value( 'REGISTRATION_EXTRA_FIELDS', getattr(settings, 'REGISTRATION_EXTRA_FIELDS', {}) ) if is_registration_api_v1(request): if 'confirm_email' in extra_fields: del extra_fields['confirm_email'] # registration via third party (Google, Facebook) using mobile application # doesn't use social auth pipeline (no redirect uri(s) etc involved). # In this case all related info (required for account linking) # is sent in params. # `third_party_auth_credentials_in_api` essentially means 'request # is made from mobile application' third_party_auth_credentials_in_api = 'provider' in params is_third_party_auth_enabled = third_party_auth.is_enabled() if is_third_party_auth_enabled and (pipeline.running(request) or third_party_auth_credentials_in_api): params["password"] = generate_password() # in case user is registering via third party (Google, Facebook) and pipeline has expired, show appropriate # error message if is_third_party_auth_enabled and ('social_auth_provider' in params and not pipeline.running(request)): raise ValidationError( {'session_expired': [ _(u"Registration using {provider} has timed out.").format( provider=params.get('social_auth_provider')) ]} ) extended_profile_fields = configuration_helpers.get_value('extended_profile_fields', []) # Can't have terms of service for certain SHIB users, like at Stanford registration_fields = getattr(settings, 'REGISTRATION_EXTRA_FIELDS', {}) tos_required = ( registration_fields.get('terms_of_service') != 'hidden' or registration_fields.get('honor_code') != 'hidden' ) form = AccountCreationForm( data=params, extra_fields=extra_fields, extended_profile_fields=extended_profile_fields, do_third_party_auth=False, tos_required=tos_required, ) custom_form = get_registration_extension_form(data=params) # Perform operations within a transaction that are critical to account creation with outer_atomic(read_committed=True): # first, create the account (user, profile, registration) = do_create_account(form, custom_form) third_party_provider, running_pipeline = _link_user_to_third_party_provider( is_third_party_auth_enabled, third_party_auth_credentials_in_api, user, request, params, ) new_user = authenticate_new_user(request, user.username, form.cleaned_data['password']) django_login(request, new_user) request.session.set_expiry(0) # Sites using multiple languages need to record the language used during registration. # If not, compose_and_send_activation_email will be sent in site's default language only. create_or_set_user_attribute_created_on_site(user, request.site) preferences_api.set_user_preference(user, LANGUAGE_KEY, get_language()) # Check if system is configured to skip activation email for the current user. skip_email = _skip_activation_email( user, running_pipeline, third_party_provider, ) if skip_email: registration.activate() else: compose_and_send_activation_email(user, profile, registration) if settings.FEATURES.get('ENABLE_DISCUSSION_EMAIL_DIGEST'): try: enable_notifications(user) except Exception: # pylint: disable=broad-except log.exception(u"Enable discussion notifications failed for user {id}.".format(id=user.id)) _track_user_registration(user, profile, params, third_party_provider) # Announce registration REGISTER_USER.send(sender=None, user=user, registration=registration) create_comments_service_user(user) try: _record_registration_attributions(request, new_user) # Don't prevent a user from registering due to attribution errors. except Exception: # pylint: disable=broad-except log.exception('Error while attributing cookies to user registration.') # TODO: there is no error checking here to see that the user actually logged in successfully, # and is not yet an active user. if new_user is not None: AUDIT_LOG.info(u"Login success on new account creation - {0}".format(new_user.username)) return new_user
def get_language(self): """ Define the language of the current view, defaults to the active language. """ return translation.get_language()
def _data(self, request, cleaned, *args, explain=None, **kwargs): m_search = MultiSearch() search = Search(using=connection, index=settings.ELASTICSEARCH_COMMON_ALIAS_NAME, extra={'size': 0}) search.aggs.bucket( 'documents_by_type', TermsFacet(field='model').get_aggregation()).bucket( 'by_month', DateHistogramFacet(field='created', interval='month', min_doc_count=0).get_aggregation()) d_search = DatasetDocument().search().extra(size=0).filter( 'match', status='published') r_search = ResourceDocument().search().extra(size=0).filter( 'match', status='published') d_search.aggs.bucket( 'datasets_by_institution', NestedFacet( 'institution', TermsFacet(field='institution.id')).get_aggregation()) d_search.aggs.bucket( 'datasets_by_categories', NestedFacet( 'categories', TermsFacet(field='categories.id', min_doc_count=1, size=50)).get_aggregation()) d_search.aggs.bucket( 'datasets_by_category', NestedFacet( 'category', TermsFacet(field='category.id', min_doc_count=1, size=50)).get_aggregation()) d_search.aggs.bucket('datasets_by_tag', TermsFacet(field='tags').get_aggregation()) d_search.aggs.bucket( 'datasets_by_keyword', Nested(aggs={ 'inner': Filter( aggs={'inner': Terms(field='keywords.name')}, term={'keywords.language': get_language()}, ) }, path='keywords')) d_search.aggs.bucket('datasets_by_formats', TermsFacet(field='formats').get_aggregation()) d_search.aggs.bucket( 'datasets_by_openness_scores', TermsFacet(field='openness_scores').get_aggregation()) r_search.aggs.bucket('resources_by_type', TermsFacet(field='type').get_aggregation()) m_search = m_search.add(search) m_search = m_search.add(d_search) m_search = m_search.add(r_search) if explain == '1': return m_search.to_dict() try: resp1, resp2, resp3 = m_search.execute() # TODO: how to concatenate two responses in more elegant way? resp1.aggregations.datasets_by_institution = resp2.aggregations.datasets_by_institution resp1.aggregations.datasets_by_categories = resp2.aggregations.datasets_by_categories resp1.aggregations.datasets_by_category = resp2.aggregations.datasets_by_category resp1.aggregations.datasets_by_tag = resp2.aggregations.datasets_by_tag resp1.aggregations.datasets_by_keyword = resp2.aggregations.datasets_by_keyword resp1.aggregations.datasets_by_formats = resp2.aggregations.datasets_by_formats resp1.aggregations.datasets_by_openness_scores = resp2.aggregations.datasets_by_openness_scores resp1.aggregations.resources_by_type = resp3.aggregations.resources_by_type return resp1 except TransportError as err: try: description = err.info['error']['reason'] except KeyError: description = err.error raise falcon.HTTPBadRequest(description=description)
def get_current_cc(language=None): language = language or translation.get_language() return language.split('-')[-1].upper()
def user_profile(request): profile = request.user.profile if not profile.language: profile.language = get_language() profile.save(update_fields=['language']) form_classes = [ ProfileForm, SubscriptionForm, UserSettingsForm, DashboardSettingsForm, UserForm, ] forms = [form.from_request(request) for form in form_classes] forms.extend(get_notification_forms(request)) all_backends = set(load_backends(social_django.utils.BACKENDS).keys()) if request.method == 'POST': if all(form.is_valid() for form in forms): # Save changes for form in forms: form.save() # Change language set_lang(request, request.user.profile) # Redirect after saving (and possibly changing language) response = redirect_profile(request.POST.get('activetab')) # Set language cookie and activate new language (for message below) lang_code = profile.language response.set_cookie(settings.LANGUAGE_COOKIE_NAME, lang_code) translation.activate(lang_code) messages.success(request, _('Your profile has been updated.')) return response else: if not request.user.has_usable_password() and 'email' in all_backends: messages.warning( request, render_to_string('accounts/password-warning.html')) social = request.user.social_auth.all() social_names = [assoc.provider for assoc in social] new_backends = [ x for x in all_backends if x == 'email' or x not in social_names ] license_projects = Component.objects.filter( project__in=request.user.allowed_projects).exclude( license='').order_project() result = render( request, 'accounts/profile.html', { 'languagesform': forms[0], 'subscriptionform': forms[1], 'usersettingsform': forms[2], 'dashboardsettingsform': forms[3], 'userform': forms[4], 'notification_forms': forms[5:], 'all_forms': forms, 'profile': profile, 'title': _('User profile'), 'licenses': license_projects, 'associated': social, 'new_backends': new_backends, 'auditlog': request.user.auditlog_set.order()[:20], }) result.set_cookie(settings.LANGUAGE_COOKIE_NAME, profile.language) return result
def common(request): context = {} context['paypal_return_url'] = settings.PAYPAL_RETURN_URL context['paypal_notify_url'] = settings.PAYPAL_NOTIFY_URL context['paypal_business_name'] = settings.PAYPAL_BUSINESS_NAME context['paypal_receiver_email'] = settings.PAYPAL_RECEIVER_EMAIL context['paypal_submit_url'] = settings.PAYPAL_SUBMIT_URL context['stripe_public_key'] = settings.STRIPE_PUBLIC_KEY context['stripe_secret_key'] = settings.STRIPE_SECRET_KEY context['ga_is_on'] = settings.GA_IS_ON context['latestblogs'] = BlogEntry.objects.filter( is_draft=False, title__isnull=False).exclude( title__exact="None").order_by('-date_added')[:3] context['static_url'] = settings.STATIC_URL context['thumb_large'] = settings.THUMB_LARGE context['thumb_home_large'] = settings.THUMB_HOME_LARGE context['thumb_medium'] = settings.THUMB_MEDIUM context['thumb_small'] = settings.THUMB_SMALL context['date'] = datetime.now() # STUFF RELATED TO COUNTRY SPECIFIC SITES context['site_url'] = "http://www.minrivertea.com" context['analytics_id'] = settings.ANALYTICS_ID context['mailchimp_list_id'] = settings.MAILCHIMP_LIST_ID # TEA OF THE MONTH try: totm = Product.objects.filter(totm__month=datetime.now().month, is_active=True)[0] except IndexError: totm = None context['totm'] = totm if get_language() == 'de': context['mailchimp_list_id'] = settings.GERMAN_MAILCHIMP_LIST_ID context['site_name'] = settings.SITE_NAME # the loose non-techy name # GET THE NAVIGATIONS context['main_nav'] = Category.objects.filter( is_navigation_item=True).order_by('list_order') context['top_nav'] = Page.objects.filter( is_top_nav=True).order_by('list_order') # REGIONAL STUFF context['region'] = _get_region(request) if context['region'] == 'US': context['weight_unit'] = 'oz' else: context['weight_unit'] = 'g' # currency stuff context['currency'] = _get_currency(request) # AFFILIATE STUFF if settings.AFFILIATE_SESSION_KEY in request.session: context['affiliate_session'] = True if request.GET.get(settings.AFFILIATE_URL_VARIABLE): context[ 'landing_page'] = True # TODO we should change this to specify which landing page it shoudl show # CHANGE THE BASE TEMPLATE FOR ADMIN if '/admin-stuff/' in request.path: base_template = settings.BASE_TEMPLATE_ADMIN else: base_template = settings.BASE_TEMPLATE context['base_template'] = base_template # BASKET STUFF try: basket = Basket.objects.get(id=request.session['BASKET_ID']) except: basket = None try: context['basket_quantity'] = request.session['BASKET_QUANTITY'] context['basket_amount'] = request.session['BASKET_AMOUNT'] except: basket = _get_basket_value(request) context['basket_quantity'] = basket['basket_quantity'] context['basket_amount'] = basket['total_price'] return context
def _get_format(): lang = get_language() return Format(utils.get_locale_from_lang(lang))
def render(self, context): context[self.variable] = translation.get_language() return ''
def django_settings(request): return { 'LANGUAGE': get_language(), }
def language(): lang = translation.get_language() return lang
def home_real(request: HttpRequest) -> HttpResponse: # Before we do any real work, check if the app is banned. client_user_agent = request.META.get("HTTP_USER_AGENT", "") (insecure_desktop_app, banned_desktop_app, auto_update_broken) = is_outdated_desktop_app( client_user_agent) if banned_desktop_app: return render( request, 'zerver/insecure_desktop_app.html', context={ "auto_update_broken": auto_update_broken, }, ) (unsupported_browser, browser_name) = is_unsupported_browser(client_user_agent) if unsupported_browser: return render( request, 'zerver/unsupported_browser.html', context={ "browser_name": browser_name, }, ) # We need to modify the session object every two weeks or it will expire. # This line makes reloading the page a sufficient action to keep the # session alive. request.session.modified = True if request.user.is_authenticated: user_profile = request.user else: # nocoverage # This code path should not be reachable because of zulip_login_required above. user_profile = None # If a user hasn't signed the current Terms of Service, send them there if need_accept_tos(user_profile): return accounts_accept_terms(request) narrow, narrow_stream, narrow_topic = detect_narrowed_window(request, user_profile) client_capabilities = { 'notification_settings_null': True, 'bulk_message_deletion': True, 'user_avatar_url_field_optional': True, } register_ret = do_events_register(user_profile, request.client, apply_markdown=True, client_gravatar=True, slim_presence=True, client_capabilities=client_capabilities, narrow=narrow) update_last_reminder(user_profile) if user_profile is not None: first_in_realm = realm_user_count(user_profile.realm) == 1 # If you are the only person in the realm and you didn't invite # anyone, we'll continue to encourage you to do so on the frontend. prompt_for_invites = ( first_in_realm and not PreregistrationUser.objects.filter(referred_by=user_profile).count() ) needs_tutorial = user_profile.tutorial_status == UserProfile.TUTORIAL_WAITING else: # nocoverage first_in_realm = False prompt_for_invites = False # The current tutorial doesn't super make sense for logged-out users. needs_tutorial = False furthest_read_time = get_furthest_read_time(user_profile) # We pick a language for the user as follows: # * First priority is the language in the URL, for debugging. # * If not in the URL, we use the language from the user's settings. request_language = translation.get_language_from_path(request.path_info) if request_language is None: request_language = register_ret['default_language'] translation.activate(request_language) # We also save the language to the user's session, so that # something reasonable will happen in logged-in portico pages. request.session[translation.LANGUAGE_SESSION_KEY] = translation.get_language() two_fa_enabled = settings.TWO_FACTOR_AUTHENTICATION_ENABLED and user_profile is not None # Pass parameters to the client-side JavaScript code. # These end up in a global JavaScript Object named 'page_params'. page_params = dict( # Server settings. debug_mode = settings.DEBUG, test_suite = settings.TEST_SUITE, poll_timeout = settings.POLL_TIMEOUT, insecure_desktop_app = insecure_desktop_app, login_page = settings.HOME_NOT_LOGGED_IN, root_domain_uri = settings.ROOT_DOMAIN_URI, save_stacktraces = settings.SAVE_FRONTEND_STACKTRACES, warn_no_email = settings.WARN_NO_EMAIL, search_pills_enabled = settings.SEARCH_PILLS_ENABLED, # Misc. extra data. initial_servertime = time.time(), # Used for calculating relative presence age default_language_name = get_language_name(register_ret['default_language']), language_list_dbl_col = get_language_list_for_templates(register_ret['default_language']), language_list = get_language_list(), needs_tutorial = needs_tutorial, first_in_realm = first_in_realm, prompt_for_invites = prompt_for_invites, furthest_read_time = furthest_read_time, has_mobile_devices = user_profile is not None and num_push_devices_for_user(user_profile) > 0, bot_types = get_bot_types(user_profile), two_fa_enabled = two_fa_enabled, # Adding two_fa_enabled as condition saves us 3 queries when # 2FA is not enabled. two_fa_enabled_user = two_fa_enabled and bool(default_device(user_profile)), ) undesired_register_ret_fields = [ 'streams', ] for field_name in set(register_ret.keys()) - set(undesired_register_ret_fields): page_params[field_name] = register_ret[field_name] if narrow_stream is not None: # In narrow_stream context, initial pointer is just latest message recipient = narrow_stream.recipient try: max_message_id = Message.objects.filter(recipient=recipient).order_by('id').reverse()[0].id except IndexError: max_message_id = -1 page_params["narrow_stream"] = narrow_stream.name if narrow_topic is not None: page_params["narrow_topic"] = narrow_topic page_params["narrow"] = [dict(operator=term[0], operand=term[1]) for term in narrow] page_params["max_message_id"] = max_message_id page_params["enable_desktop_notifications"] = False statsd.incr('views.home') show_invites, show_add_streams = compute_show_invites_and_add_streams(user_profile) show_billing = False show_plans = False if settings.CORPORATE_ENABLED and user_profile is not None: from corporate.models import CustomerPlan, get_customer_by_realm if user_profile.has_billing_access: customer = get_customer_by_realm(user_profile.realm) if customer is not None: if customer.sponsorship_pending: show_billing = True elif CustomerPlan.objects.filter(customer=customer).exists(): show_billing = True if user_profile.realm.plan_type == Realm.LIMITED: show_plans = True request._log_data['extra'] = "[{}]".format(register_ret["queue_id"]) page_params['translation_data'] = {} if request_language != 'en': page_params['translation_data'] = get_language_translation_data(request_language) csp_nonce = generate_random_token(48) if user_profile is not None: color_scheme = user_profile.color_scheme is_guest = user_profile.is_guest is_realm_owner = user_profile.is_realm_owner is_realm_admin = user_profile.is_realm_admin show_webathena = user_profile.realm.webathena_enabled else: # nocoverage color_scheme = UserProfile.COLOR_SCHEME_AUTOMATIC is_guest = False is_realm_admin = False is_realm_owner = False show_webathena = False navbar_logo_url = compute_navbar_logo_url(page_params) response = render(request, 'zerver/app/index.html', context={'user_profile': user_profile, 'page_params': page_params, 'csp_nonce': csp_nonce, 'search_pills_enabled': settings.SEARCH_PILLS_ENABLED, 'show_invites': show_invites, 'show_add_streams': show_add_streams, 'show_billing': show_billing, 'corporate_enabled': settings.CORPORATE_ENABLED, 'show_plans': show_plans, 'is_owner': is_realm_owner, 'is_admin': is_realm_admin, 'is_guest': is_guest, 'color_scheme': color_scheme, 'navbar_logo_url': navbar_logo_url, 'show_webathena': show_webathena, 'embedded': narrow_stream is not None, 'invite_as': PreregistrationUser.INVITE_AS, 'max_file_upload_size_mib': settings.MAX_FILE_UPLOAD_SIZE, }) patch_cache_control(response, no_cache=True, no_store=True, must_revalidate=True) return response
def process_response(self, request, response): if 'Content-Language' not in response: response['Content-Language'] = translation.get_language() translation.deactivate() return response
def get_kml_url(self, obj): return reverse('sensitivity:sensitivearea_kml_detail', kwargs={'lang': get_language(), 'pk': obj.pk})
def active_contentions(self): language = normalize_language_code(get_language()) return self.contentions.filter( is_published=True, language=language ).order_by('?')
def process_response(self, request, response): if settings.USE_I18N and request.path.find('/admin') != 0 and response.status_code == 200 and 'text/html' in \ response['Content-Type']: response.set_cookie(settings.LANGUAGE_COOKIE_NAME, get_language()) return response
def get_current_language(context): from django.utils.translation import get_language return get_language()
def get_map_image_path(self): basefolder = os.path.join(settings.MEDIA_ROOT, 'maps') if not os.path.exists(basefolder): os.makedirs(basefolder) return os.path.join(basefolder, '%s-%s-%s.png' % (self._meta.module_name, self.pk, get_language()))
def get_real_fieldname(field, lang=None): """ append lang to base field name. Use active or fallback language if lang is None """ if lang is None: lang = get_language() or fallback_language() lang = lang.split('-')[0] # both 'en-US' and 'en' -> 'en' return str('%s_%s' % (field, lang))
def get_context_data(self, **kwargs): activate(self.language) context = super(TranslatedTemplateView, self).get_context_data(**kwargs) context['current_language'] = get_language() return context
def get_document_public_url(self): """ Override ``geotrek.common.mixins.PublishableMixin`` """ return ('trekking:poi_document_public', [], {'lang': get_language(), 'pk': self.pk, 'slug': self.slug})
def __set__(self, instance, value): if isinstance(value, six.string_types): language = translation.get_language() or settings.LANGUAGE_CODE self.__get__(instance).set(language, value) # pylint: disable=no-member else: instance.__dict__[self.field.name] = value
def get_map_image_url(self): return ('trekking:trek_map_image', [], {'pk': str(self.pk), 'lang': get_language()})