def test05_lock(self): languages.lock('en') self.assertEqual(languages.is_locked(), True) self.assertEqual(languages.get_active(), 'en') languages.release() self.assertEqual(languages.is_locked(), False) self.assertEqual(languages.get_active(), 'cs')
def test_get_active(self): deactivate_all() # No active language, returns default self.assertEqual(languages.get_active(), 'cs') activate('en') # Active language is returned self.assertEqual(languages.get_active(), 'en')
def test_lock(self): activate('en') self.assertFalse(languages.is_locked()) self.assertEqual(languages.get_active(), 'en') languages.lock('fr') self.assertTrue(languages.is_locked()) self.assertEqual(languages.get_active(), 'fr') languages.release() self.assertFalse(languages.is_locked()) self.assertEqual(languages.get_active(), 'en')
def __init__( self, data=None, files=None, auto_id="id_%s", prefix=None, initial=None, error_class=ErrorList, label_suffix=":", empty_permitted=False, instance=None, ): opts = self._meta initial_data = {} if instance is not None: trans_model = getattr(instance._meta, "translation_model", None) if trans_model is not None: try: translation = instance._get_translation(get_active(), can_create=True) except trans_model.DoesNotExist: pass else: if opts.exclude is None: exclude = ("id", "language_code", "master") else: exclude = list(opts.exclude) + ["id", "language_code", "master"] initial_data = model_to_dict(translation, opts.fields, exclude) initial_data.update(initial or {}) super(MultilingualModelForm, self).__init__( data, files, auto_id, prefix, initial_data, error_class, label_suffix, empty_permitted, instance )
def language_code(self): """ Returns effective language code. """ if self._language_code is not None: return self._language_code return get_active()
def language_code(self): """ If _language_code is None we are the _current field, so we use the currently used language for lookups. """ if self._language_code is not None: return self._language_code return get_active()
def change_view(self, request, object_id, extra_context=None): """ Lock language over change_view and add extra_context """ try: lock(request.POST.get("language", request.GET.get("language", get_active()))) model = self.model opts = model._meta context = { "title": _("Add %s for language %s") % (force_unicode(opts.verbose_name), force_unicode(get_dict()[get_active()])) } context.update(extra_context or {}) return super(MultilingualModelAdmin, self).change_view(request, object_id, context) finally: release()
def add_select_related(self, fields): """ If in fields is related_field for translations, will be replaced by fields in proper languages. """ new_fields = [] extra_select = {} opts = self.model._meta trans_opts = opts.translation_model._meta # TODO: fix this #related_name = trans_opts.related_name related_name = 'translations' translation_fields = [f.name for f in trans_opts.fields if f.name not in ('master', 'language_code')] for field in fields: # usual select_related if not field.startswith(related_name): new_fields.append(field) continue # get language if field == related_name: language_code = get_active() else: field_and_lang = field.rsplit('_', 1) # Coincidental field name might occur if language_code is not correct, do not do anything as # select_related does not raise errors if used with incorrect fields if len(field_and_lang) != 2 or field_and_lang[1] not in get_all(): new_fields.append(field) continue field, language_code = field_and_lang # This is main code of this method, build extra_select that might be used by fill_translation_cache for trans_field in translation_fields: extra_select[get_field_alias(trans_field, language_code)] = '%s.%s' % ( get_table_alias(trans_opts.db_table, language_code), connection.ops.quote_name(trans_field) ) # XXX: this is not safe if translation model has no fields, can it happen?? # join translatable model (original) table if not joined yet alias = self.get_initial_alias() # join translation table if not joined yet translation_fields.remove(trans_opts.pk.name) self.setup_joins( ['%s_%s' % (translation_fields[0], language_code)], # any translated_field opts, alias, True, can_reuse = set([alias]) ) if extra_select: self.add_extra(extra_select, None, None, None, None, None) super(MultilingualQuery, self).add_select_related(new_fields)
def add_view(self, request, form_url='', extra_context=None): """ Lock language over add_view and add extra_context """ try: lock(request.POST.get('language', request.GET.get('language', get_active()))) model = self.model opts = model._meta context = { 'title': _('Add %s for language %s') % ( force_unicode(opts.verbose_name), force_unicode(get_dict()[get_active()]) ), } context.update(extra_context or {}) return super(MultilingualModelAdmin, self).add_view(request, form_url, context) finally: release()
def multilingual(request): """ Returns context variables containing information about available languages. """ codes = sorted(get_all()) return {'ML_LANGUAGE': get_active(), # DEPRECATED context #TODO: LANGUAGE_CODES, LANGUAGE_CODES_AND_NAMES available in i18n context processor 'LANGUAGE_CODES': codes, 'LANGUAGE_CODES_AND_NAMES': get_dict(), 'DEFAULT_LANGUAGE_CODE': get_settings_default()}
def change_view(self, request, object_id, extra_context=None): """ Lock language over change_view and add extra_context """ try: lock_language= request.POST.get('language', request.GET.get('language', get_active())) edit_lock(lock_language) model = self.model opts = model._meta context = { 'title': _('Add %s for language %s') % ( force_unicode(opts.verbose_name), force_unicode(get_dict()[get_active()]) ), 'ML_LOCK_LANGUAGE': lock_language, } context.update(extra_context or {}) return super(MultilingualModelAdmin, self).change_view(request, object_id, context) finally: edit_release()
def change_view(self, request, object_id, **kwargs): """ Lock language over change_view and add extra_context """ # In Django 1.4 number of arguments have changed. extra_context = kwargs.get('extra_context') try: lock(request.POST.get('language', request.GET.get('language', get_active()))) model = self.model opts = model._meta context = { 'title': _('Change %s for language %s') % ( force_unicode(opts.verbose_name), force_unicode(get_dict()[get_active()]) ), } context.update(extra_context or {}) kwargs['extra_context'] = context return super(MultilingualModelAdmin, self).change_view(request, object_id, **kwargs) finally: release()
def _post_clean(self): """ Stores translation data into translation instance """ opts = self._meta translation = self.instance._get_translation(get_active(), can_create=True) if opts.exclude is None: exclude = ('id', 'language_code', 'master') else: exclude = list(opts.exclude) + ['id', 'language_code', 'master'] # Update instance translation construct_instance(self, translation, opts.fields, exclude) super(BaseMultilingualModelForm, self)._post_clean()
def multilingual(request): """ Returns context variables containing information about available languages. """ codes = sorted(get_all()) return { "ML_LANGUAGE": get_active(), # DEPRECATED context # TODO: LANGUAGE_CODES, LANGUAGE_CODES_AND_NAMES available in i18n context processor "LANGUAGE_CODES": codes, "LANGUAGE_CODES_AND_NAMES": get_dict(), "DEFAULT_LANGUAGE_CODE": get_settings_default(), "ADMIN_MEDIA_URL": settings.ADMIN_MEDIA_PREFIX, }
def render(self, context): # If language_code is string, strip quotes # otherwise resolve variable if self.language_code[0] == self.language_code[-1] and self.language_code[0] in ('"',"'"): language_code = self.language_code[1:-1] else: # Do not catch VariableDoesNotExist exception language_code = template.Variable(self.language_code).resolve(context) # Lock language, store code into context, render, restore context and release lock languages.lock(language_code) context.push() context[self.varname] = languages.get_active() output = self.nodelist.render(context) context.pop() languages.release() return output
def change_view(self, request, object_id, form_url='', extra_context=None): """ Lock language over 'change' view and update context. """ try: lock(request.POST.get('ml_admin_language', request.GET.get('ml_admin_language', get_active()))) model = self.model opts = model._meta context = { 'title': _('Change %s for language %s') % ( force_unicode(opts.verbose_name), force_unicode(get_dict()[get_active()]) ), } context.update(extra_context or {}) return super(MultilingualModelAdmin, self).change_view(request, object_id, form_url=form_url, extra_context=context) finally: release()
def add_select_related(self, fields): """ Sets up the select_related data structure so that we only select certain related models (as opposed to all models, when self.select_related=True). """ new_fields = [] opts = self.model._meta # There is not actually any useful code, all this is to handle deprecated arguments. for field_name in fields: if field_name.startswith('translations'): new_name = None if field_name == 'translations': new_name = '%s_%s' % (TRANSLATION_FIELD_NAME, sanitize_language_code(get_active())) elif '_' in field_name: dummy, language_code = field_name.rsplit('_', 1) if language_code in get_all(): new_name = '%s_%s' % (TRANSLATION_FIELD_NAME, sanitize_language_code(language_code)) if new_name: msg = "Using '%s' in select_related is deprecated, use '%s' or '%s' instead." warnings.warn(msg % (field_name, TRANSLATION_FIELD_NAME, new_name), DeprecationWarning) new_fields.append(TRANSLATION_FIELD_NAME) new_fields.append(new_name) continue # In all other cases use the old name new_fields.append(field_name) new_fields = set(new_fields) return super(MultilingualQuery, self).add_select_related(new_fields)
def test_get_active_undefined(self): # Django allows activation of language not defined in settings, we need to cope for that. activate('INCORRECT_LANGUAGE') self.assertEqual(languages.get_active(), 'cs')
def test01_basics(self): self.assertEqual(languages.get_dict(), SortedDict(self.LANGUAGES)) self.assertEqual(languages.get_all(), ['cs', 'en', 'en-us']) self.assertEqual(languages.get_settings_default(), 'cs') self.assertEqual(languages.get_active(), 'cs')
def test03_language_change(self): activate('en') self.assertEqual(languages.get_active(), 'en')
def render_change_form(self, request, context, **kwargs): # Since Django 1.4 template rendering is lazy, so we need to add language to context. # TODO: Make this a hidden form field. context['ml_admin_language'] = get_active() return super(MultilingualModelAdmin, self).render_change_form(request, context, **kwargs)
def test04_incorrect_language(self): activate('INCORRECT_LANGUAGE') self.assertEqual(languages.get_active(), 'cs')
def test_basics(self): self.assertEqual(languages.get_dict(), SortedDict((('cs', u'Čeština'), ('en', u'English'), ('en-us', u'American english')))) self.assertEqual(languages.get_all(), ['cs', 'en', 'en-us']) self.assertEqual(languages.get_settings_default(), 'cs') self.assertEqual(languages.get_active(), 'cs')
def render_change_form(self, request, context, **kwargs): # Django 1.4 postponed template rendering, so we have to pass updated language in context and avoid context # processor. # TODO: Make this a hidden form field. context['LANGUAGE'] = get_active() return super(MultilingualModelAdmin, self).render_change_form(request, context, **kwargs)
def language_code(self): return get_active()
def __init__(self, data=None, files=None, auto_id='id_%s', prefix=None, initial=None, error_class=ErrorList, label_suffix=':', empty_permitted=False, instance=None): super(MultilingualModelForm, self).__init__(data, files, auto_id, prefix, initial, error_class, label_suffix, empty_permitted, instance) # Nothing to do if the instance was not provided if not instance: return # Create empty translation if not exists if not hasattr(self.instance, 'translation') or self.instance.translation is None: self.instance.translation = self.instance._meta.translation_model(master=self.instance, language_code=get_active()) opts = self._meta exclude = ['id', 'language_code', 'master'] if opts.exclude is not None: exclude.extend(opts.exclude) object_data = model_to_dict(self.instance.translation, opts.fields, exclude) for key, value in object_data.iteritems(): self.initial.setdefault(key, value)
def wrapped(cls, request, *args, **kwargs): lock(request.POST.get('language', request.GET.get('language', get_active()))) resp = func(cls, request, *args, **kwargs) release() return resp
def multilingual(request): """ Returns context variables containing information about available languages. """ return {'ML_LANGUAGE': get_active()}