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()}
