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)