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