def translatable_default(
inner_default: Union[str, Callable[[], str]]
) -> Dict[str, str]:
"""Return default from inner field as dict with current language"""
lang = get_current_language_code()
if callable(inner_default):
return {lang: inner_default()}
return {lang: inner_default}
def value_from_object(self, obj):
"""Return the value of this field in the given model instance."""
all_ts = getattr(obj, f"{self.name}_tsall")
if type(all_ts) is not dict:
logger.warning(
"Displaying an untranslatable field - model:{} (pk:{}), field:{}".format(
type(obj), obj.pk, self.name
)
)
return str(all_ts)
language = get_current_language_code()
return all_ts.get(language, None)
def migrate(apps: Apps, schema_editor: BaseDatabaseSchemaEditor) -> None:
current_lang = get_current_language_code()
for model_name, fields in model_fields.items():
updated = []
model = apps.get_model(app_label, model_name)
for item in model.objects.all():
for field_name in fields:
# Set new value retrieved from update function
value = getattr(item, field_name)
setattr(item, field_name, update(current_lang, value))
updated.append(item)
# Bulk update only the required fields
model.objects.bulk_update(updated, fields)
def test_author_reverse_migration(self):
"""Test migrating data in author back to original state"""
lang = get_current_language_code()
self.nice.author = json.dumps({lang: self.nice.author})
self.nice.save()
self.bad.author = json.dumps({lang: self.bad.author})
self.bad.save()
migration = get_migration("library_app", {"book": ["author"]})
# Call backward migration directly with current apps
migration.reverse_code(apps, None)
self.nice.refresh_from_db()
self.assertEqual(self.nice.author, "Nice")
self.bad.refresh_from_db()
self.assertEqual(self.bad.author, "Bad")
def __new__(cls, content, fallback: Callable = None):
current_language_code = get_current_language_code()
has_current_language = current_language_code in content.keys()
if has_current_language:
fallback_language = None
text = content.get(current_language_code)
else:
if fallback:
fallback_language, text = fallback(content)
else:
fallback_language, text = cls.get_fallback_text(content)
instance = super().__new__(cls, text)
instance.translations = codes_to_langs(content)
instance.is_fallback = not has_current_language
instance.fallback_language = fallback_language
return instance
def translator(ego, value):
"""Setter for main field (without _tsall)"""
all_ts = getattr(ego, f"{name}_tsall")
if not all_ts:
# This is probably the first save through
all_ts = {}
elif type(all_ts) is not dict:
logger.warning(
"Saving a broken field - model:{} (pk:{}), field:{}".format(
type(ego), ego.pk, name
)
)
logger.debug("Field data was - {}".format(all_ts))
all_ts = {}
if isinstance(value, str):
language_code = get_current_language_code()
all_ts[language_code] = value
elif isinstance(value, dict):
all_ts = value
else:
raise TypeError("Invalid type assigned to translatable field")
setattr(ego, f"{name}_tsall", all_ts)
def get_ordering(self):
code = get_current_language_code()
return f"title__{code}"
def test_view(request):
lang = get_current_language_code()
self.assertEqual(lang, "de")
return HttpResponse("Nice")
