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")