merge

CHANGELOG

@@ -1,3 +1,4 @@
+* Improve search on translatable fields
 * export_data return empty value for invisible fields
 * Don't allow to use float in Numeric fields
 * set/get function on Fields take a list of ids

trytond/model/browse.py

@@ -103,7 +103,7 @@ class BrowseRecord(object):
                         if not hasattr(x[1], 'get') \
                         and (x[0] not in self._data[self._id] \
                             or x[0] not in self._local_data[self._id]) \
-                        and ((not x[1].translate \
+                        and ((not getattr(x[1], 'translate', False) \
                                 and x[1]._type not in ('text', 'binary')) \
                             or x[0] == name)]
                 # gen the list of inherited fields
@@ -114,7 +114,7 @@ class BrowseRecord(object):
                         and (x[0] not in self._data[self._id] \
                             or x[0] not in self._local_data[self._id]) \
                         and x[0] not in self._model._columns \
-                        and ((not x[1].translate \
+                        and ((not getattr(x[1], 'translate', False) \
                                 and x[1]._type not in ('text', 'binary')) \
                             or x[0] == name)]
             # otherwise we fetch only that field

trytond/model/fields/char.py

@@ -15,13 +15,15 @@ class Char(Field):
             change_default=False, translate=False, select=0, on_change=None,
             on_change_with=None, depends=None, order_field=None, context=None):
         '''
+        :param translate: A boolean. If ``True`` the field is translatable.
         :param size: A integer. If set defines the maximum size of the values.
         '''
         super(Char, self).__init__(string=string, help=help, required=required,
                 readonly=readonly, domain=domain, states=states,
                 priority=priority, change_default=change_default,
-                translate=translate, select=select, on_change=on_change,
+                select=select, on_change=on_change,
                 on_change_with=on_change_with, depends=depends,
                 order_field=order_field, context=context)
+        self.translate = translate
         self.size = size
     __init__.__doc__ += Field.__init__.__doc__

trytond/model/fields/field.py

@@ -53,7 +53,7 @@ class Field(object):
 
     def __init__(self, string='', help='', required=False, readonly=False,
             domain=None, states=None, priority=0, change_default=False,
-            translate=False, select=0, on_change=None, on_change_with=None,
+            select=0, on_change=None, on_change_with=None,
             depends=None, order_field=None, context=None):
         '''
         :param string: A string for label of the field.
@@ -70,7 +70,6 @@ class Field(object):
         :param priority: Give the order in which set methods are called.
         :param change_default: A boolean. If ``True`` the field can be used as
         condition for a custom default value.
-        :param translate: A boolean. If ``True`` the field is translatable.
         :param select: An integer. When equal to ``1``, the field appears in the
             search box in list view and the search will be optimized. When equal to
             ``2`` the field appears in the *Advanced Search* in the search box.
@@ -97,7 +96,6 @@ class Field(object):
         self.states = states or {}
         self.priority = priority
         self.change_default = change_default
-        self.translate = translate
         self.select = select
         self.__on_change = None
         self.on_change = on_change

trytond/model/fields/float.py

@@ -23,18 +23,18 @@ class Float(Field):
 
     def __init__(self, string='', digits=None,  help='', required=False,
             readonly=False, domain=None, states=None, priority=0,
-            change_default=False, translate=False, select=0, on_change=None,
+            change_default=False, select=0, on_change=None,
             on_change_with=None, depends=None, order_field=None, context=None):
         '''
         :param digits: a list of two integers defining the total
             of digits and the number of decimals of the float.
         '''
-        super(Float, self).__init__(string=string, help=help, required=required,
-                readonly=readonly, domain=domain, states=states,
-                priority=priority, change_default=change_default,
-                translate=translate, select=select, on_change=on_change,
-                on_change_with=on_change_with, depends=depends,
-                order_field=order_field, context=context)
+        super(Float, self).__init__(string=string, help=help,
+                required=required, readonly=readonly, domain=domain,
+                states=states, priority=priority,
+                change_default=change_default, select=select,
+                on_change=on_change, on_change_with=on_change_with,
+                depends=depends, order_field=order_field, context=context)
         self.__digits = None
         self.digits = digits
 

trytond/model/fields/many2many.py

@@ -14,8 +14,8 @@ class Many2Many(Field):
     def __init__(self, relation_name, origin, target, string='', order=None,
             datetime_field=None, help='', required=False, readonly=False,
             domain=None, states=None, priority=0, change_default=False,
-            translate=False, select=0, on_change=None, on_change_with=None,
-            depends=None, order_field=None, context=None):
+            select=0, on_change=None, on_change_with=None, depends=None,
+            order_field=None, context=None):
         '''
         :param relation_name: The name of the relation model
             or the name of the target model for ModelView only.
@@ -34,10 +34,10 @@ class Many2Many(Field):
                 depends = [datetime_field]
         super(Many2Many, self).__init__(string=string, help=help,
                 required=required, readonly=readonly, domain=domain,
-                states=states, priority=priority, change_default=change_default,
-                translate=translate, select=select, on_change=on_change,
-                on_change_with=on_change_with, depends=depends,
-                order_field=order_field, context=context)
+                states=states, priority=priority,
+                change_default=change_default, select=select,
+                on_change=on_change, on_change_with=on_change_with,
+                depends=depends, order_field=order_field, context=context)
         self.relation_name = relation_name
         self.origin = origin
         self.target = target

trytond/model/fields/many2one.py

@@ -13,7 +13,7 @@ class Many2One(Field):
     def __init__(self, model_name, string='', left=None, right=None,
             ondelete='SET NULL', datetime_field=None, help='', required=False,
             readonly=False, domain=None, states=None, priority=0,
-            change_default=False, translate=False, select=0, on_change=None,
+            change_default=False, select=0, on_change=None,
             on_change_with=None, depends=None, order_field=None, context=None):
         '''
         :param model_name: The name of the targeted model.
@@ -38,10 +38,10 @@ class Many2One(Field):
                 depends = [datetime_field]
         super(Many2One, self).__init__(string=string, help=help,
                 required=required, readonly=readonly, domain=domain,
-                states=states, priority=priority, change_default=change_default,
-                translate=translate, select=select, on_change=on_change,
-                on_change_with=on_change_with, depends=depends,
-                order_field=order_field, context=context)
+                states=states, priority=priority,
+                change_default=change_default, select=select,
+                on_change=on_change, on_change_with=on_change_with,
+                depends=depends, order_field=order_field, context=context)
         self.model_name = model_name
         self.left = left
         self.right = right

trytond/model/fields/one2many.py

@@ -15,11 +15,11 @@ class One2Many(Field):
     '''
     _type = 'one2many'
 
-    def __init__(self, model_name, field, string='', add_remove=None, order=None,
-            datetime_field=None, help='', required=False, readonly=False,
-            domain=None, states=None, priority=0, change_default=False,
-            translate=False, select=0, on_change=None, on_change_with=None,
-            depends=None, order_field=None, context=None):
+    def __init__(self, model_name, field, string='', add_remove=None,
+            order=None, datetime_field=None, help='', required=False,
+            readonly=False, domain=None, states=None, priority=0,
+            change_default=False, select=0, on_change=None,
+            on_change_with=None, depends=None, order_field=None, context=None):
         '''
         :param model_name: The name of the targeted model.
         :param field: The name of the field that handle the reverse many2one.
@@ -38,10 +38,10 @@ class One2Many(Field):
                 depends = [datetime_field]
         super(One2Many, self).__init__(string=string, help=help,
                 required=required, readonly=readonly, domain=domain,
-                states=states, priority=priority, change_default=change_default,
-                translate=translate, select=select, on_change=on_change,
-                on_change_with=on_change_with, depends=depends,
-                order_field=order_field, context=context)
+                states=states, priority=priority,
+                change_default=change_default, select=select,
+                on_change=on_change, on_change_with=on_change_with,
+                depends=depends, order_field=order_field, context=context)
         self.model_name = model_name
         self.field = field
         self.__add_remove = None

trytond/model/fields/reference.py

@@ -13,7 +13,7 @@ class Reference(Field):
 
     def __init__(self, string='', selection=None, help='', required=False,
             readonly=False, domain=None, states=None, priority=0,
-            change_default=False, translate=False, select=0, on_change=None,
+            change_default=False, select=0, on_change=None,
             on_change_with=None, depends=None, order_field=None, context=None):
         '''
         :param selection: A list or a function name that returns a list.
@@ -22,10 +22,10 @@ class Reference(Field):
         '''
         super(Reference, self).__init__(string=string, help=help,
                 required=required, readonly=readonly, domain=domain,
-                states=states, priority=priority, change_default=change_default,
-                translate=translate, select=select, on_change=on_change,
-                on_change_with=on_change_with, depends=depends,
-                order_field=order_field, context=context)
+                states=states, priority=priority,
+                change_default=change_default, select=select,
+                on_change=on_change, on_change_with=on_change_with,
+                depends=depends, order_field=order_field, context=context)
         self.selection = selection or None
 
     __init__.__doc__ += Field.__init__.__doc__

trytond/model/modelsql.py

@@ -551,7 +551,7 @@ class ModelSQL(ModelStorage):
         for field in fields_pre:
             if field == '_timestamp':
                 continue
-            if self._columns[field].translate:
+            if getattr(self._columns[field], 'translate', False):
                 ids = [x['id'] for x in res]
                 res_trans = translation_obj._get_ids(cursor,
                         self._name + ',' + field, 'model',
@@ -797,7 +797,7 @@ class ModelSQL(ModelStorage):
         for field in values:
             if field in self._columns:
                 if not hasattr(self._columns[field], 'set'):
-                    if (not self._columns[field].translate) \
+                    if (not getattr(self._columns[field], 'translate', False)) \
                             or (context.get('language') or 'en_US') == 'en_US':
                         upd0.append(('"' + field + '"', '%s'))
                         upd1.append(FIELDS[self._columns[field]._type]\
@@ -921,7 +921,7 @@ class ModelSQL(ModelStorage):
                 raise
 
         for field in direct:
-            if self._columns[field].translate:
+            if getattr(self._columns[field], 'translate', False):
                 self.pool.get('ir.translation')._set_ids(cursor, user,
                         self._name + ',' + field, 'model',
                         context.get('language') or 'en_US', ids,
@@ -1225,7 +1225,7 @@ class ModelSQL(ModelStorage):
                     for x in self._columns.iteritems() \
                     if not hasattr(x[1], 'get') \
                     and (x[0] != 'id')
-                    and (not x[1].translate \
+                    and (not getattr(x[1], 'translate', False) \
                         and x[1]._type not in ('text', 'binary'))]
             if not self.table_query(context):
                 select_fields += ['(COALESCE("' + self._table + '".write_date,'\
@@ -1651,7 +1651,7 @@ class ModelSQL(ModelStorage):
                         domain[i] += (table,)
                 i += 1
             else:
-                if field.translate:
+                if getattr(field, 'translate', False):
                     if self._name == 'ir.model':
                         table_join = 'LEFT JOIN "ir_translation" ' \
                                 'ON (ir_translation.name = ' \
@@ -1695,16 +1695,20 @@ class ModelSQL(ModelStorage):
                         table_query, table_args = table.table_query(context)
                         table_query = '(' + table_query  + ') AS '
 
-                    trans_field = 'COALESCE(NULLIF(' \
-                            'ir_translation.value, \'\'), ' \
-                            + '"' + table._table + '".' + domain[i][0] + ')'
+                    translation_obj = self.pool.get('ir.translation')
 
+                    qu1, qu2, tables, table_args = translation_obj.search_domain(
+                            cursor, user, [
+                                ('value', domain[i][1], domain[i][2]),
+                                ], context=context)
+                    qu1 = qu1.replace('"ir_translation"."value"',
+                            'COALESCE(NULLIF("ir_translation"."value", \'\'), '
+                            '"%s"."%s")' % (table._table, domain[i][0]))
                     query1 = 'SELECT "' + table._table + '".id ' \
                             'FROM ' + table_query + '"' + table._table + '" ' \
-                            + table_join + ' ' \
-                            'WHERE ' \
-                            '(' + trans_field + ' ' + domain[i][1] + ' %s)'
-                    query2 = table_args + table_join_args + [domain[i][2]]
+                            + table_join + ' WHERE ' + qu1
+                    query2 = table_args + table_join_args + qu2
+
                     domain[i] = ('id', 'inselect', (query1, query2), table)
                 else:
                     domain[i] += (table,)
@@ -1836,7 +1840,7 @@ class ModelSQL(ModelStorage):
                             arg[0], arg[1]))
                         if add_null:
                             qu1[-1] = '(' + qu1[-1] + ' OR ' \
-                                    '"' + table._table + '".' + arg[0] + \
+                                    '"' + table._table + '"."' + arg[0] + '"' \
                                         ' IS NULL)'
 
         return qu1, qu2
@@ -1951,7 +1955,7 @@ class ModelSQL(ModelStorage):
                     return order_by, tables, tables_args
 
             if field_name in self._columns \
-                    and self._columns[field_name].translate:
+                    and getattr(self._columns[field_name], 'translate', False):
                 translation_table = 'ir_translation_%s_%s' % \
                         (table_name, field_name)
                 if self._name == 'ir.model':

trytond/model/modelstorage.py

@@ -273,7 +273,7 @@ class ModelStorage(Model):
         fields_translate = {}
         for field_name, field in field_defs.iteritems():
             if field_name in self._columns and \
-                    self._columns[field_name].translate:
+                    getattr(self._columns[field_name], 'translate', False):
                 fields_translate[field_name] = field
 
         if fields_translate:

trytond/test/test.py

@@ -194,6 +194,16 @@ class CharSize(ModelSQL):
 CharSize()
 
 
+class CharTranslate(ModelSQL):
+    'Char Translate'
+    _name = 'test.char_translate'
+    _description = __doc__
+    char = fields.Char(string='Char', size=None, help='Test char',
+            required=False, translate=True)
+
+CharTranslate()
+
+
 class Text(ModelSQL):
     'Text'
     _name = 'test.text'
@@ -237,6 +247,16 @@ class TextSize(ModelSQL):
 TextSize()
 
 
+class TextTranslate(ModelSQL):
+    'Text Translate'
+    _name = 'test.text_translate'
+    _description = __doc__
+    text = fields.Text(string='Text', size=None, help='Test text',
+            required=False, translate=True)
+
+TextTranslate()
+
+
 class Sha(ModelSQL):
     'Sha'
     _name = 'test.sha'

trytond/tests/test_fields.py

@@ -37,11 +37,13 @@ class FieldsTestCase(unittest.TestCase):
         self.char_default = POOL.get('test.char_default')
         self.char_required = POOL.get('test.char_required')
         self.char_size = POOL.get('test.char_size')
+        self.char_translate = POOL.get('test.char_translate')
 
         self.text = POOL.get('test.text')
         self.text_default = POOL.get('test.text_default')
         self.text_required = POOL.get('test.text_required')
         self.text_size = POOL.get('test.text_size')
+        self.text_translate = POOL.get('test.text_translate')
 
         self.sha = POOL.get('test.sha')
         self.sha_default = POOL.get('test.sha_default')
@@ -804,186 +806,187 @@ class FieldsTestCase(unittest.TestCase):
         '''
         cursor = DB.cursor()
 
-        char1_id = self.char.create(cursor, USER, {
-            'char': 'Test',
-            }, CONTEXT)
-        self.assert_(char1_id)
+        for char in (self.char, self.char_translate):
+            char1_id = char.create(cursor, USER, {
+                'char': 'Test',
+                }, CONTEXT)
+            self.assert_(char1_id)
 
-        char1 = self.char.read(cursor, USER, char1_id, ['char'], CONTEXT)
-        self.assert_(char1['char'] == 'Test')
+            char1 = char.read(cursor, USER, char1_id, ['char'], CONTEXT)
+            self.assert_(char1['char'] == 'Test')
 
-        char_ids = self.char.search(cursor, USER, [
-            ('char', '=', 'Test'),
-            ], 0, None, None, CONTEXT)
-        self.assert_(char_ids == [char1_id])
+            char_ids = char.search(cursor, USER, [
+                ('char', '=', 'Test'),
+                ], 0, None, None, CONTEXT)
+            self.assert_(char_ids == [char1_id])
 
-        char_ids = self.char.search(cursor, USER, [
-            ('char', '=', 'Foo'),
-            ], 0, None, None, CONTEXT)
-        self.assert_(char_ids == [])
+            char_ids = char.search(cursor, USER, [
+                ('char', '=', 'Foo'),
+                ], 0, None, None, CONTEXT)
+            self.assert_(char_ids == [])
 
-        char_ids = self.char.search(cursor, USER, [
-            ('char', '=', False),
-            ], 0, None, None, CONTEXT)
-        self.assert_(char_ids == [])
+            char_ids = char.search(cursor, USER, [
+                ('char', '=', False),
+                ], 0, None, None, CONTEXT)
+            self.assert_(char_ids == [])
 
-        char_ids = self.char.search(cursor, USER, [
-            ('char', '!=', 'Test'),
-            ], 0, None, None, CONTEXT)
-        self.assert_(char_ids == [])
+            char_ids = char.search(cursor, USER, [
+                ('char', '!=', 'Test'),
+                ], 0, None, None, CONTEXT)
+            self.assert_(char_ids == [])
 
-        char_ids = self.char.search(cursor, USER, [
-            ('char', '!=', 'Foo'),
-            ], 0, None, None, CONTEXT)
-        self.assert_(char_ids == [char1_id])
+            char_ids = char.search(cursor, USER, [
+                ('char', '!=', 'Foo'),
+                ], 0, None, None, CONTEXT)
+            self.assert_(char_ids == [char1_id])
 
-        char_ids = self.char.search(cursor, USER, [
-            ('char', '!=', False),
-            ], 0, None, None, CONTEXT)
-        self.assert_(char_ids == [char1_id])
+            char_ids = char.search(cursor, USER, [
+                ('char', '!=', False),
+                ], 0, None, None, CONTEXT)
+            self.assert_(char_ids == [char1_id])
 
-        char_ids = self.char.search(cursor, USER, [
-            ('char', 'in', ['Test']),
-            ], 0, None, None, CONTEXT)
-        self.assert_(char_ids == [char1_id])
+            char_ids = char.search(cursor, USER, [
+                ('char', 'in', ['Test']),
+                ], 0, None, None, CONTEXT)
+            self.assert_(char_ids == [char1_id])
 
-        char_ids = self.char.search(cursor, USER, [
-            ('char', 'in', ['Foo']),
-            ], 0, None, None, CONTEXT)
-        self.assert_(char_ids == [])
+            char_ids = char.search(cursor, USER, [
+                ('char', 'in', ['Foo']),
+                ], 0, None, None, CONTEXT)
+            self.assert_(char_ids == [])
 
-        char_ids = self.char.search(cursor, USER, [
-            ('char', 'in', [False]),
-            ], 0, None, None, CONTEXT)
-        self.assert_(char_ids == [])
+            char_ids = char.search(cursor, USER, [
+                ('char', 'in', [False]),
+                ], 0, None, None, CONTEXT)
+            self.assert_(char_ids == [])
 
-        char_ids = self.char.search(cursor, USER, [
-            ('char', 'in', []),
-            ], 0, None, None, CONTEXT)
-        self.assert_(char_ids == [])
+            char_ids = char.search(cursor, USER, [
+                ('char', 'in', []),
+                ], 0, None, None, CONTEXT)
+            self.assert_(char_ids == [])
 
-        char_ids = self.char.search(cursor, USER, [
-            ('char', 'not in', ['Test']),
-            ], 0, None, None, CONTEXT)
-        self.assert_(char_ids == [])
+            char_ids = char.search(cursor, USER, [
+                ('char', 'not in', ['Test']),
+                ], 0, None, None, CONTEXT)
+            self.assert_(char_ids == [])
 
-        char_ids = self.char.search(cursor, USER, [
-            ('char', 'not in', ['Foo']),
-            ], 0, None, None, CONTEXT)
-        self.assert_(char_ids == [char1_id])
+            char_ids = char.search(cursor, USER, [
+                ('char', 'not in', ['Foo']),
+                ], 0, None, None, CONTEXT)
+            self.assert_(char_ids == [char1_id])
 
-        char_ids = self.char.search(cursor, USER, [
-            ('char', 'not in', [False]),
-            ], 0, None, None, CONTEXT)
-        self.assert_(char_ids == [char1_id])
+            char_ids = char.search(cursor, USER, [
+                ('char', 'not in', [False]),
+                ], 0, None, None, CONTEXT)
+            self.assert_(char_ids == [char1_id])
 
-        char_ids = self.char.search(cursor, USER, [
-            ('char', 'not in', []),
-            ], 0, None, None, CONTEXT)
-        self.assert_(char_ids == [char1_id])
+            char_ids = char.search(cursor, USER, [
+                ('char', 'not in', []),
+                ], 0, None, None, CONTEXT)
+            self.assert_(char_ids == [char1_id])
 
-        char_ids = self.char.search(cursor, USER, [
-            ('char', 'like', 'Test'),
-            ], 0, None, None, CONTEXT)
-        self.assert_(char_ids == [char1_id])
+            char_ids = char.search(cursor, USER, [
+                ('char', 'like', 'Test'),
+                ], 0, None, None, CONTEXT)
+            self.assert_(char_ids == [char1_id])
 
-        char_ids = self.char.search(cursor, USER, [
-            ('char', 'like', 'T%'),
-            ], 0, None, None, CONTEXT)
-        self.assert_(char_ids == [char1_id])
+            char_ids = char.search(cursor, USER, [
+                ('char', 'like', 'T%'),
+                ], 0, None, None, CONTEXT)
+            self.assert_(char_ids == [char1_id])
 
-        char_ids = self.char.search(cursor, USER, [
-            ('char', 'like', 'Foo'),
-            ], 0, None, None, CONTEXT)
-        self.assert_(char_ids == [])
+            char_ids = char.search(cursor, USER, [
+                ('char', 'like', 'Foo'),
+                ], 0, None, None, CONTEXT)
+            self.assert_(char_ids == [])
 
-        char_ids = self.char.search(cursor, USER, [
-            ('char', 'like', 'F%'),
-            ], 0, None, None, CONTEXT)
-        self.assert_(char_ids == [])
+            char_ids = char.search(cursor, USER, [
+                ('char', 'like', 'F%'),
+                ], 0, None, None, CONTEXT)
+            self.assert_(char_ids == [])
 
-        char_ids = self.char.search(cursor, USER, [
-            ('char', 'ilike', 'test'),
-            ], 0, None, None, CONTEXT)
-        self.assert_(char_ids == [char1_id])
+            char_ids = char.search(cursor, USER, [
+                ('char', 'ilike', 'test'),
+                ], 0, None, None, CONTEXT)
+            self.assert_(char_ids == [char1_id])
 
-        char_ids = self.char.search(cursor, USER, [
-            ('char', 'ilike', 't%'),
-            ], 0, None, None, CONTEXT)
-        self.assert_(char_ids == [char1_id])
+            char_ids = char.search(cursor, USER, [
+                ('char', 'ilike', 't%'),
+                ], 0, None, None, CONTEXT)
+            self.assert_(char_ids == [char1_id])
 
-        char_ids = self.char.search(cursor, USER, [
-            ('char', 'ilike', 'foo'),
-            ], 0, None, None, CONTEXT)
-        self.assert_(char_ids == [])
+            char_ids = char.search(cursor, USER, [
+                ('char', 'ilike', 'foo'),
+                ], 0, None, None, CONTEXT)
+            self.assert_(char_ids == [])
 
-        char_ids = self.char.search(cursor, USER, [
-            ('char', 'ilike', 'f%'),
-            ], 0, None, None, CONTEXT)
-        self.assert_(char_ids == [])
+            char_ids = char.search(cursor, USER, [
+                ('char', 'ilike', 'f%'),
+                ], 0, None, None, CONTEXT)
+            self.assert_(char_ids == [])
 
-        char_ids = self.char.search(cursor, USER, [
-            ('char', 'not like', 'Test'),
-            ], 0, None, None, CONTEXT)
-        self.assert_(char_ids == [])
+            char_ids = char.search(cursor, USER, [
+                ('char', 'not like', 'Test'),
+                ], 0, None, None, CONTEXT)
+            self.assert_(char_ids == [])
 
-        char_ids = self.char.search(cursor, USER, [
-            ('char', 'not like', 'T%'),
-            ], 0, None, None, CONTEXT)
-        self.assert_(char_ids == [])
+            char_ids = char.search(cursor, USER, [
+                ('char', 'not like', 'T%'),
+                ], 0, None, None, CONTEXT)
+            self.assert_(char_ids == [])
 
-        char_ids = self.char.search(cursor, USER, [
-            ('char', 'not like', 'Foo'),
-            ], 0, None, None, CONTEXT)
-        self.assert_(char_ids == [char1_id])
+            char_ids = char.search(cursor, USER, [
+                ('char', 'not like', 'Foo'),
+                ], 0, None, None, CONTEXT)
+            self.assert_(char_ids == [char1_id])
 
-        char_ids = self.char.search(cursor, USER, [
-            ('char', 'not like', 'F%'),
-            ], 0, None, None, CONTEXT)
-        self.assert_(char_ids == [char1_id])
+            char_ids = char.search(cursor, USER, [
+                ('char', 'not like', 'F%'),
+                ], 0, None, None, CONTEXT)
+            self.assert_(char_ids == [char1_id])
 
-        char_ids = self.char.search(cursor, USER, [
-            ('char', 'not ilike', 'test'),
-            ], 0, None, None, CONTEXT)
-        self.assert_(char_ids == [])
+            char_ids = char.search(cursor, USER, [
+                ('char', 'not ilike', 'test'),
+                ], 0, None, None, CONTEXT)
+            self.assert_(char_ids == [])
 
-        char_ids = self.char.search(cursor, USER, [
-            ('char', 'not ilike', 't%'),
-            ], 0, None, None, CONTEXT)
-        self.assert_(char_ids == [])
+            char_ids = char.search(cursor, USER, [
+                ('char', 'not ilike', 't%'),
+                ], 0, None, None, CONTEXT)
+            self.assert_(char_ids == [])
 
-        char_ids = self.char.search(cursor, USER, [
-            ('char', 'not ilike', 'foo'),
-            ], 0, None, None, CONTEXT)
-        self.assert_(char_ids == [char1_id])
+            char_ids = char.search(cursor, USER, [
+                ('char', 'not ilike', 'foo'),
+                ], 0, None, None, CONTEXT)
+            self.assert_(char_ids == [char1_id])
 
-        char_ids = self.char.search(cursor, USER, [
-            ('char', 'not ilike', 'f%'),
-            ], 0, None, None, CONTEXT)
-        self.assert_(char_ids == [char1_id])
+            char_ids = char.search(cursor, USER, [
+                ('char', 'not ilike', 'f%'),
+                ], 0, None, None, CONTEXT)
+            self.assert_(char_ids == [char1_id])
 
-        char2_id = self.char.create(cursor, USER, {
-            'char': False,
-            }, CONTEXT)
-        self.assert_(char2_id)
+            char2_id = char.create(cursor, USER, {
+                'char': False,
+                }, CONTEXT)
+            self.assert_(char2_id)
 
-        char2 = self.char.read(cursor, USER, char2_id, ['char'], CONTEXT)
-        self.assert_(char2['char'] == None)
+            char2 = char.read(cursor, USER, char2_id, ['char'], CONTEXT)
+            self.assert_(char2['char'] == None)
 
-        char_ids = self.char.search(cursor, USER, [
-            ('char', '=', False),
-            ], 0, None, None, CONTEXT)
-        self.assert_(char_ids == [char2_id])
+            char_ids = char.search(cursor, USER, [
+                ('char', '=', False),
+                ], 0, None, None, CONTEXT)
+            self.assert_(char_ids == [char2_id])
 
-        char_ids = self.char.search(cursor, USER, [
-            ('char', 'in', [False, 'Test']),
-            ], 0, None, None, CONTEXT)
-        self.assert_(char_ids == [char1_id, char2_id])
+            char_ids = char.search(cursor, USER, [
+                ('char', 'in', [False, 'Test']),
+                ], 0, None, None, CONTEXT)
+            self.assert_(char_ids == [char1_id, char2_id])
 
-        char_ids = self.char.search(cursor, USER, [
-            ('char', 'not in', [False, 'Test']),
-            ], 0, None, None, CONTEXT)
-        self.assert_(char_ids == [])
+            char_ids = char.search(cursor, USER, [
+                ('char', 'not in', [False, 'Test']),
+                ], 0, None, None, CONTEXT)
+            self.assert_(char_ids == [])
 
         char3_id = self.char.create(cursor, USER, {}, CONTEXT)
         self.assert_(char3_id)
@@ -1067,186 +1070,187 @@ class FieldsTestCase(unittest.TestCase):
         '''
         cursor = DB.cursor()
 
-        text1_id = self.text.create(cursor, USER, {
-            'text': 'Test',
-            }, CONTEXT)
-        self.assert_(text1_id)
+        for text in (self.text, self.text_translate):
+            text1_id = text.create(cursor, USER, {
+                'text': 'Test',
+                }, CONTEXT)
+            self.assert_(text1_id)
 
-        text1 = self.text.read(cursor, USER, text1_id, ['text'], CONTEXT)
-        self.assert_(text1['text'] == 'Test')
+            text1 = text.read(cursor, USER, text1_id, ['text'], CONTEXT)
+            self.assert_(text1['text'] == 'Test')
 
-        text_ids = self.text.search(cursor, USER, [
-            ('text', '=', 'Test'),
-            ], 0, None, None, CONTEXT)
-        self.assert_(text_ids == [text1_id])
+            text_ids = text.search(cursor, USER, [
+                ('text', '=', 'Test'),
+                ], 0, None, None, CONTEXT)
+            self.assert_(text_ids == [text1_id])
 
-        text_ids = self.text.search(cursor, USER, [
-            ('text', '=', 'Foo'),
-            ], 0, None, None, CONTEXT)
-        self.assert_(text_ids == [])
+            text_ids = text.search(cursor, USER, [
+                ('text', '=', 'Foo'),
+                ], 0, None, None, CONTEXT)
+            self.assert_(text_ids == [])
 
-        text_ids = self.text.search(cursor, USER, [
-            ('text', '=', False),
-            ], 0, None, None, CONTEXT)
-        self.assert_(text_ids == [])
+            text_ids = text.search(cursor, USER, [
+                ('text', '=', False),
+                ], 0, None, None, CONTEXT)
+            self.assert_(text_ids == [])
 
-        text_ids = self.text.search(cursor, USER, [
-            ('text', '!=', 'Test'),
-            ], 0, None, None, CONTEXT)
-        self.assert_(text_ids == [])
+            text_ids = text.search(cursor, USER, [
+                ('text', '!=', 'Test'),
+                ], 0, None, None, CONTEXT)
+            self.assert_(text_ids == [])
 
-        text_ids = self.text.search(cursor, USER, [
-            ('text', '!=', 'Foo'),
-            ], 0, None, None, CONTEXT)
-        self.assert_(text_ids == [text1_id])
+            text_ids = text.search(cursor, USER, [
+                ('text', '!=', 'Foo'),
+                ], 0, None, None, CONTEXT)
+            self.assert_(text_ids == [text1_id])
 
-        text_ids = self.text.search(cursor, USER, [
-            ('text', '!=', False),
-            ], 0, None, None, CONTEXT)
-        self.assert_(text_ids == [text1_id])
+            text_ids = text.search(cursor, USER, [
+                ('text', '!=', False),
+                ], 0, None, None, CONTEXT)
+            self.assert_(text_ids == [text1_id])
 
-        text_ids = self.text.search(cursor, USER, [
-            ('text', 'in', ['Test']),
-            ], 0, None, None, CONTEXT)
-        self.assert_(text_ids == [text1_id])
+            text_ids = text.search(cursor, USER, [
+                ('text', 'in', ['Test']),
+                ], 0, None, None, CONTEXT)
+            self.assert_(text_ids == [text1_id])
 
-        text_ids = self.text.search(cursor, USER, [
-            ('text', 'in', ['Foo']),
-            ], 0, None, None, CONTEXT)
-        self.assert_(text_ids == [])
+            text_ids = text.search(cursor, USER, [
+                ('text', 'in', ['Foo']),
+                ], 0, None, None, CONTEXT)
+            self.assert_(text_ids == [])
 
-        text_ids = self.text.search(cursor, USER, [
-            ('text', 'in', [False]),
-            ], 0, None, None, CONTEXT)
-        self.assert_(text_ids == [])
+            text_ids = text.search(cursor, USER, [
+                ('text', 'in', [False]),
+                ], 0, None, None, CONTEXT)
+            self.assert_(text_ids == [])
 
-        text_ids = self.text.search(cursor, USER, [
-            ('text', 'in', []),
-            ], 0, None, None, CONTEXT)
-        self.assert_(text_ids == [])
+            text_ids = text.search(cursor, USER, [
+                ('text', 'in', []),
+                ], 0, None, None, CONTEXT)
+            self.assert_(text_ids == [])
 
-        text_ids = self.text.search(cursor, USER, [
-            ('text', 'not in', ['Test']),
-            ], 0, None, None, CONTEXT)
-        self.assert_(text_ids == [])
+            text_ids = text.search(cursor, USER, [
+                ('text', 'not in', ['Test']),
+                ], 0, None, None, CONTEXT)
+            self.assert_(text_ids == [])
 
-        text_ids = self.text.search(cursor, USER, [
-            ('text', 'not in', ['Foo']),
-            ], 0, None, None, CONTEXT)
-        self.assert_(text_ids == [text1_id])
+            text_ids = text.search(cursor, USER, [
+                ('text', 'not in', ['Foo']),
+                ], 0, None, None, CONTEXT)
+            self.assert_(text_ids == [text1_id])
 
-        text_ids = self.text.search(cursor, USER, [
-            ('text', 'not in', [False]),
-            ], 0, None, None, CONTEXT)
-        self.assert_(text_ids == [text1_id])
+            text_ids = text.search(cursor, USER, [
+                ('text', 'not in', [False]),
+                ], 0, None, None, CONTEXT)
+            self.assert_(text_ids == [text1_id])
 
-        text_ids = self.text.search(cursor, USER, [
-            ('text', 'not in', []),
-            ], 0, None, None, CONTEXT)
-        self.assert_(text_ids == [text1_id])
+            text_ids = text.search(cursor, USER, [
+                ('text', 'not in', []),
+                ], 0, None, None, CONTEXT)
+            self.assert_(text_ids == [text1_id])
 
-        text_ids = self.text.search(cursor, USER, [
-            ('text', 'like', 'Test'),
-            ], 0, None, None, CONTEXT)
-        self.assert_(text_ids == [text1_id])
+            text_ids = text.search(cursor, USER, [
+                ('text', 'like', 'Test'),
+                ], 0, None, None, CONTEXT)
+            self.assert_(text_ids == [text1_id])
 
-        text_ids = self.text.search(cursor, USER, [
-            ('text', 'like', 'T%'),
-            ], 0, None, None, CONTEXT)
-        self.assert_(text_ids == [text1_id])
+            text_ids = text.search(cursor, USER, [
+                ('text', 'like', 'T%'),
+                ], 0, None, None, CONTEXT)
+            self.assert_(text_ids == [text1_id])
 
-        text_ids = self.text.search(cursor, USER, [
-            ('text', 'like', 'Foo'),
-            ], 0, None, None, CONTEXT)
-        self.assert_(text_ids == [])
+            text_ids = text.search(cursor, USER, [
+                ('text', 'like', 'Foo'),
+                ], 0, None, None, CONTEXT)
+            self.assert_(text_ids == [])
 
-        text_ids = self.text.search(cursor, USER, [
-            ('text', 'like', 'F%'),
-            ], 0, None, None, CONTEXT)
-        self.assert_(text_ids == [])
+            text_ids = text.search(cursor, USER, [
+                ('text', 'like', 'F%'),
+                ], 0, None, None, CONTEXT)
+            self.assert_(text_ids == [])
 
-        text_ids = self.text.search(cursor, USER, [
-            ('text', 'ilike', 'test'),
-            ], 0, None, None, CONTEXT)
-        self.assert_(text_ids == [text1_id])
+            text_ids = text.search(cursor, USER, [
+                ('text', 'ilike', 'test'),
+                ], 0, None, None, CONTEXT)
+            self.assert_(text_ids == [text1_id])
 
-        text_ids = self.text.search(cursor, USER, [
-            ('text', 'ilike', 't%'),
-            ], 0, None, None, CONTEXT)
-        self.assert_(text_ids == [text1_id])
+            text_ids = text.search(cursor, USER, [
+                ('text', 'ilike', 't%'),
+                ], 0, None, None, CONTEXT)
+            self.assert_(text_ids == [text1_id])
 
-        text_ids = self.text.search(cursor, USER, [
-            ('text', 'ilike', 'foo'),
-            ], 0, None, None, CONTEXT)
-        self.assert_(text_ids == [])
+            text_ids = text.search(cursor, USER, [
+                ('text', 'ilike', 'foo'),
+                ], 0, None, None, CONTEXT)
+            self.assert_(text_ids == [])
 
-        text_ids = self.text.search(cursor, USER, [
-            ('text', 'ilike', 'f%'),
-            ], 0, None, None, CONTEXT)
-        self.assert_(text_ids == [])
+            text_ids = text.search(cursor, USER, [
+                ('text', 'ilike', 'f%'),
+                ], 0, None, None, CONTEXT)
+            self.assert_(text_ids == [])
 
-        text_ids = self.text.search(cursor, USER, [
-            ('text', 'not like', 'Test'),
-            ], 0, None, None, CONTEXT)
-        self.assert_(text_ids == [])
+            text_ids = text.search(cursor, USER, [
+                ('text', 'not like', 'Test'),
+                ], 0, None, None, CONTEXT)
+            self.assert_(text_ids == [])
 
-        text_ids = self.text.search(cursor, USER, [
-            ('text', 'not like', 'T%'),
-            ], 0, None, None, CONTEXT)
-        self.assert_(text_ids == [])
+            text_ids = text.search(cursor, USER, [
+                ('text', 'not like', 'T%'),
+                ], 0, None, None, CONTEXT)
+            self.assert_(text_ids == [])
 
-        text_ids = self.text.search(cursor, USER, [
-            ('text', 'not like', 'Foo'),
-            ], 0, None, None, CONTEXT)
-        self.assert_(text_ids == [text1_id])
+            text_ids = text.search(cursor, USER, [
+                ('text', 'not like', 'Foo'),
+                ], 0, None, None, CONTEXT)
+            self.assert_(text_ids == [text1_id])
 
-        text_ids = self.text.search(cursor, USER, [
-            ('text', 'not like', 'F%'),
-            ], 0, None, None, CONTEXT)
-        self.assert_(text_ids == [text1_id])
+            text_ids = text.search(cursor, USER, [
+                ('text', 'not like', 'F%'),
+                ], 0, None, None, CONTEXT)
+            self.assert_(text_ids == [text1_id])
 
-        text_ids = self.text.search(cursor, USER, [
-            ('text', 'not ilike', 'test'),
-            ], 0, None, None, CONTEXT)
-        self.assert_(text_ids == [])
+            text_ids = text.search(cursor, USER, [
+                ('text', 'not ilike', 'test'),
+                ], 0, None, None, CONTEXT)
+            self.assert_(text_ids == [])
 
-        text_ids = self.text.search(cursor, USER, [
-            ('text', 'not ilike', 't%'),
-            ], 0, None, None, CONTEXT)
-        self.assert_(text_ids == [])
+            text_ids = text.search(cursor, USER, [
+                ('text', 'not ilike', 't%'),
+                ], 0, None, None, CONTEXT)
+            self.assert_(text_ids == [])
 
-        text_ids = self.text.search(cursor, USER, [
-            ('text', 'not ilike', 'foo'),
-            ], 0, None, None, CONTEXT)
-        self.assert_(text_ids == [text1_id])
+            text_ids = text.search(cursor, USER, [
+                ('text', 'not ilike', 'foo'),
+                ], 0, None, None, CONTEXT)
+            self.assert_(text_ids == [text1_id])
 
-        text_ids = self.text.search(cursor, USER, [
-            ('text', 'not ilike', 'f%'),
-            ], 0, None, None, CONTEXT)
-        self.assert_(text_ids == [text1_id])
+            text_ids = text.search(cursor, USER, [
+                ('text', 'not ilike', 'f%'),
+                ], 0, None, None, CONTEXT)
+            self.assert_(text_ids == [text1_id])
 
-        text2_id = self.text.create(cursor, USER, {
-            'text': False,
-            }, CONTEXT)
-        self.assert_(text2_id)
+            text2_id = text.create(cursor, USER, {
+                'text': False,
+                }, CONTEXT)
+            self.assert_(text2_id)
 
-        text2 = self.text.read(cursor, USER, text2_id, ['text'], CONTEXT)
-        self.assert_(text2['text'] == None)
+            text2 = text.read(cursor, USER, text2_id, ['text'], CONTEXT)
+            self.assert_(text2['text'] == None)
 
-        text_ids = self.text.search(cursor, USER, [
-            ('text', '=', False),
-            ], 0, None, None, CONTEXT)
-        self.assert_(text_ids == [text2_id])
+            text_ids = text.search(cursor, USER, [
+                ('text', '=', False),
+                ], 0, None, None, CONTEXT)
+            self.assert_(text_ids == [text2_id])
 
-        text_ids = self.text.search(cursor, USER, [
-            ('text', 'in', [False, 'Test']),
-            ], 0, None, None, CONTEXT)
-        self.assert_(text_ids == [text1_id, text2_id])
+            text_ids = text.search(cursor, USER, [
+                ('text', 'in', [False, 'Test']),
+                ], 0, None, None, CONTEXT)
+            self.assert_(text_ids == [text1_id, text2_id])
 
-        text_ids = self.text.search(cursor, USER, [
-            ('text', 'not in', [False, 'Test']),
-            ], 0, None, None, CONTEXT)
-        self.assert_(text_ids == [])
+            text_ids = text.search(cursor, USER, [
+                ('text', 'not in', [False, 'Test']),
+                ], 0, None, None, CONTEXT)
+            self.assert_(text_ids == [])
 
         text3_id = self.text.create(cursor, USER, {}, CONTEXT)
         self.assert_(text3_id)

trytond/tools/convert.py

@@ -633,7 +633,8 @@ class TrytondXmlHandler(sax.handler.ContentHandler):
                         table_name = self.pool.get(
                                 object_ref._inherit_fields[field_name][0])._name
                         res_id = inherit_db_ids[table_name]
-                    if field.translate and values.get(field_name):
+                    if getattr(field, 'translate', False) and \
+                            values.get(field_name):
                         cursor.execute('SELECT id FROM ir_translation ' \
                                 'WHERE name = %s ' \
                                     'AND lang = %s ' \
@@ -776,7 +777,7 @@ class TrytondXmlHandler(sax.handler.ContentHandler):
                         table_name = self.pool.get(
                                 object_ref._inherit_fields[field_name][0])._name
                         res_id = inherit_db_ids[table_name]
-                    if field.translate:
+                    if getattr(field, 'translate', False):
                         cursor.execute('SELECT id FROM ir_translation ' \
                                 'WHERE name = %s ' \
                                     'AND lang = %s ' \
@@ -865,7 +866,8 @@ class TrytondXmlHandler(sax.handler.ContentHandler):
                     table_name = self.pool.get(
                             object_ref._inherit_fields[field_name][0])._name
                     res_id = inherit_db_ids[table_name]
-                if field.translate and values.get(field_name):
+                if getattr(field, 'translate', False) and \
+                        values.get(field_name):
                     cursor.execute('SELECT id FROM ir_translation ' \
                             'WHERE name = %s' \
                                 'AND lang = %s ' \