def handle(self, *args, **options):
""" command execution """
assume_yes = options.get('assume_yes', False)
default_language = options.get('default_language', None)
with transaction.atomic():
self.cursor = connection.cursor()
self.introspection = connection.introspection
self.default_lang = default_language or mandatory_language()
all_models = get_models()
found_db_change_fields = False
for model in all_models:
if hasattr(model._meta, 'translatable_fields'):
model_full_name = '%s.%s' % (model._meta.app_label,
model._meta.model_name)
translatable_fields = get_all_translatable_fields(
model, column_in_current_table=True)
db_table = model._meta.db_table
for field_name in translatable_fields:
db_table_fields = self.get_table_fields(db_table)
db_change_langs = list(
set(
list(
self.get_db_change_languages(
field_name, db_table_fields)) +
[self.default_lang]))
if db_change_langs:
sql_sentences = self.get_sync_sql(
field_name, db_change_langs, model,
db_table_fields)
if sql_sentences:
found_db_change_fields = True
print_db_change_langs(db_change_langs,
field_name,
model_full_name)
execute_sql = ask_for_confirmation(
sql_sentences, model_full_name, assume_yes)
if execute_sql:
print('Executing SQL...')
for sentence in sql_sentences:
self.cursor.execute(sentence)
# commit
print('Done')
else:
print('SQL not executed')
if not found_db_change_fields:
print('\nNo new translatable fields detected')
if default_language:
variable = 'TRANSMETA_DEFAULT_LANGUAGE'
has_transmeta_default_language = getattr(settings, variable, False)
if not has_transmeta_default_language:
variable = 'LANGUAGE_CODE'
if getattr(settings, variable) != default_language:
print(
('\n\nYou should change in your settings '
'the %s variable to "%s"' % (variable, default_language)))
def render(self, context):
form = template.Variable(self.form_variable).resolve(context)
fields = self.fields
# if it is a modelform, get real fieldnames of translated fields from transmeta
if hasattr(form, '_meta') and hasattr(form._meta, 'model'):
try:
from transmeta import get_all_translatable_fields, get_real_fieldname_in_each_language
trans_fields = get_all_translatable_fields(form._meta.model)
for field in trans_fields:
if field in fields:
fields.remove(field)
fields.extend(get_real_fieldname_in_each_language(field))
print fields
except ImportError:
pass
new_form = copy.copy(form)
new_form.fields = SortedDict([(key, value) for key, value in form.fields.items() if key in fields])
context[self.variable_name] = new_form
return u''
def handle(self, *args, **options):
""" command execution """
assume_yes = options.get('assume_yes', False)
default_language = options.get('default_language', None)
drop = options.get('drop', False)
# set manual transaction management
transaction.commit_unless_managed()
transaction.enter_transaction_management()
transaction.managed(True)
self.cursor = connection.cursor()
self.introspection = connection.introspection
self.default_lang = default_language or fallback_language()
all_models = get_models()
found_db_change_fields = False
for model in all_models:
if hasattr(model._meta, 'translatable_fields'):
model_full_name = '%s.%s' % (model._meta.app_label, model._meta.module_name)
translatable_fields = get_all_translatable_fields(model, column_in_current_table=True)
db_table = model._meta.db_table
for field_name in translatable_fields:
db_table_fields = self.get_table_fields(db_table)
db_change_langs = list(set(list(self.get_db_change_languages(field_name, db_table_fields)) + [self.default_lang]))
if db_change_langs:
sql_sentences = self.get_sync_sql(field_name, db_change_langs, model, db_table_fields, drop=drop)
if sql_sentences:
found_db_change_fields = True
print_db_change_langs(db_change_langs, field_name, model_full_name)
execute_sql = ask_for_confirmation(sql_sentences, model_full_name, assume_yes)
if execute_sql:
print 'Executing SQL...',
for sentence in sql_sentences:
self.cursor.execute(sentence)
# commit
transaction.commit()
print 'Done'
else:
print 'SQL not executed'
if transaction.is_dirty():
transaction.commit()
transaction.leave_transaction_management()
if not found_db_change_fields:
print '\nNo new translatable fields detected'
if default_language:
variable = 'TRANSMETA_DEFAULT_LANGUAGE'
has_transmeta_default_language = getattr(settings, variable, False)
if not has_transmeta_default_language:
variable = 'LANGUAGE_CODE'
if getattr(settings, variable) != default_language:
print ('\n\nYou should change in your settings '
'the %s variable to "%s"' % (variable, default_language))
def handle(self, *args, **options):
""" command execution """
assume_yes = options.get('assume_yes', False)
default_language = options.get('default_language', None)
self.delete_columns = options.get('delete_columns', None)
self.cursor = connection.cursor()
self.introspection = connection.introspection
self.default_lang = default_language or mandatory_language()
self.ignored_langs = set()
self.ignored_fields = {}
all_models = get_models()
found_db_change_fields = False
for model in all_models:
if hasattr(model._meta, 'translatable_fields'):
model_full_name = '%s.%s' % (model._meta.app_label, model._meta.module_name)
translatable_fields = get_all_translatable_fields(model, column_in_current_table=True)
db_table = model._meta.db_table
db_table_fields = self.get_table_fields(db_table)
for field_name in translatable_fields:
db_change_langs = list(set(list(self.get_db_change_languages(field_name, db_table_fields)) + [self.default_lang]))
if db_change_langs:
sql_sentences = self.get_sync_sql(field_name, db_change_langs, model, db_table_fields)
if sql_sentences:
found_db_change_fields = True
print_db_change_langs(db_change_langs, field_name, model_full_name)
execute_sql = ask_for_confirmation(sql_sentences, model_full_name, assume_yes)
if execute_sql:
print ('Executing SQL...')
with transaction.commit_on_success():
for sentence in sql_sentences:
self.cursor.execute(sentence)
print ('Done')
else:
print ('SQL not executed')
if self.ignored_langs:
print ("Ignored languages: %s" % ', '.join(self.ignored_langs))
print ("Ignored fields:")
for model, fields in self.ignored_fields.items():
print (" %s: %s" % (model, ', '.join(fields)))
print ("Use -D to delete")
if not found_db_change_fields:
print ('\nNo new translatable fields detected')
if default_language:
variable = 'TRANSMETA_DEFAULT_LANGUAGE'
has_transmeta_default_language = getattr(settings, variable, False)
if not has_transmeta_default_language:
variable = 'LANGUAGE_CODE'
if getattr(settings, variable) != default_language:
print (('\n\nYou should change in your settings '
'the %s variable to "%s"' % (variable, default_language)))
def handle(self, *args, **options):
""" command execution """
assume_yes = options.get('assume_yes', False)
default_language = options.get('default_language', None)
# set manual transaction management
transaction.commit_unless_managed()
transaction.enter_transaction_management()
transaction.managed(True)
self.cursor = connection.cursor()
self.introspection = connection.introspection
self.default_lang = ask_for_default_language(assume_yes,
default_language)
all_models = get_models()
found_missing_fields = False
for model in all_models:
if hasattr(model._meta, 'translatable_fields'):
model_full_name = '%s.%s' % (model._meta.app_label,
model._meta.module_name)
translatable_fields = get_all_translatable_fields(
model, column_in_current_table=True)
db_table = model._meta.db_table
for field_name in translatable_fields:
missing_langs = list(
set(
list(
self.get_missing_languages(
field_name, db_table)) +
[self.default_lang]))
if missing_langs:
found_missing_fields = True
print_missing_langs(missing_langs, field_name,
model_full_name)
sql_sentences = self.get_sync_sql(
field_name, missing_langs, model)
if sql_sentences:
execute_sql = ask_for_confirmation(
sql_sentences, model_full_name, assume_yes)
if execute_sql:
print 'Executing SQL...',
for sentence in sql_sentences:
self.cursor.execute(sentence)
# commit
transaction.commit()
print 'Done'
else:
print 'SQL not executed'
transaction.leave_transaction_management()
if not found_missing_fields:
print '\nNo new translatable fields detected'
def _test_save_fields(self, model, field_names=None):
client = self.__client_login()
obj = model.objects.all()[0]
module_name = model._meta.module_name
app_label = model._meta.app_label
field_names = field_names or model._meta.get_all_field_names()
for field_name in field_names:
if field_name in transmeta.get_all_translatable_fields(model):
field = model._meta.get_field_by_name(transmeta.get_fallback_fieldname(field_name))[0]
else:
field = model._meta.get_field_by_name(field_name)[0]
if field_name == 'id' or field_name.endswith('_id'): # id or id fk
continue
if isinstance(field, models.FileField):
continue
url = reverse('inplace_save')
value = getattr(obj, field_name)
if isinstance(value, datetime.datetime):
value = '"1982-11-14 03:13:12"'
elif isinstance(value, datetime.date):
value = '"1982-11-14"'
elif isinstance(value, datetime.time):
value = '"03:13:12"'
else:
if hasattr(value, 'all'):
value = [str(obj_rel.pk) for obj_rel in value.model.objects.all()]
elif isinstance(value, decimal.Decimal):
value = float(value) + 10
elif (isinstance(value, string) and
isinstance(field, models.CharField) and
not isinstance(field, models.CommaSeparatedIntegerField) and
not isinstance(field, models.EmailField)):
if field.choices:
value = field.choices[0][0]
else:
value += '_save'
elif isinstance(field, models.CommaSeparatedIntegerField):
value += ',44'
elif isinstance(field, models.EmailField):
value = '*****@*****.**'
elif isinstance(field, models.ForeignKey):
value = field.rel.to.objects.all()[0].pk
elif isinstance(field, bool):
value = not value
value = json.dumps(value)
adaptor = get_adaptor_class(obj=obj, field_name=field_name)(None, obj, field_name).name
data = {'app_label': app_label,
'module_name': module_name,
'field_name': field_name,
'value': value,
'obj_id': obj.pk,
'adaptor': adaptor}
response = client.post(url, data)
self.assertEqual(response.status_code, 200)
self.assertEqual(json.loads(response.content.decode('utf-8')).get('errors', None), False)
def pre_processing_transmeta_fields(model, field_list):
translatable_fields = transmeta.get_all_translatable_fields(model)
for translatable_field in translatable_fields:
fields_to_remove = transmeta.get_real_fieldname_in_each_language(translatable_field)
for i, field_to_remove in enumerate(fields_to_remove):
if i == 0:
index = field_list.index(field_to_remove)
field_list[index] = translatable_field
else:
field_list.remove(field_to_remove)
return field_list
def get_common_field_translated_name(collection, field):
"""
Return the translation field if it exists for all collection models,
or the original field otherwise.
"""
model = collection.get_first_parents_of_content_types()
if not model:
return field
import transmeta
translatables = transmeta.get_all_translatable_fields(model)
common_fields = get_common_fields(collection)
if field in translatables:
real_field = get_real_fieldname(field)
if real_field in common_fields:
return real_field
return field
def handle(self, *args, **options):
""" command execution """
assume_yes = options.get('assume_yes', False)
default_language = options.get('default_language', None)
# set manual transaction management
transaction.commit_unless_managed()
transaction.enter_transaction_management()
transaction.managed(True)
self.cursor = connection.cursor()
self.introspection = connection.introspection
self.default_lang = ask_for_default_language(assume_yes, default_language)
all_models = get_models()
found_missing_fields = False
for model in all_models:
if hasattr(model._meta, 'translatable_fields'):
model_full_name = '%s.%s' % (model._meta.app_label, model._meta.module_name)
translatable_fields = get_all_translatable_fields(model, column_in_current_table=True)
db_table = model._meta.db_table
for field_name in translatable_fields:
missing_langs = list(set(list(self.get_missing_languages(field_name, db_table)) + [self.default_lang]))
if missing_langs:
found_missing_fields = True
print_missing_langs(missing_langs, field_name, model_full_name)
sql_sentences = self.get_sync_sql(field_name, missing_langs, model)
if sql_sentences:
execute_sql = ask_for_confirmation(sql_sentences, model_full_name, assume_yes)
if execute_sql:
print 'Executing SQL...',
for sentence in sql_sentences:
self.cursor.execute(sentence)
# commit
transaction.commit()
print 'Done'
else:
print 'SQL not executed'
transaction.leave_transaction_management()
if not found_missing_fields:
print '\nNo new translatable fields detected'
def _generate_cached_plain_text(self):
if self.id:
instance = self.get_real_instance()
else:
instance = self
to_store = instance.store_plain
translated_fields = get_all_translatable_fields(instance.__class__)
for lang in settings.LANGUAGES:
setattr(self, 'cached_plain_text_%s' % lang[0], '')
for field_name in to_store:
for lang_code, lang_name in settings.LANGUAGES:
cached = getattr(self, 'cached_plain_text_%s' % lang_code, '')
if field_name in translated_fields:
cached += self._convert_to_plain(getattr(self, '%s_%s' % (field_name, lang_code), ''))
else:
cached += self._convert_to_plain(getattr(self, field_name, ''))
if cached:
cached += " "
setattr(self, 'cached_plain_text_%s' % lang_code, cached)
class Deserializer(xml_serializer.Deserializer):
"""
Deserialize XML.
Like Django XML deserializer, with these improvements:
* Translations fields support.
* Option for not overwrite objects previously loaded in your site.
"""
def next(self):
for event, node in self.event_stream:
if event == "START_ELEMENT" and node.nodeName == "object":
if node.hasAttribute("overwrite") and \
node.getAttribute("overwrite") == 'no':
Model = self._get_model_from_node(node, "model")
pk = node.getAttribute("pk")
if not pk:
raise base.DeserializationError(
"<object> node is missing the 'pk' attribute")
if not node.hasAttribute("compare-by"):
filters = {'pk': Model._meta.pk.to_python(pk)}
else: # comparing by custom field defined in the fixture
field = str(node.getAttribute("compare-by"))
value = node.getAttribute(field)
filters = {field: value}
if Model._base_manager.filter(**filters):
# if object is found we will not overwrite it
# because is marked as non overridable
continue
self.event_stream.expandNode(node)
return self._handle_object(node)
raise StopIteration
def _handle_object(self, node):
"""
Convert an <object> node to a DeserializedObject.
"""
# Look up the model using the model loading mechanism. If this fails,
# bail.
Model = self._get_model_from_node(node, "model")
# Start building a data dictionary from the object. If the node is
# missing the pk attribute, fail.
pk = node.getAttribute("pk")
if not pk:
raise base.DeserializationError(
"<object> node is missing the 'pk' attribute")
data = {Model._meta.pk.attname: Model._meta.pk.to_python(pk)}
# Also start building a dict of m2m data (this is saved as
# {m2m_accessor_attribute : [list_of_related_objects]})
m2m_data = {}
# Deseralize each field.
for field_node in node.getElementsByTagName("field"):
# If the field is missing the name attribute, bail (are you
# sensing a pattern here?)
field_name = field_node.getAttribute("name")
if not field_name:
raise base.DeserializationError(
"<field> node is missing the 'name' attribute")
# Get the field from the Model. This will raise a
# FieldDoesNotExist if, well, the field doesn't exist, which will
# be propagated correctly.
try:
field = Model._meta.get_field(field_name)
except FieldDoesNotExist, e:
try:
language = get_field_language(field_name)
except:
raise e
else:
lang_codes = [l[0] for l in settings.LANGUAGES]
if language not in lang_codes:
# fails silently because the LANGUAGES in these settings
# are not same as fixtures data
continue
else:
raise e
# As is usually the case, relation fields get the special treatment.
if field.rel and isinstance(field.rel, models.ManyToManyRel):
m2m_data[field.name] = self._handle_m2m_field_node(
field_node, field)
elif field.rel and isinstance(field.rel, models.ManyToOneRel):
data[field.attname] = self._handle_fk_field_node(
field_node, field)
else:
if field_node.getElementsByTagName('None'):
value = None
else:
value = field.to_python(
xml_serializer.getInnerText(field_node).strip())
data[field.name] = value
# check there is not any mandatory translatable fields in the fixtures without
# a value in the fallback language. In that case use the english language.
# This is to make the initial fixtures work in languages not included by default
# in fixtures
for trans_field in get_all_translatable_fields(Model):
fallback_fieldname = get_fallback_fieldname(trans_field)
if Model._meta.get_field(fallback_fieldname).null:
continue # not a mandatory field
en_fieldname = get_real_fieldname(trans_field, 'en')
if data.get(fallback_fieldname, None) is None and data.get(
en_fieldname, None) is not None:
data[fallback_fieldname] = data[en_fieldname]
obj = Model(**data)
for field in obj._meta.local_fields:
if isinstance(field, JSONField):
field_name = field.name
setattr(obj, field_name,
getattr(obj, 'get_%s_json' % field_name)())
# Return a DeserializedObject so that the m2m data has a place to live.
return DeserializedObject(obj, m2m_data)
def _test_save_fields(self,
model,
obj=None,
field_names=None,
client=None,
has_error=False):
client = client or self.__client_login()
obj = obj or model.objects.all()[0]
self.assertEqual(model, obj.__class__)
module_name = get_module_name(model)
app_label = model._meta.app_label
field_names = field_names or model._meta.get_all_field_names()
for field_name in field_names:
extra_data = {}
if field_name in transmeta.get_all_translatable_fields(model):
field = model._meta.get_field_by_name(
transmeta.get_fallback_fieldname(field_name))[0]
else:
field = model._meta.get_field_by_name(field_name)[0]
if field_name == 'id' or field_name.endswith('_id'): # id or id fk
continue
url = reverse('inplace_save')
value = getattr(obj, field_name)
if isinstance(field, models.FileField):
value = '"example1.jpg"'
file_path = os.path.join(settings.MEDIA_ROOT, 'images',
'example1.jpg')
extra_data['attachment'] = open(file_path, 'rb')
elif isinstance(value, datetime.datetime):
value = '"1982-11-14 03:13:12"'
elif isinstance(value, datetime.date):
value = '"1982-11-14"'
elif isinstance(value, datetime.time):
value = '"03:13:12"'
else:
if hasattr(value, 'all'):
value = [
str(obj_rel.pk)
for obj_rel in value.model.objects.all()
]
elif isinstance(value, decimal.Decimal):
value = float(value) + 10
elif (isinstance(value, string)
and isinstance(field, models.CharField) and
not isinstance(field, models.CommaSeparatedIntegerField)
and not isinstance(field, models.EmailField)):
if field.choices:
value = field.choices[0][0]
else:
value += '_save'
elif isinstance(field, models.CommaSeparatedIntegerField):
value += ',44'
elif isinstance(field, models.EmailField):
value = '*****@*****.**'
elif isinstance(field, models.ForeignKey):
value = field.rel.to.objects.all()[0].pk
elif isinstance(field, bool):
value = not value
value = json.dumps(value)
adaptor = get_adaptor_class(obj=obj,
field_name=field_name)(None, obj,
field_name).name
data = {
'app_label': app_label,
'module_name': module_name,
'field_name': field_name,
'value': value,
'obj_id': obj.pk,
'adaptor': adaptor
}
data.update(extra_data)
response = client.post(url, data)
self.assertEqual(response.status_code, 200)
self.assertEqual(
bool(
json.loads(response.content.decode('utf-8')).get(
'errors', None)), has_error)
def _test_save_fields(self, model, obj=None, field_names=None, client=None, has_error=False):
client = client or self.__client_login()
obj = obj or model.objects.all()[0]
self.assertEqual(model, obj.__class__)
module_name = model._meta.module_name
app_label = model._meta.app_label
field_names = field_names or model._meta.get_all_field_names()
for field_name in field_names:
extra_data = {}
if field_name in transmeta.get_all_translatable_fields(model):
field = model._meta.get_field_by_name(transmeta.get_fallback_fieldname(field_name))[0]
else:
field = model._meta.get_field_by_name(field_name)[0]
if field_name == "id" or field_name.endswith("_id"): # id or id fk
continue
url = reverse("inplace_save")
value = getattr(obj, field_name)
if isinstance(field, models.FileField):
value = '"example1.jpg"'
file_path = os.path.join(settings.MEDIA_ROOT, "images", "example1.jpg")
extra_data["attachment"] = open(file_path, "rb")
elif isinstance(value, datetime.datetime):
value = '"1982-11-14 03:13:12"'
elif isinstance(value, datetime.date):
value = '"1982-11-14"'
elif isinstance(value, datetime.time):
value = '"03:13:12"'
else:
if hasattr(value, "all"):
value = [str(obj_rel.pk) for obj_rel in value.model.objects.all()]
elif isinstance(value, decimal.Decimal):
value = float(value) + 10
elif (
isinstance(value, string)
and isinstance(field, models.CharField)
and not isinstance(field, models.CommaSeparatedIntegerField)
and not isinstance(field, models.EmailField)
):
if field.choices:
value = field.choices[0][0]
else:
value += "_save"
elif isinstance(field, models.CommaSeparatedIntegerField):
value += ",44"
elif isinstance(field, models.EmailField):
value = "*****@*****.**"
elif isinstance(field, models.ForeignKey):
value = field.rel.to.objects.all()[0].pk
elif isinstance(field, bool):
value = not value
value = json.dumps(value)
adaptor = get_adaptor_class(obj=obj, field_name=field_name)(None, obj, field_name).name
data = {
"app_label": app_label,
"module_name": module_name,
"field_name": field_name,
"value": value,
"obj_id": obj.pk,
"adaptor": adaptor,
}
data.update(extra_data)
response = client.post(url, data)
self.assertEqual(response.status_code, 200)
self.assertEqual(bool(json.loads(response.content.decode("utf-8")).get("errors", None)), has_error)
