def test_language_code_enforcing(self):
'With language_code enforcing, language should be set automatically'
Form = translatable_modelform_factory('ja', Normal, form=NormalForm)
data = {
'shared_field': 'shared',
'translated_field': 'Japanese',
}
form = Form(data)
self.assertTrue(form.is_valid(), form.errors.as_text())
self.assertCountEqual(
form.cleaned_data,
['shared_field', 'translated_field', 'language_code'])
self.assertEqual(form.cleaned_data['language_code'], 'ja')
data = {
'shared_field': 'shared',
'translated_field': 'Japanese',
'language_code': 'sr',
}
Form = translatable_modelform_factory('ja', Normal, form=NormalForm)
form = Form(data)
self.assertTrue(form.is_valid(), form.errors.as_text())
self.assertCountEqual(
form.cleaned_data,
['shared_field', 'translated_field', 'language_code'])
self.assertEqual(form.cleaned_data['language_code'], 'ja')
def test_instance_wrong_translation(self):
# no language enforced
form = NormalForm(instance=Normal.objects.language('en').get(
pk=self.normal_id[1]))
self.assertFalse(form.is_valid())
self.assertCountEqual(form.initial,
['shared_field', 'translated_field'])
self.assertEqual(form.initial['shared_field'], NORMAL[1].shared_field)
self.assertEqual(form.initial['translated_field'],
NORMAL[1].translated_field['en'])
self.assertIn('value="%s"' % NORMAL[1].shared_field, form.as_p())
self.assertIn('value="%s"' % NORMAL[1].translated_field['en'],
form.as_p())
self.assertEqual(
get_cached_translation(form.instance).language_code, 'en')
# enforce japanese language
Form = translatable_modelform_factory('ja', Normal, form=NormalForm)
form = Form(instance=Normal.objects.language('en').get(
pk=self.normal_id[1]))
self.assertFalse(form.is_valid())
self.assertCountEqual(form.initial,
['shared_field', 'translated_field'])
self.assertEqual(form.initial['shared_field'], NORMAL[1].shared_field)
self.assertEqual(form.initial['translated_field'],
NORMAL[1].translated_field['ja'])
self.assertIn('value="%s"' % NORMAL[1].shared_field, form.as_p())
self.assertIn('value="%s"' % NORMAL[1].translated_field['ja'],
form.as_p())
self.assertEqual(
get_cached_translation(form.instance).language_code, 'en')
def get_form(self, request, obj=None, **kwargs):
"""
Returns a Form class for use in the admin add view. This is used by
add_view and change_view.
"""
if self.declared_fieldsets:
fields = flatten_fieldsets(self.declared_fieldsets)
else:
fields = None
if self.exclude is None:
exclude = []
else:
exclude = list(self.exclude)
exclude.extend(kwargs.get("exclude", []))
exclude.extend(self.get_readonly_fields(request, obj))
# Exclude language_code, adding it again to the instance is done by
# the LanguageAwareCleanMixin (see translatable_modelform_factory)
exclude.append('language_code')
old_formfield_callback = curry(self.formfield_for_dbfield,
request=request)
defaults = {
"form": self.form,
"fields": fields,
"exclude": exclude,
"formfield_callback": old_formfield_callback,
}
defaults.update(kwargs)
language = self._language(request)
return translatable_modelform_factory(language, self.model, **defaults)
def test_set_fields_before_save(self):
'Manually set some translated fields before calling save()'
Form = translatable_modelform_factory('sr',
Normal,
form=NormalForm,
exclude=['translated_field'])
data = {
'shared_field': 'shared',
}
with translation.override('en'):
form = Form(data,
instance=Normal.objects.language('ja').get(
pk=self.normal_id[1]))
with self.assertNumQueries(1):
self.assertTrue(form.is_valid())
form.instance.translated_field = u'ћирилица'
with self.assertNumQueries(2 if django.VERSION >= (1, 6) else 3):
obj = form.save()
with self.assertNumQueries(0):
self.assertEqual(obj.pk, self.normal_id[1])
self.assertEqual(obj.language_code, 'sr')
self.assertEqual(obj.shared_field, 'shared')
self.assertEqual(obj.translated_field, u'ћирилица')
self.assertEqual(
Normal.objects.language('sr').get(
pk=self.normal_id[1]).translated_field, u'ћирилица')
def test_instance(self):
# no language enforced
with self.assertNumQueries(1):
form = NormalForm(instance=Normal.objects.language('ja').get(
pk=self.normal_id[1]))
self.assertFalse(form.is_valid())
self.assertCountEqual(form.initial,
['shared_field', 'translated_field'])
self.assertEqual(form.initial['shared_field'], NORMAL[1].shared_field)
self.assertEqual(form.initial['translated_field'],
NORMAL[1].translated_field['ja'])
self.assertIn('value="%s"' % NORMAL[1].shared_field, form.as_p())
self.assertIn('value="%s"' % NORMAL[1].translated_field['ja'],
form.as_p())
self.assertEqual(form.instance.language_code, 'ja')
# enforce japanese language
with self.assertNumQueries(1):
Form = translatable_modelform_factory('ja',
Normal,
form=NormalForm)
form = Form(instance=Normal.objects.language('ja').get(
pk=self.normal_id[1]))
self.assertFalse(form.is_valid())
self.assertCountEqual(form.initial,
['shared_field', 'translated_field'])
self.assertEqual(form.initial['shared_field'], NORMAL[1].shared_field)
self.assertEqual(form.initial['translated_field'],
NORMAL[1].translated_field['ja'])
self.assertIn('value="%s"' % NORMAL[1].shared_field, form.as_p())
self.assertIn('value="%s"' % NORMAL[1].translated_field['ja'],
form.as_p())
self.assertEqual(form.instance.language_code, 'ja')
def get_form(self, request, obj=None, **kwargs):
"""
Returns a Form class for use in the admin add view. This is used by
add_view and change_view.
"""
if 'fields' in kwargs:
fields = kwargs.pop('fields')
else:
fields = flatten_fieldsets(self.get_fieldsets(request, obj))
exclude = (tuple(self.exclude or ()) + tuple(kwargs.pop("exclude",
())) +
tuple(self.get_readonly_fields(request, obj) or ()))
old_formfield_callback = curry(self.formfield_for_dbfield,
request=request)
defaults = {
"form": self.form,
"fields": fields,
"exclude": exclude,
"formfield_callback": old_formfield_callback,
}
defaults.update(kwargs)
language = self._language(request)
if django.VERSION > (2, 1) and 'change' in defaults:
del defaults['change']
return translatable_modelform_factory(language, self.model, **defaults)
def test_instance_untranslated(self):
# no language enforced, should load anyway
with translation.override('en'):
form = NormalForm(instance=Normal.objects.untranslated().get(
pk=self.normal_id[1]))
self.assertFalse(form.is_valid())
self.assertCountEqual(form.initial,
['shared_field', 'translated_field'])
self.assertEqual(form.initial['shared_field'], NORMAL[1].shared_field)
self.assertEqual(form.initial['translated_field'],
NORMAL[1].translated_field['en'])
self.assertIn('value="%s"' % NORMAL[1].shared_field, form.as_p())
self.assertIn('value="%s"' % NORMAL[1].translated_field['en'],
form.as_p())
self.assertIs(get_cached_translation(form.instance), None)
# enforce japanese language
with translation.override('en'):
Form = translatable_modelform_factory('ja',
Normal,
form=NormalForm)
form = Form(instance=Normal.objects.untranslated().get(
pk=self.normal_id[1]))
self.assertFalse(form.is_valid())
self.assertCountEqual(form.initial,
['shared_field', 'translated_field'])
self.assertEqual(form.initial['shared_field'], NORMAL[1].shared_field)
self.assertEqual(form.initial['translated_field'],
NORMAL[1].translated_field['ja'])
self.assertIn('value="%s"' % NORMAL[1].shared_field, form.as_p())
self.assertIn('value="%s"' % NORMAL[1].translated_field['ja'],
form.as_p())
self.assertIs(get_cached_translation(form.instance), None)
def get_form(self, request, obj=None, **kwargs):
"""
Returns a Form class for use in the admin add view. This is used by
add_view and change_view.
"""
if django.VERSION >= (1, 6):
# From v1.6 on, using get_fieldsets is ok, as long as no 'fields'
# argument was given. It allows dynamic fieldsets on admin form.
if 'fields' in kwargs:
fields = kwargs.pop('fields')
else:
fields = flatten_fieldsets(self.get_fieldsets(request, obj))
else:
# On previous versions, calling get_fieldsets triggers infinite recursion
# and we should stick to statically declared fieldsets
if self.declared_fieldsets:
fields = flatten_fieldsets(self.declared_fieldsets)
else:
fields = None
exclude = (
tuple(self.exclude or ()) +
tuple(kwargs.pop("exclude", ())) +
self.get_readonly_fields(request, obj)
)
old_formfield_callback = curry(self.formfield_for_dbfield, request=request)
defaults = {
"form": self.form,
"fields": fields,
"exclude": exclude,
"formfield_callback": old_formfield_callback,
}
defaults.update(kwargs)
language = self._language(request)
return translatable_modelform_factory(language, self.model, **defaults)
def get_form(self, request, obj=None, **kwargs):
"""
Returns a Form class for use in the admin add view. This is used by
add_view and change_view.
"""
if self.declared_fieldsets:
fields = flatten_fieldsets(self.declared_fieldsets)
else:
fields = None
if self.exclude is None:
exclude = []
else:
exclude = list(self.exclude)
exclude.extend(kwargs.get("exclude", []))
exclude.extend(self.get_readonly_fields(request, obj))
# Exclude language_code, adding it again to the instance is done by
# the LanguageAwareCleanMixin (see translatable_modelform_factory)
exclude.append('language_code')
old_formfield_callback = curry(self.formfield_for_dbfield,
request=request)
defaults = {
"form": self.form,
"fields": fields,
"exclude": exclude,
"formfield_callback": old_formfield_callback,
}
defaults.update(kwargs)
language = self._language(request)
return translatable_modelform_factory(language, self.model, **defaults)
def get_form(self, request, obj=None, **kwargs):
"""
Returns a Form class for use in the admin add view. This is used by
add_view and change_view.
"""
if django.VERSION >= (1, 6):
# From v1.6 on, using get_fieldsets is ok, as long as no 'fields'
# argument was given. It allows dynamic fieldsets on admin form.
if 'fields' in kwargs:
fields = kwargs.pop('fields')
else:
fields = flatten_fieldsets(self.get_fieldsets(request, obj))
else:
# On previous versions, calling get_fieldsets triggers infinite recursion
# and we should stick to statically declared fieldsets
if self.declared_fieldsets:
fields = flatten_fieldsets(self.declared_fieldsets)
else:
fields = None
exclude = (
tuple(self.exclude or ()) +
tuple(kwargs.pop("exclude", ())) +
self.get_readonly_fields(request, obj)
)
old_formfield_callback = curry(self.formfield_for_dbfield, request=request)
defaults = {
"form": self.form,
"fields": fields,
"exclude": exclude,
"formfield_callback": old_formfield_callback,
}
defaults.update(kwargs)
language = self._language(request)
return translatable_modelform_factory(language, self.model, **defaults)
def test_accepts_none_clean(self):
Form = translatable_modelform_factory('en', Normal, form=NoneCleanForm,
fields=['shared_field', 'translated_field'])
data = {
'shared_field': 'shared',
'translated_field': 'English',
}
form = Form(data, instance=Normal(), initial=data)
self.assertTrue(form.is_valid(), form.errors.as_text())
def test_no_meta(self):
'Empty form and filled in variant from factory'
class Form(TranslatableModelForm):
pass
self.assertIs(Form._meta.fields, None)
self.assertCountEqual(Form._meta.exclude, ['language_code'])
self.assertCountEqual(Form.base_fields, [])
engineered = translatable_modelform_factory('en', Normal, form=Form)
self.assertIs(Form._meta.fields, None)
self.assertCountEqual(engineered._meta.exclude, ['language_code', 'translations'])
self.assertCountEqual(engineered.base_fields, ['shared_field', 'translated_field'])
def test_no_meta(self):
'Empty form and filled in variant from factory'
class Form(TranslatableModelForm):
pass
self.assertIs(Form._meta.fields, None)
self.assertCountEqual(Form._meta.exclude, [])
self.assertCountEqual(Form.base_fields, [])
engineered = translatable_modelform_factory('en', Normal, form=Form)
self.assertIs(Form._meta.fields, None)
self.assertCountEqual(engineered._meta.exclude, ['translations'])
self.assertCountEqual(engineered.base_fields, ['shared_field', 'translated_field'])
def test_instance_initial(self):
Form = translatable_modelform_factory('ja', Normal, form=NormalForm)
initial = {
'shared_field': 'shared_initial',
'translated_field': 'translated_initial',
}
form = Form(instance=Normal.objects.language('ja').get(pk=self.normal_id[1]),
initial=initial)
self.assertFalse(form.is_valid())
self.assertCountEqual(form.initial, ['shared_field', 'translated_field'])
self.assertEqual(form.initial['shared_field'], 'shared_initial')
self.assertEqual(form.initial['translated_field'], 'translated_initial')
def test_instance_initial(self):
Form = translatable_modelform_factory('ja', Normal, form=NormalForm)
initial = {
'shared_field': 'shared_initial',
'translated_field': 'translated_initial',
}
form = Form(instance=Normal.objects.language('ja').get(pk=self.normal_id[1]),
initial=initial)
self.assertFalse(form.is_valid())
self.assertCountEqual(form.initial, ['shared_field', 'translated_field'])
self.assertEqual(form.initial['shared_field'], 'shared_initial')
self.assertEqual(form.initial['translated_field'], 'translated_initial')
def test_only_fields(self):
'Empty form and filled in variant from factory - applies field restriction'
class Form(TranslatableModelForm):
class Meta:
fields = ('shared_field', 'translated_field')
self.assertCountEqual(Form._meta.fields, ['shared_field', 'translated_field'])
self.assertCountEqual(Form._meta.exclude, ['language_code'])
self.assertCountEqual(Form.base_fields, [])
engineered = translatable_modelform_factory('en', Normal, form=Form)
self.assertCountEqual(engineered._meta.fields, ['shared_field', 'translated_field'])
self.assertCountEqual(engineered._meta.exclude, ['language_code', 'translations'])
self.assertCountEqual(engineered.base_fields, ['shared_field', 'translated_field'])
def test_language_code_enforcing_override(self):
'Custom clean() method should see language_code and be able to override it'
Form = translatable_modelform_factory('ja', Normal, form=CustomLanguageNormalForm)
data = {
'shared_field': 'shared',
'translated_field': 'Japanese',
}
form = Form(data)
self.assertTrue(form.is_valid(), form.errors.as_text())
self.assertCountEqual(form.cleaned_data, ['shared_field', 'translated_field',
'seen_language', 'language_code'])
self.assertIs(form.cleaned_data['seen_language'], 'ja')
self.assertEqual(form.cleaned_data['language_code'], 'sr')
def test_language_code_enforcing(self):
'With language_code enforcing, language should be set automatically'
Form = translatable_modelform_factory('ja', Normal, form=NormalForm)
data = {
'shared_field': 'shared',
'translated_field': 'Japanese',
}
form = Form(data)
self.assertTrue(form.is_valid(), form.errors.as_text())
self.assertCountEqual(form.cleaned_data, ['shared_field', 'translated_field', 'language_code'])
self.assertEqual(form.cleaned_data['language_code'], 'ja')
data = {
'shared_field': 'shared',
'translated_field': 'Japanese',
'language_code': 'sr',
}
Form = translatable_modelform_factory('ja', Normal, form=NormalForm)
form = Form(data)
self.assertTrue(form.is_valid(), form.errors.as_text())
self.assertCountEqual(form.cleaned_data, ['shared_field', 'translated_field', 'language_code'])
self.assertEqual(form.cleaned_data['language_code'], 'ja')
def test_language_code_enforcing_override(self):
'Custom clean() method should see language_code and be able to override it'
Form = translatable_modelform_factory('ja', Normal, form=CustomLanguageNormalForm)
data = {
'shared_field': 'shared',
'translated_field': 'Japanese',
}
form = Form(data)
self.assertTrue(form.is_valid(), form.errors.as_text())
self.assertCountEqual(form.cleaned_data, ['shared_field', 'translated_field',
'seen_language', 'language_code'])
self.assertIs(form.cleaned_data['seen_language'], 'ja')
self.assertEqual(form.cleaned_data['language_code'], 'sr')
def test_only_fields(self):
'Empty form and filled in variant from factory - applies field restriction'
class Form(TranslatableModelForm):
class Meta:
fields = ('shared_field', 'translated_field')
self.assertCountEqual(Form._meta.fields, ['shared_field', 'translated_field'])
self.assertCountEqual(Form._meta.exclude, [])
self.assertCountEqual(Form.base_fields, [])
engineered = translatable_modelform_factory('en', Normal, form=Form)
self.assertCountEqual(engineered._meta.fields, ['shared_field', 'translated_field'])
self.assertCountEqual(engineered._meta.exclude, ['translations'])
self.assertCountEqual(engineered.base_fields, ['shared_field', 'translated_field'])
def get_form_class(self):
if self.model is not None:
model = self.model
elif getattr(self, 'object', None) is not None:
model = self.object.__class__
else:
qs = self.get_queryset()
model = getattr(qs, 'shared_model', qs.model)
kwargs = {}
if self.form_class is not None:
kwargs['form'] = self.form_class
return translatable_modelform_factory(self.get_language(), model, **kwargs)
def get_form_class(self):
if self.model is not None:
model = self.model
elif getattr(self, 'object', None) is not None:
model = self.object.__class__
else:
qs = self.get_queryset()
model = getattr(qs, 'shared_model', qs.model)
kwargs = {}
if self.form_class is not None:
kwargs['form'] = self.form_class
return translatable_modelform_factory(self.get_language(), model, **kwargs)
def test_fields_all(self):
'Empty form and filled in variant from factory - using __all__ special value'
class Form(TranslatableModelForm):
class Meta:
model = Normal
fields = '__all__'
self.assertIs(Form._meta.fields, None)
self.assertCountEqual(Form._meta.exclude, ['translations'])
self.assertCountEqual(Form.base_fields, ['shared_field', 'translated_field'])
engineered = translatable_modelform_factory('en', Normal, form=Form)
self.assertIs(engineered._meta.fields, None)
self.assertCountEqual(engineered._meta.exclude, ['translations'])
self.assertCountEqual(engineered.base_fields, ['shared_field', 'translated_field'])
def test_create_enforcing(self):
'Calling save() on a new instance with a language_code in cleaned_data'
Form = translatable_modelform_factory('ja', Normal, form=NormalForm)
data = {
'shared_field': 'shared',
'translated_field': 'Japanese',
}
with translation.override('en'):
form = Form(data, instance=Normal(language_code='sr'))
with self.assertNumQueries(2):
obj = form.save()
with self.assertNumQueries(0):
self.assertNotEqual(obj.pk, None)
self.assertEqual(obj.language_code, 'ja')
self.assertEqual(obj.shared_field, 'shared')
self.assertEqual(obj.translated_field, 'Japanese')
def test_create_enforcing(self):
'Calling save() on a new instance with a language_code in cleaned_data'
Form = translatable_modelform_factory('ja', Normal, form=NormalForm)
data = {
'shared_field': 'shared',
'translated_field': 'Japanese',
}
with translation.override('en'):
form = Form(data, instance=Normal(language_code='sr'))
with self.assertNumQueries(2):
obj = form.save()
with self.assertNumQueries(0):
self.assertNotEqual(obj.pk, None)
self.assertEqual(obj.language_code, 'ja')
self.assertEqual(obj.shared_field, 'shared')
self.assertEqual(obj.translated_field, 'Japanese')
def test_fields_all(self):
'Empty form and filled in variant from factory - using __all__ special value'
class Form(TranslatableModelForm):
class Meta:
model = Normal
fields = '__all__'
self.assertIs(Form._meta.fields, None)
self.assertCountEqual(Form._meta.exclude, ['translations'])
self.assertCountEqual(Form.base_fields,
['shared_field', 'translated_field'])
engineered = translatable_modelform_factory('en', Normal, form=Form)
self.assertIs(engineered._meta.fields, None)
self.assertCountEqual(engineered._meta.exclude, ['translations'])
self.assertCountEqual(engineered.base_fields,
['shared_field', 'translated_field'])
def test_update_enforcing(self):
'Calling save on an existing instance, with a language_code in cleaned_data'
Form = translatable_modelform_factory('sr', Normal, form=NormalForm)
data = {
'shared_field': 'shared',
'translated_field': u'српски',
}
with translation.override('en'):
# wrong translation is loaded, override it
form = Form(data, instance=Normal.objects.language('ja').get(pk=self.normal_id[1]))
with self.assertNumQueries(3 if django.VERSION >= (1, 6) else 4):
obj = form.save()
with self.assertNumQueries(0):
self.assertEqual(obj.pk, self.normal_id[1])
self.assertEqual(obj.language_code, 'sr')
self.assertEqual(obj.shared_field, 'shared')
self.assertEqual(obj.translated_field, u'српски')
self.assertEqual(Normal.objects.language('sr').get(pk=self.normal_id[1]).translated_field,
u'српски')
def test_update_enforcing(self):
'Calling save on an existing instance, with a language_code in cleaned_data'
Form = translatable_modelform_factory('sr', Normal, form=NormalForm)
data = {
'shared_field': 'shared',
'translated_field': u'српски',
}
with translation.override('en'):
# wrong translation is loaded, override it
form = Form(data, instance=Normal.objects.language('ja').get(pk=self.normal_id[1]))
with self.assertNumQueries(3 if django.VERSION >= (1, 6) else 4):
obj = form.save()
with self.assertNumQueries(0):
self.assertEqual(obj.pk, self.normal_id[1])
self.assertEqual(obj.language_code, 'sr')
self.assertEqual(obj.shared_field, 'shared')
self.assertEqual(obj.translated_field, u'српски')
self.assertEqual(Normal.objects.language('sr').get(pk=self.normal_id[1]).translated_field,
u'српски')
def test_instance_wrong_translation(self):
# no language enforced
form = NormalForm(instance=Normal.objects.language('en').get(pk=self.normal_id[1]))
self.assertFalse(form.is_valid())
self.assertCountEqual(form.initial, ['shared_field', 'translated_field'])
self.assertEqual(form.initial['shared_field'], NORMAL[1].shared_field)
self.assertEqual(form.initial['translated_field'], NORMAL[1].translated_field['en'])
self.assertIn('value="%s"' % NORMAL[1].shared_field, form.as_p())
self.assertIn('value="%s"' % NORMAL[1].translated_field['en'], form.as_p())
self.assertEqual(get_cached_translation(form.instance).language_code, 'en')
# enforce japanese language
Form = translatable_modelform_factory('ja', Normal, form=NormalForm)
form = Form(instance=Normal.objects.language('en').get(pk=self.normal_id[1]))
self.assertFalse(form.is_valid())
self.assertCountEqual(form.initial, ['shared_field', 'translated_field'])
self.assertEqual(form.initial['shared_field'], NORMAL[1].shared_field)
self.assertEqual(form.initial['translated_field'], NORMAL[1].translated_field['ja'])
self.assertIn('value="%s"' % NORMAL[1].shared_field, form.as_p())
self.assertIn('value="%s"' % NORMAL[1].translated_field['ja'], form.as_p())
self.assertEqual(get_cached_translation(form.instance).language_code, 'en')
def test_set_fields_before_save(self):
'Manually set some translated fields before calling save()'
Form = translatable_modelform_factory('sr', Normal, form=NormalForm,
exclude=['translated_field'])
data = {
'shared_field': 'shared',
}
with translation.override('en'):
form = Form(data, instance=Normal.objects.language('ja').get(pk=self.normal_id[1]))
with self.assertNumQueries(1):
self.assertTrue(form.is_valid())
form.instance.translated_field = u'ћирилица'
with self.assertNumQueries(2 if django.VERSION >= (1, 6) else 3):
obj = form.save()
with self.assertNumQueries(0):
self.assertEqual(obj.pk, self.normal_id[1])
self.assertEqual(obj.language_code, 'sr')
self.assertEqual(obj.shared_field, 'shared')
self.assertEqual(obj.translated_field, u'ћирилица')
self.assertEqual(Normal.objects.language('sr').get(pk=self.normal_id[1]).translated_field,
u'ћирилица')
def get_form(self, request, obj=None, **kwargs):
"""
Returns a Form class for use in the admin add view. This is used by
add_view and change_view.
"""
if django.VERSION >= (1, 6):
# From v1.6 on, using get_fieldsets is ok, as long as no 'fields'
# argument was given. It allows dynamic fieldsets on admin form.
if 'fields' in kwargs:
fields = kwargs.pop('fields')
else:
fields = flatten_fieldsets(self.get_fieldsets(request, obj))
else:
# On previous versions, calling get_fieldsets triggers infinite recursion
# and we should stick to statically declared fieldsets
if self.declared_fieldsets:
fields = flatten_fieldsets(self.declared_fieldsets)
else:
fields = None
if self.exclude is None:
exclude = []
else:
exclude = list(self.exclude)
exclude.extend(kwargs.get("exclude", []))
exclude.extend(self.get_readonly_fields(request, obj))
# Exclude language_code, adding it again to the instance is done by
# the LanguageAwareCleanMixin (see translatable_modelform_factory)
exclude.append('language_code')
old_formfield_callback = curry(self.formfield_for_dbfield,
request=request)
defaults = {
"form": self.form,
"fields": fields,
"exclude": exclude,
"formfield_callback": old_formfield_callback,
}
defaults.update(kwargs)
language = self._language(request)
return translatable_modelform_factory(language, self.model, **defaults)
def get_form(self, request, obj=None, **kwargs):
"""
Returns a Form class for use in the admin add view. This is used by
add_view and change_view.
"""
if django.VERSION >= (1, 6):
# From v1.6 on, using get_fieldsets is ok, as long as no 'fields'
# argument was given. It allows dynamic fieldsets on admin form.
if 'fields' in kwargs:
fields = kwargs.pop('fields')
else:
fields = flatten_fieldsets(self.get_fieldsets(request, obj))
else:
# On previous versions, calling get_fieldsets triggers infinite recursion
# and we should stick to statically declared fieldsets
if self.declared_fieldsets:
fields = flatten_fieldsets(self.declared_fieldsets)
else:
fields = None
if self.exclude is None:
exclude = []
else:
exclude = list(self.exclude)
exclude.extend(kwargs.get("exclude", []))
exclude.extend(self.get_readonly_fields(request, obj))
# Exclude language_code, adding it again to the instance is done by
# the LanguageAwareCleanMixin (see translatable_modelform_factory)
exclude.append('language_code')
old_formfield_callback = curry(self.formfield_for_dbfield,
request=request)
defaults = {
"form": self.form,
"fields": fields,
"exclude": exclude,
"formfield_callback": old_formfield_callback,
}
defaults.update(kwargs)
language = self._language(request)
return translatable_modelform_factory(language, self.model, **defaults)
def test_instance_untranslated(self):
# no language enforced, should load anyway
with translation.override('en'):
form = NormalForm(instance=Normal.objects.untranslated().get(pk=self.normal_id[1]))
self.assertFalse(form.is_valid())
self.assertCountEqual(form.initial, ['shared_field', 'translated_field'])
self.assertEqual(form.initial['shared_field'], NORMAL[1].shared_field)
self.assertEqual(form.initial['translated_field'], NORMAL[1].translated_field['en'])
self.assertIn('value="%s"' % NORMAL[1].shared_field, form.as_p())
self.assertIn('value="%s"' % NORMAL[1].translated_field['en'], form.as_p())
self.assertIs(get_cached_translation(form.instance), None)
# enforce japanese language
with translation.override('en'):
Form = translatable_modelform_factory('ja', Normal, form=NormalForm)
form = Form(instance=Normal.objects.untranslated().get(pk=self.normal_id[1]))
self.assertFalse(form.is_valid())
self.assertCountEqual(form.initial, ['shared_field', 'translated_field'])
self.assertEqual(form.initial['shared_field'], NORMAL[1].shared_field)
self.assertEqual(form.initial['translated_field'], NORMAL[1].translated_field['ja'])
self.assertIn('value="%s"' % NORMAL[1].shared_field, form.as_p())
self.assertIn('value="%s"' % NORMAL[1].translated_field['ja'], form.as_p())
self.assertIs(get_cached_translation(form.instance), None)
def get_form(self, request, obj=None, **kwargs):
"""
Returns a Form class for use in the admin add view. This is used by
add_view and change_view.
"""
if 'fields' in kwargs:
fields = kwargs.pop('fields')
else:
fields = flatten_fieldsets(self.get_fieldsets(request, obj))
exclude = (
tuple(self.exclude or ()) +
tuple(kwargs.pop("exclude", ())) +
self.get_readonly_fields(request, obj)
)
old_formfield_callback = curry(self.formfield_for_dbfield, request=request)
defaults = {
"form": self.form,
"fields": fields,
"exclude": exclude,
"formfield_callback": old_formfield_callback,
}
defaults.update(kwargs)
language = self._language(request)
return translatable_modelform_factory(language, self.model, **defaults)
def get_form_class(self):
language = self._language(self.request)
return translatable_modelform_factory(language,
self.model,
form=self.form_class)
def get_form_class(self):
return translatable_modelform_factory(self.get_language(), self.model, AppForm)
def get_form_class(self):
language = self._language(self.request)
return translatable_modelform_factory(language, self.model, form=self.form_class)
