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
model_opts = opts.model._meta
object_data = {}
language = getattr(self, 'language', get_language())
if instance is not None:
trans = get_cached_translation(instance)
if not trans or trans.language_code != language:
try:
trans = get_translation(instance, language)
except model_opts.translations_model.DoesNotExist:
trans = None
if trans:
object_data = model_to_dict(trans, opts.fields, opts.exclude)
# Dirty hack that swaps the id from the translation id, to the master id
# This is necessary, because we in this case get the untranslated instance,
# and thereafter get the correct translation on save.
if object_data.has_key("id"):
object_data["id"] = trans.master.id
if initial is not None:
object_data.update(initial)
initial = object_data
super(TranslatableModelForm, self).__init__(data, files, auto_id,
prefix, initial,
error_class, label_suffix,
empty_permitted, instance)
def save(self, commit=True):
if self.instance.pk is None:
fail_message = 'created'
new = True
else:
fail_message = 'changed'
new = False
super(TranslatableModelForm, self).save(True)
trans_model = self.instance._meta.translations_model
language_code = self.cleaned_data.get('language_code', get_language())
if not new:
trans = get_cached_translation(self.instance)
if not trans or trans.language_code != language_code:
try:
trans = get_translation(self.instance, language_code)
except trans_model.DoesNotExist:
trans = trans_model()
else:
trans = trans_model()
trans.language_code = language_code
trans.master = self.instance
trans = save_instance(self,
trans,
self._meta.fields,
fail_message,
commit,
construct=True)
return combine(trans)
def save(self, commit=True):
if self.instance.pk is None:
fail_message = 'created'
new = True
else:
fail_message = 'changed'
new = False
super(TranslatableModelForm, self).save(True)
trans_model = self.instance._meta.translations_model
language_code = self.cleaned_data.get('language_code', get_language())
if not new:
trans = get_cached_translation(self.instance)
if not trans:
try:
trans = get_translation(self.instance, language_code)
except trans_model.DoesNotExist:
trans = trans_model()
else:
trans = trans_model()
trans.language_code = language_code
trans.master = self.instance
trans = save_instance(self, trans, self._meta.fields, fail_message,
commit, construct=True)
return combine(trans)
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
model_opts = opts.model._meta
object_data = {}
if instance is not None:
trans = get_cached_translation(instance)
if not trans:
try:
trans = get_translation(instance, self.language)
except model_opts.translations_model.DoesNotExist:
trans = None
if trans:
object_data = model_to_dict(trans, opts.fields, opts.exclude)
if initial is not None:
object_data.update(initial)
initial = object_data
super(TranslatableModelForm, self).__init__(data, files, auto_id,
prefix, object_data,
error_class, label_suffix,
empty_permitted, instance)
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
model_opts = opts.model._meta
object_data = {}
language = getattr(self, 'language', get_language())
if instance is not None:
trans = get_cached_translation(instance)
if not trans:
try:
trans = get_translation(instance, language)
except model_opts.translations_model.DoesNotExist:
trans = None
if trans:
object_data = model_to_dict(trans, opts.fields, opts.exclude)
if initial is not None:
object_data.update(initial)
initial = object_data
super(TranslatableModelForm,
self).__init__(data, files, auto_id, prefix, object_data,
error_class, label_suffix, empty_permitted,
instance)
def _post_clean(self):
if self.instance.pk:
try:
trans = trans = get_translation(self.instance, self.instance.language_code)
trans.master = self.instance
self.instance = combine(trans)
except self.instance._meta.translations_model.DoesNotExist:
language_code = self.cleaned_data.get('language_code', get_language())
self.instance = self.instance.translate(language_code)
return super(TranslatableModelForm, self)._post_clean()
def _post_clean(self):
if self.instance.pk:
try:
trans = trans = get_translation(self.instance,
self.instance.language_code)
trans.master = self.instance
self.instance = combine(trans)
except self.instance._meta.translations_model.DoesNotExist:
language_code = self.cleaned_data.get('language_code',
get_language())
self.instance = self.instance.translate(language_code)
return super(TranslatableModelForm, self)._post_clean()
def iterator(self):
if self._translation_fallbacks:
opts = self.model._meta
fallbacks = list(self._translation_fallbacks)
for instance in super(FallbackQueryset, self).iterator():
for fallback in fallbacks:
try:
cached = get_translation(instance, fallback)
except opts.translations_model.DoesNotExist:
continue
setattr(instance, opts.translations_cache, cached)
break
yield instance
else:
for instance in super(FallbackQueryset, self).iterator():
yield instance
def __set__(self, instance, value):
"""
Setting the language_code attribute is a bit odd.
When changing the language_code on an instance, we try to grab the
existing translation and copy over the unfilled fields from that
translation onto the instance. If no such translation exist, create one
and copy over the fields from the instance.
This is used to translate instances.
This will also refresh the translations cache attribute on the instance.
EG:
english = MyModel.objects.get(pk=1, language_code='en')
english.language_code = 'ja'
english.save()
japanese = MyModel.objects.get(pk=1, language_code='ja')
"""
if not instance:
raise AttributeError()
tmodel = instance._meta.translations_model
try:
other_lang = get_translation(instance, value)
except tmodel.DoesNotExist:
other_lang = tmodel()
for field in other_lang._meta.get_all_field_names():
val = getattr(instance, field, NULL)
if val is NULL:
continue
if field == 'pk':
continue
if field == tmodel._meta.pk.name:
continue
if callable(getattr(val, 'all', None)):
val = val.all()
setattr(other_lang, field, val)
other_lang.language_code = value
other_lang.master = instance
setattr(instance, instance._meta.translations_cache, other_lang)
def save(self, *args, **kwargs):
obj = super(TranslatableAdminBaseForm, self).save(*args, **kwargs)
for form in self.inner_trans_forms:
new = form.instance.pk is None
cd = form.cleaned_data
print cd
trans_model = form.instance.__class__
language_code = form.instance.language_code
try:
trans = get_translation(obj, language_code)
except trans_model.DoesNotExist:
trans = trans_model()
for field_name in obj._translated_field_names:
if field_name in ['id', 'master', 'language_code']:
continue
setattr(trans, field_name,
cd["".join([field_name, "_", language_code])])
trans.language_code = language_code
trans.master = obj
trans.save()
return obj
def __init__(self, *args, **kwargs):
self.instance = kwargs.pop('instance')
languages = []
if kwargs.has_key('languages'):
languages = kwargs.pop('languages')
super(TranslatableAdminBaseForm, self).__init__(instance=self.instance,
*args,
**kwargs)
self.inner_trans_forms = []
for language in languages:
trans_model = self._meta.model._meta.translations_model
try:
trans = get_translation(self.instance, language.code)
except trans_model.DoesNotExist:
trans = trans_model()
trans.language_code = language.code
fields = {}
for field_name in self.instance._translated_field_names:
if field_name in ['id', 'master', 'language_code']:
continue
fields["".join([field_name, "_",
language.code])] = forms.CharField(
max_length=1000,
initial=getattr(trans, field_name),
label=field_name.capitalize())
fields['language_code_' + language.code] = forms.CharField(
widget=forms.HiddenInput(), initial=language.code, label='')
trans_form = type(
'AdminTransForm', (forms.BaseForm, ),
dict(
instance=trans,
prefix="".join(["trans_", language.code, "_form"]),
base_fields=fields,
))(*args, **kwargs)
setattr(self, "".join(["trans_", language.code, "_form"]),
trans_form)
self.inner_trans_forms.append(trans_form)
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
model_opts = opts.model._meta
object_data = {}
language = getattr(self, 'language', get_language())
if instance is not None:
trans = get_cached_translation(instance)
if not trans or trans.language_code != language:
try:
trans = get_translation(instance, language)
except model_opts.translations_model.DoesNotExist:
trans = None
if trans:
object_data = model_to_dict(trans, opts.fields, opts.exclude)
# Dirty hack that swaps the id from the translation id, to the master id
# This is necessary, because we in this case get the untranslated instance,
# and thereafter get the correct translation on save.
if object_data.has_key("id"):
object_data["id"] = trans.master.id
if initial is not None:
object_data.update(initial)
initial = object_data
super(TranslatableModelForm,
self).__init__(data, files, auto_id, prefix, initial,
error_class, label_suffix, empty_permitted,
instance)
def translation(self, instance):
cached = getattr(instance, self.opts.translations_cache, None)
if not cached:
cached = get_translation(instance)
setattr(instance, self.opts.translations_cache, cached)
return cached
def trans_for_value(value):
return [
get_translation(value, lang)
for lang in instance.get_available_languages()
],
def trans_for_instance(instance):
return [get_translation(instance, lang) for lang in instance.get_available_languages()]
def translation(self, instance):
cached = getattr(instance, self.opts.translations_cache, None)
if not cached:
cached = get_translation(instance)
setattr(instance, self.opts.translations_cache, cached)
return cached
