Merge lp:~therp-nl/openobject-server/[e-mail]_trunk_lp645980 into lp:openobject-server

[Ronald Portier (Therp)]

This merge request contains the minimal changes to just correct the ordering of rows ordered on a translated field.

Did not (as yet) change/correct the selection, nor streamlined the reading of translated fields, just to keep this merge request as compact as possible.

Unmerged revisions

4509. By Ronald Portier (Therp) on 2012-10-30

[FIX] Rows ordered by translated fields are shown in the correct order.

=== modified file 'openerp/addons/base/ir/ir_translation.py'
--- openerp/addons/base/ir/ir_translation.py	2012-10-22 13:27:59 +0000
+++ openerp/addons/base/ir/ir_translation.py	2012-10-30 13:29:28 +0000
@@ -18,6 +18,7 @@
 #    along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 ##############################################################################
+import re
 
 import tools
 import logging
@@ -147,6 +148,11 @@
 class ir_translation(osv.osv):
     _name = "ir.translation"
     _log_access = False
+    
+    _clause_pattern = re.compile(
+        r'\b(order by|select)?\b(.*$)', re.IGNORECASE)
+    _field_pattern = re.compile(
+        r'\b([\"|\w]+\.)?([\"|\w]+)\W*\b(asc|desc)?', re.IGNORECASE)
 
     def _get_language(self, cr, uid, context):
         lang_model = self.pool.get('res.lang')
@@ -411,6 +417,101 @@
                 elif lang_code != 'en_US':
                     _logger.warning('module %s: no translation for language %s', module_name, lang_code)
         return True
+    
+    def check_translation_existing(self, cr, user, modelname, field, language):
+        '''Check wether any translation for field existing'''
+        statement = '''select count(*) from ir_translation
+           where lang = '%(language)s'
+             and type = 'model'
+             and name = '%(modelname)s,%(field)s'
+        ''' % {
+               'language': language,
+               'modelname': modelname,
+               'field': field}
+        cr.execute(statement)
+        res = cr.fetchall()
+        itr_count = res[0][0]
+        if  itr_count:
+            return True
+        return False
+
+    def _compose_translation_join(
+            self, cr, user, modelname, tablename, field, context=None):
+        if  not context:
+            context = {}
+        replace_dict = {}
+        replace_dict['contextlang'] = context.get('lang', 'en_US')
+        replace_dict['tablename'] = tablename
+        replace_dict['field'] = field
+        replace_dict['modelname'] = modelname
+        # use q_ for quoted stuff
+        replace_dict['q_tablename'] = '"%(tablename)s"' % replace_dict
+        replace_dict['q_joinname'] = '"itr_%(field)s"' % replace_dict
+        # split followed by join removes unneeded whitespace
+        new_join = (' '.join((
+            '''LEFT OUTER JOIN ir_translation as %(q_joinname)s
+            ON  (%(q_joinname)s.res_id = %(q_tablename)s.id 
+            AND  %(q_joinname)s.name = '%(modelname)s,%(field)s'
+            AND  %(q_joinname)s.lang = '%(contextlang)s'
+            AND  %(q_joinname)s.type = 'model')''' % replace_dict).split()))
+        new_field = (
+            'coalesce(%(q_joinname)s.value, %(q_tablename)s.%(field)s)' %
+            replace_dict)
+        return (new_join, new_field)
+        
+    def _apply_translation_2fields(
+            self, cr, user, modelname, tablename, sql_clause, context=None):
+        '''Scan all fields in sql order_by or select clause for translatable
+         fields. If found, determine joins needed to translate them, and 
+         replace the fields in the clause by their translated equivalents.'''
+        assert modelname and tablename  # must be filled
+        translation_joins = []
+        if  (not context) or (not sql_clause):
+            # no context, means no translation, so nothing to do
+            return (translation_joins, sql_clause)
+        # check for default language, which does not need translation
+        contextlang = context.get('lang', 'en_US')
+        if  contextlang == 'en_US':
+            return (translation_joins, sql_clause)
+        # Work to do. Start by splitting fieldlist from optional keyword
+        clause_parts = self._clause_pattern.search(sql_clause).groups()
+        clause_keyword = clause_parts[0] or ''
+        field_list = clause_parts[1].strip() or ''
+        if  not field_list:
+            # We only had a keyword, so nothing to translate
+            return (translation_joins, sql_clause)
+        # Now set up field array to loop over
+        fields = field_list.split(',')
+        sql_clause_parts = []
+        for field in fields:
+            # default just replace existing field
+            replacing_field = field
+            # get rid of field qualifier and asc en desc field.trans
+            field_parts = self._field_pattern.search(field).groups()
+            if  field_parts:
+                field_pre = field_parts[0] or ''
+                field_bare = field_parts[1] or ''
+                field_post = field_parts[2] or ''
+                if  field_bare:
+                    # check wether translatable
+                    if  self.check_translation_existing(
+                        cr, user, modelname, field_bare, contextlang):
+                        # join to translation table
+                        # and replace field by translated version
+                        new_join, new_field = (
+                            self._compose_translation_join(
+                                cr, user, modelname, tablename,
+                                field_bare, context))
+                        translation_joins.append(new_join)
+                        field_bare = new_field
+                        replacing_field = (
+                                field_pre + new_field + ' ' + field_post)
+            sql_clause_parts.append(replacing_field)
+        if  translation_joins:
+            # We have one or more translations, recompose sql_clause clause
+            sql_clause = clause_keyword + ' ' + ','.join(sql_clause_parts)
+        # return extra joins needed for translation, and modified clause
+        return (translation_joins, sql_clause)
 
 
 # vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4:

=== modified file 'openerp/osv/orm.py'
--- openerp/osv/orm.py	2012-10-29 18:07:42 +0000
+++ openerp/osv/orm.py	2012-10-30 13:29:28 +0000
@@ -4752,7 +4752,7 @@
                 order_by_clause = ",".join(order_by_elements)
 
         return order_by_clause and (' ORDER BY %s ' % order_by_clause) or ''
-
+    
     def _search(self, cr, user, args, offset=0, limit=None, order=None, context=None, count=False, access_rights_uid=None):
         """
         Private implementation of search() method, allowing specifying the uid to use for the access right check.
@@ -4784,6 +4784,13 @@
             cr.execute('SELECT count("%s".id) FROM ' % self._table + from_clause + where_str + limit_str + offset_str, where_clause_params)
             res = cr.fetchall()
             return res[0][0]
+        itr_obj = self.pool.get('ir.translation')
+        translation_joins, modified_order_by = (
+            itr_obj._apply_translation_2fields(
+                cr, user, self._name, self._table, order_by, context))
+        if  translation_joins:
+            from_clause = from_clause + ' ' + ' '.join(translation_joins)
+            order_by = modified_order_by
         cr.execute('SELECT "%s".id FROM ' % self._table + from_clause + where_str + order_by + limit_str + offset_str, where_clause_params)
         res = cr.fetchall()
         return [x[0] for x in res]