[MERGE]

bzr revid: hda@tinyerp.com-20091001120820-2tke1hk1ixd7nbb8

9 files changed, 262 insertions, 166 deletions

diff --git a/bin/addons/base/ir/ir_actions.py b/bin/addons/base/ir/ir_actions.py
index 561fdc4ea40..d806f49beb6 100644
--- a/bin/addons/base/ir/ir_actions.py
+++ b/bin/addons/base/ir/ir_actions.py
@@ -350,57 +350,57 @@ class ir_model_fields(osv.osv):
         'complete_name': fields.char('Complete Name', size=64, select=1),
     }
 
-    def name_search(self, cr, uid, name, args=None, operator='ilike', context=None, limit=800):
-        def get_fields(cr, uid, field, rel):
-            result = []
-            mobj = self.pool.get('ir.model')
-            id = mobj.search(cr, uid, [('model','=',rel)])
-
-            obj = self.pool.get('ir.model.fields')
-            ids = obj.search(cr, uid, [('model_id','in',id)])
-            records = obj.read(cr, uid, ids)
-            for record in records:
-                id = record['id']
-                fld = field + '/' + record['name']
-
-                result.append((id, fld))
-            return result
-
-        if not args:
-            args=[]
-        if not context:
-            context={}
-            return super(ir_model_fields, self).name_search(cr, uid, name, args, operator, context, limit)
-
-        if context.get('key') != 'server_action':
-            return super(ir_model_fields, self).name_search(cr, uid, name, args, operator, context, limit)
-
-        result = []
-        obj = self.pool.get('ir.model.fields')
-        ids = obj.search(cr, uid, args)
-        records = obj.read(cr, uid, ids)
-        for record in records:
-            id = record['id']
-            field = record['name']
-
-            if record['ttype'] == 'many2one':
-                rel = record['relation']
-                res = get_fields(cr, uid, field, record['relation'])
-                for rs in res:
-                    result.append(rs)
-
-            result.append((id, field))
-
-        for rs in result:
-            obj.write(cr, uid, [rs[0]], {'complete_name':rs[1]})
-
-        iids = []
-        for rs in result:
-            iids.append(rs[0])
-
-        result = super(ir_model_fields, self).name_search(cr, uid, name, [('complete_name','ilike',name), ('id','in',iids)], operator, context, limit)
-
-        return result
+    def name_search(self, cr, uid, name, args=None, operator='ilike', context=None, limit=80):
+        return super(ir_model_fields, self).name_search(cr, uid, name, args, operator, context, limit)
+#        def get_fields(cr, uid, field, rel):
+#            result = []
+#            mobj = self.pool.get('ir.model')
+#            id = mobj.search(cr, uid, [('model','=',rel)])
+
+#            obj = self.pool.get('ir.model.fields')
+#            ids = obj.search(cr, uid, [('model_id','in',id)])
+#            records = obj.read(cr, uid, ids)
+#            for record in records:
+#                id = record['id']
+#                fld = field + '/' + record['name']
+
+#                result.append((id, fld))
+#            return result
+
+#        if not args:
+#            args=[]
+#        if not context:
+#            context={}
+#            return super(ir_model_fields, self).name_search(cr, uid, name, args, operator, context, limit)
+
+#        if context.get('key') != 'server_action':
+#            return super(ir_model_fields, self).name_search(cr, uid, name, args, operator, context, limit)
+#        result = []
+#        obj = self.pool.get('ir.model.fields')
+#        ids = obj.search(cr, uid, args)
+#        records = obj.read(cr, uid, ids)
+#        for record in records:
+#            id = record['id']
+#            field = record['name']
+
+#            if record['ttype'] == 'many2one':
+#                rel = record['relation']
+#                res = get_fields(cr, uid, field, record['relation'])
+#                for rs in res:
+#                    result.append(rs)
+
+#            result.append((id, field))
+
+#        for rs in result:
+#            obj.write(cr, uid, [rs[0]], {'complete_name':rs[1]})
+
+#        iids = []
+#        for rs in result:
+#            iids.append(rs[0])
+
+#        result = super(ir_model_fields, self).name_search(cr, uid, name, [('complete_name','ilike',name), ('id','in',iids)], operator, context, limit)
+
+#        return result
 
 ir_model_fields()
 
diff --git a/bin/addons/base/ir/ir_cron.py b/bin/addons/base/ir/ir_cron.py
index 7da956c36af..166a5781d44 100644
--- a/bin/addons/base/ir/ir_cron.py
+++ b/bin/addons/base/ir/ir_cron.py
@@ -27,8 +27,6 @@ import tools
 import pooler
 from osv import fields,osv
 
-next_wait = 60
-
 _intervalTypes = {
     'work_days': lambda interval: DateTime.RelativeDateTime(days=interval),
     'days': lambda interval: DateTime.RelativeDateTime(days=interval),
@@ -74,20 +72,18 @@ class ir_cron(osv.osv, netsvc.Agent):
             f = getattr(m, func)
             f(cr, uid, *args)
 
-    def _poolJobs(self, db_name, check=False):
+    def _poolJobs(self, db_name, check=False):        
         try:
             db, pool = pooler.get_db_and_pool(db_name)
         except:
-            return False
-
+            return False        
         if pool._init:
             # retry in a few minutes
-            next_call = 600 
+            next_call = 600
         else:
-            next_call = next_wait
-            cr = db.cursor()
             now = DateTime.now()
             try:
+                cr = db.cursor()
                 cr.execute('select * from ir_cron where numbercall<>0 and active and nextcall<=now() order by priority')
                 for job in cr.dictfetchall():
                     nextcall = DateTime.strptime(job['nextcall'], '%Y-%m-%d %H:%M:%S')
@@ -115,8 +111,32 @@ class ir_cron(osv.osv, netsvc.Agent):
         # Can be improved to do at the min(min(nextcalls), time()+next_call)
         # But is this an improvement ?
         # 
+        cr = db.cursor()
+        cr.execute('select min(nextcall) as min_next_call from ir_cron where numbercall<>0 and active and nextcall>=now()')
+        next_call = cr.dictfetchone()['min_next_call']  
+        cr.close()                 
+        if next_call:                
+            next_call = time.mktime(time.strptime(next_call, '%Y-%m-%d %H:%M:%S'))
+        else:
+            next_call = int(time.time()) + 3600   # if do not find active cron job from database, it will run again after 1 day
         if not check:
-            self.setAlarm(self._poolJobs, int(time.time()) + next_call, db_name, db_name)
+            self.setAlarm(self._poolJobs, next_call, db_name, db_name)
+            
+    def create(self, cr, uid, vals, context=None):
+        res = super(ir_cron, self).create(cr, uid, vals, context=context)        
+        cr.commit()
+        self._poolJobs(cr.dbname)
+        return res
+    def write(self, cr, user, ids, vals, context=None):
+        res = super(ir_cron, self).write(cr, user, ids, vals, context=context)
+        cr.commit()
+        self._poolJobs(cr.dbname)
+        return res
+    def unlink(self, cr, uid, ids, context=None):
+        res = super(ir_cron, self).unlink(cr, uid, ids, context=context)
+        cr.commit()
+        self._poolJobs(cr.dbname)
+        return res
 ir_cron()
 
 # vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4:
diff --git a/bin/addons/base/res/res_currency.py b/bin/addons/base/res/res_currency.py
index 7033abe7ec6..0ce4cbb3254 100644
--- a/bin/addons/base/res/res_currency.py
+++ b/bin/addons/base/res/res_currency.py
@@ -26,6 +26,7 @@ import ir
 
 from tools.misc import currency
 from tools.translate import _
+from tools import config
 
 import mx.DateTime
 from mx.DateTime import RelativeDateTime, now, DateTime, localtime
@@ -67,7 +68,7 @@ class res_currency(osv.osv):
         if currency.rounding == 0:
             return 0.0
         else:
-            return round(amount / currency.rounding) * currency.rounding
+            return round(amount / currency.rounding, int(config['price_accuracy'])) * currency.rounding
 
     def is_zero(self, cr, uid, currency, amount):
         return abs(self.round(cr, uid, currency, amount)) < currency.rounding
diff --git a/bin/addons/quality_integration_server/base_quality_interrogation.py b/bin/addons/quality_integration_server/base_quality_interrogation.py
index a50e12f5391..b79c8a5ff77 100755
--- a/bin/addons/quality_integration_server/base_quality_interrogation.py
+++ b/bin/addons/quality_integration_server/base_quality_interrogation.py
@@ -1,7 +1,7 @@
 # -*- encoding: utf-8 -*-
 ##############################################################################
 #
-#    OpenERP, Open Source Management Solution    
+#    OpenERP, Open Source Management Solution
 #    Copyright (C) 2004-2009 Tiny SPRL (<http://tiny.be>). All Rights Reserved
 #    $Id$
 #
@@ -37,26 +37,36 @@ waittime = 10
 wait_count = 0
 wait_limit = 12
 
+def to_decode(s):
+    try:
+        return s.encode('utf-8')
+    except UnicodeError:
+        try:
+            return s.encode('latin')
+        except UnicodeError:
+            try:
+                return s.decode('ascii')
+            except UnicodeError:
+                return s
+
 def start_server(root_path, port, addons_path):
-    if root_path:
-        root_path += '/'
-    os.system('python2.5 '+root_path+'openerp-server.py  --pidfile=openerp.pid  --port=%s --no-netrpc --addons-path=%s' %(str(port),addons_path))    
+    os.system('python2.5 %sopenerp-server.py  --pidfile=openerp.pid  --port=%s --no-netrpc --addons-path=%s' %(root_path, str(port), addons_path))
 def clean():
     if os.path.isfile('openerp.pid'):
-        ps = open('openerp.pid') 
+        ps = open('openerp.pid')
         if ps:
             pid = int(ps.read())
-            ps.close()  
-            if pid:    
+            ps.close()
+            if pid:
                 os.kill(pid,9)
-                
+
 def execute(connector, method, *args):
     global wait_count
     res = False
-    try:        
+    try:
         res = getattr(connector,method)(*args)
-    except socket.error,e:        
-        if e.args[0] == 111:                                    
+    except socket.error,e:
+        if e.args[0] == 111:
             if wait_count > wait_limit:
                 print "Server is taking too long to start, it has exceeded the maximum limit of %d seconds."%(wait_limit)
                 clean()
@@ -68,24 +78,23 @@ def execute(connector, method, *args):
         else:
             raise e
     wait_count = 0
-    return res                  
-
+    return res
 
 def login(uri, dbname, user, pwd):
     conn = xmlrpclib.ServerProxy(uri + '/xmlrpc/common')
-    uid = execute(conn,'login',dbname, user, pwd) 
+    uid = execute(conn,'login',dbname, user, pwd)
     return uid
 
-def import_translate(uri, user, pwd, dbname, translate_in):      
-    uid = login(uri, dbname, user, pwd)    
-    if uid:        
+def import_translate(uri, user, pwd, dbname, translate_in):
+    uid = login(uri, dbname, user, pwd)
+    if uid:
         conn = xmlrpclib.ServerProxy(uri + '/xmlrpc/wizard')
         wiz_id = execute(conn,'create',dbname, uid, pwd, 'module.lang.import')
         for trans_in in translate_in:
-            lang,ext = os.path.splitext(trans_in.split('/')[-1])                
-            state = 'init'  
+            lang,ext = os.path.splitext(trans_in.split('/')[-1])
+            state = 'init'
             datas = {'form':{}}
-            while state!='end':                
+            while state!='end':
                 res = execute(conn,'execute',dbname, uid, pwd, wiz_id, datas, state, {})
                 if 'datas' in res:
                     datas['form'].update( res['datas'].get('form',{}) )
@@ -101,41 +110,49 @@ def import_translate(uri, user, pwd, dbname, translate_in):
                     })
                     trans_obj.close()
                 elif res['type']=='action':
-                    state = res['state']                    
-                
-        
-def check_quality(uri, user, pwd, dbname, modules):       
+                    state = res['state']
+
+
+def check_quality(uri, user, pwd, dbname, modules, quality_logs):
     uid = login(uri, dbname, user, pwd)
+    quality_logs += 'quality-logs'
     if uid:
         conn = xmlrpclib.ServerProxy(uri + '/xmlrpc/object')
-        qualityresult = {}  
-        final = {}   
-        test_detail = {}
-        for module in modules:            
+        final = {}
+        for module in modules:
+            qualityresult = {}
+            test_detail = {}
             quality_result = execute(conn,'execute', dbname, uid, pwd,'module.quality.check','check_quality',module)
             detail_html = ''
-            html = '''<html><html><html><html><body><a name="TOP"></a>'''
-            html +="<h1> Module : %s </h1>"%(quality_result['name'])   
-            html += "<h2> Final score : %s</h2>"%(quality_result['final_score'])
+            html = '''<html><body><a name="TOP"></a>'''
+            html +="<h1> Module: %s </h1>"%(quality_result['name'])
+            html += "<h2> Final score: %s</h2>"%(quality_result['final_score'])
             html += "<div id='tabs'>"
             html += "<ul>"
-            for x,y,detail in quality_result['check_detail_ids']:                
+            for x,y,detail in quality_result['check_detail_ids']:
                 test = detail.get('name')
+                msg = detail.get('message','')
                 score = round(float(detail.get('score',0)),2)
                 html += "<li><a href=\"#%s\">%s</a></li>"%(test.replace(' ','-'),test)
-                detail_html +="<div id=\"%s\"><h3>%s (Score : %s)</h3>%s</div>"%(test.replace(' ','-'),test,score,detail.get('detail'))                
-                test_detail[test] = (score,detail.get('detail',''))
-            html += "</ul>%s</body></html></html></html></html></html>"%(detail_html)
-            html += "</div>"
-            final[quality_result['name']] = (quality_result['final_score'],html,test_detail)
-
-        fp = open('quality_log.pck','wb')
-        pck_obj = pickle.dump(final,fp)
-        fp.close()
-        print "LOG PATH%s"%(os.path.realpath('quality_log.pck'))
-        return final
+                detail_html +='''<div id=\"%s\"><h3>%s (Score : %s)</h3><font color=red><h5>%s</h5></font>%s</div>'''%(test.replace(' ', '-'), test, score, msg, detail.get('detail', ''))
+                test_detail[test] = (score,msg,detail.get('detail',''))
+            html += "</ul>"
+            html += "%s"%(detail_html)
+            html += "</div></body></html>"
+            if not os.path.isdir(quality_logs):
+                os.mkdir(quality_logs)
+            fp = open('%s/%s.html'%(quality_logs,module),'wb')
+            fp.write(to_decode(html))
+            fp.close()
+            #final[quality_result['name']] = (quality_result['final_score'],html,test_detail)
+
+        #fp = open('quality_log.pck','wb')
+        #pck_obj = pickle.dump(final,fp)
+        #fp.close()
+        #print "LOG PATH%s"%(os.path.realpath('quality_log.pck'))
+        return True
     else:
-        print 'Login Failed...'        
+        print 'Login Failed...'
         clean()
         sys.exit(1)
 
@@ -156,76 +173,101 @@ def create_db(uri, dbname, user='admin', pwd='admin', lang='en_US'):
     login_conn = xmlrpclib.ServerProxy(uri + '/xmlrpc/common')
     db_list = execute(conn, 'list')
     if dbname not in db_list:
-        id = execute(conn,'create',admin_passwd, dbname, True, lang) 
+        id = execute(conn,'create',admin_passwd, dbname, True, lang)
         wait(id,uri)
-    uid = login_conn.login(dbname, user, pwd)   
+    uid = login_conn.login(dbname, user, pwd)
 
     wiz_id = execute(wiz_conn,'create', dbname, uid, user, 'base_setup.base_setup')
 
     state = 'init'
     datas = {'form':{}}
 
-    while state!='config':        
+    while state!='config':
         res = execute(wiz_conn, 'execute', dbname, uid, pwd, wiz_id, datas, state, {})
         if state=='init':
             datas['form'].update( res['datas'] )
         if res['type']=='form':
-            for field in res['fields'].keys():               
+            for field in res['fields'].keys():
                 datas['form'][field] = datas['form'].get(field,False)
             state = res['state'][-1][0]
             datas['form'].update({
-                'profile': -1                
+                'profile': -1
             })
         elif res['type']=='state':
             state = res['state']
     res = execute(wiz_conn, 'execute', dbname, uid, pwd, wiz_id, datas, state, {})
-    install_module(uri, dbname, ['base_module_quality'],user,pwd)
+    install_module(uri, dbname, ['base_module_quality'],user=user,pwd=pwd)
     return True
 
 def drop_db(uri, dbname):
     conn = xmlrpclib.ServerProxy(uri + '/xmlrpc/db')
     db_list = execute(conn,'list')
     if dbname in db_list:
-        execute(conn, 'drop', admin_passwd, dbname)    
+        execute(conn, 'drop', admin_passwd, dbname)
     return True
 
-def install_module(uri, dbname, modules, user='admin', pwd='admin'):
+def make_links(uri, uid, dbname, source, destination, module, user, pwd):
+    if module in ('base','quality_integration_server'):
+        return True
+    if not os.path.islink(destination + '/' + module):
+        if not os.path.isdir(destination + '/' + module):
+            for path in source:
+                if os.path.isdir(path + '/' + module):
+                    os.symlink(path + '/' + module, destination + '/' + module)
+                    obj_conn = xmlrpclib.ServerProxy(uri + '/xmlrpc/object')
+                    execute(obj_conn, 'execute', dbname, uid, pwd, 'ir.module.module', 'update_list')
+                    module_ids = execute(obj_conn, 'execute', dbname, uid, pwd, 'ir.module.module', 'search', [('name','=',module)])
+                    if len(module_ids):
+                        data = execute(obj_conn, 'execute', dbname, uid, pwd, 'ir.module.module', 'read', module_ids[0],['name','dependencies_id'])
+                        dep_datas = execute(obj_conn, 'execute', dbname, uid, pwd, 'ir.module.module.dependency', 'read', data['dependencies_id'],['name'])
+                        for dep_data in dep_datas:
+                            make_links(uri, uid, dbname, source, destination, dep_data['name'], user, pwd)
+                    return True
+    return False
+
+def install_module(uri, dbname, modules, addons='', extra_addons='',  user='admin', pwd='admin'):
     uid = login(uri, dbname, user, pwd)
-    if uid: 
+    if extra_addons:
+        extra_addons = extra_addons.split(',')
+    if uid:
+        if addons and extra_addons:
+            for module in modules:
+                make_links(uri, uid, dbname, extra_addons, addons, module, user, pwd)
+
         obj_conn = xmlrpclib.ServerProxy(uri + '/xmlrpc/object')
         wizard_conn = xmlrpclib.ServerProxy(uri + '/xmlrpc/wizard')
-        module_ids = execute(obj_conn, 'execute', dbname, uid, pwd, 'ir.module.module', 'search', [('name','in',modules)])  
-        execute(obj_conn, 'execute', dbname, uid, pwd, 'ir.module.module', 'button_install', module_ids)           
+        module_ids = execute(obj_conn, 'execute', dbname, uid, pwd, 'ir.module.module', 'search', [('name','in',modules)])
+        execute(obj_conn, 'execute', dbname, uid, pwd, 'ir.module.module', 'button_install', module_ids)
         wiz_id = execute(wizard_conn, 'create', dbname, uid, pwd, 'module.upgrade.simple')
         state = 'init'
         datas = {}
         #while state!='menu':
-        while state!='end':                
-            res = execute(wizard_conn, 'execute', dbname, uid, pwd, wiz_id, datas, state, {})                
+        while state!='end':
+            res = execute(wizard_conn, 'execute', dbname, uid, pwd, wiz_id, datas, state, {})
             if state == 'init':
                 state = 'start'
             elif state == 'start':
-                state = 'end'                                  
+                state = 'end'
     return True
 
 def upgrade_module(uri, dbname, modules, user='admin', pwd='admin'):
     uid = login(uri, dbname, user, pwd)
-    if uid: 
+    if uid:
         obj_conn = xmlrpclib.ServerProxy(uri + '/xmlrpc/object')
-        wizard_conn = xmlrpclib.ServerProxy(uri + '/xmlrpc/wizard')        
-        module_ids = execute(obj_conn, 'execute', dbname, uid, pwd, 'ir.module.module', 'search', [('name','in',modules)])  
-        execute(obj_conn, 'execute', dbname, uid, pwd, 'ir.module.module', 'button_upgrade', module_ids)           
+        wizard_conn = xmlrpclib.ServerProxy(uri + '/xmlrpc/wizard')
+        module_ids = execute(obj_conn, 'execute', dbname, uid, pwd, 'ir.module.module', 'search', [('name','in',modules)])
+        execute(obj_conn, 'execute', dbname, uid, pwd, 'ir.module.module', 'button_upgrade', module_ids)
         wiz_id = execute(wizard_conn, 'create', dbname, uid, pwd, 'module.upgrade.simple')
         state = 'init'
         datas = {}
         #while state!='menu':
-        while state!='end':                
-            res = execute(wizard_conn, 'execute', dbname, uid, pwd, wiz_id, datas, state, {})                
+        while state!='end':
+            res = execute(wizard_conn, 'execute', dbname, uid, pwd, wiz_id, datas, state, {})
             if state == 'init':
                 state = 'start'
             elif state == 'start':
-                state = 'end'                                  
-                            
+                state = 'end'
+
     return True
 
 
@@ -238,28 +280,32 @@ Basic Commands:
     start-server         Start Server
     create-db            Create new database
     drop-db              Drop database
-    install-module       Install module 
+    install-module       Install module
     upgrade-module       Upgrade module
     install-translation  Install translation file
     check-quality        Calculate quality and dump quality result into quality_log.pck using pickle
 """
-parser = optparse.OptionParser(usage)            
+parser = optparse.OptionParser(usage)
 parser.add_option("--modules", dest="modules",
                      help="specify modules to install or check quality")
 parser.add_option("--addons-path", dest="addons_path", help="specify the addons path")
+parser.add_option("--quality-logs", dest="quality_logs", help="specify the path of quality logs files which has to stores")
 parser.add_option("--root-path", dest="root_path", help="specify the root path")
 parser.add_option("-p", "--port", dest="port", help="specify the TCP port", type="int")
-parser.add_option("-d", "--database", dest="db_name", help="specify the database name")  
-parser.add_option("--login", dest="login", help="specify the User Login") 
-parser.add_option("--password", dest="pwd", help="specify the User Password")  
+parser.add_option("-d", "--database", dest="db_name", help="specify the database name")
+parser.add_option("--login", dest="login", help="specify the User Login")
+parser.add_option("--password", dest="pwd", help="specify the User Password")
 parser.add_option("--translate-in", dest="translate_in",
                      help="specify .po files to import translation terms")
+parser.add_option("--extra-addons", dest="extra_addons",
+                     help="specify extra_addons and trunkCommunity modules path ")
+
 (opt, args) = parser.parse_args()
 if len(args) != 1:
     parser.error("incorrect number of arguments")
 command = args[0]
 if command not in ('start-server','create-db','drop-db','install-module','upgrade-module','check-quality','install-translation'):
-    parser.error("incorrect command")    
+    parser.error("incorrect command")
 
 def die(cond, msg):
     if cond:
@@ -274,38 +320,47 @@ die(opt.translate_in and (not opt.db_name),
 
 options = {
     'addons-path' : opt.addons_path or 'addons',
+    'quality-logs' : opt.quality_logs or '',
     'root-path' : opt.root_path or '',
-    'translate-in': opt.translate_in,
-    'port' : opt.port or 8069,        
+    'translate-in': [],
+    'port' : opt.port or 8069,
     'database': opt.db_name or 'terp',
     'modules' : opt.modules or [],
     'login' : opt.login or 'admin',
     'pwd' : opt.pwd or '',
+    'extra-addons':opt.extra_addons or []
 }
 
 options['modules'] = opt.modules and map(lambda m: m.strip(), opt.modules.split(',')) or []
-options['translate_in'] = opt.translate_in and map(lambda m: m.strip(), opt.translate_in.split(',')) or []
+# Hint:i18n-import=purchase:ar_AR.po+sale:fr_FR.po,nl_BE.po
+if opt.translate_in:
+    translate = opt.translate_in
+    for module_name,po_files in map(lambda x:tuple(x.split(':')),translate.split('+')):
+        for po_file in po_files.split(','):
+            po_link = '%s/%s/i18n/%s'%(options['addons-path'], module_name, po_file)
+            options['translate-in'].append(po_link)
+
 uri = 'http://localhost:' + str(options['port'])
 
 server_thread = threading.Thread(target=start_server,
                 args=(options['root-path'], options['port'], options['addons-path']))
-try:    
-    server_thread.start()       
-    if command == 'create-db': 
+try:
+    server_thread.start()
+    if command == 'create-db':
         create_db(uri, options['database'], options['login'], options['pwd'])
-    if command == 'drop-db': 
+    if command == 'drop-db':
         drop_db(uri, options['database'])
-    if command == 'install-module': 
-        install_module(uri, options['database'], options['modules'], options['login'], options['pwd'])
-    if command == 'upgrade-module': 
+    if command == 'install-module':
+        install_module(uri, options['database'], options['modules'],options['addons-path'],options['extra-addons'],options['login'], options['pwd'])
+    if command == 'upgrade-module':
         upgrade_module(uri, options['database'], options['modules'], options['login'], options['pwd'])
     if command == 'check-quality':
-        check_quality(uri, options['login'], options['pwd'], options['database'], options['modules'])
-    if command == 'install-translation':        
-        import_translate(uri, options['login'], options['pwd'], options['database'], options['translate_in'])
+        check_quality(uri, options['login'], options['pwd'], options['database'], options['modules'], options['quality-logs'])
+    if command == 'install-translation':
+        import_translate(uri, options['login'], options['pwd'], options['database'], options['translate-in'])
     clean()
     sys.exit(0)
-    
+
 except xmlrpclib.Fault, e:
     print e.faultString
     clean()
@@ -315,4 +370,4 @@ except Exception, e:
     clean()
     sys.exit(1)
 
-# vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4:
\ No newline at end of file
+# vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4:
diff --git a/bin/osv/fields.py b/bin/osv/fields.py
index 679a2d99664..6838b971bac 100644
--- a/bin/osv/fields.py
+++ b/bin/osv/fields.py
@@ -608,6 +608,12 @@ class function(_column):
         self._multi = multi
         if 'relation' in args:
             self._obj = args['relation']
+            
+        if 'digits' in args:
+            self.digits = args['digits']
+        else:
+            self.digits = (16,2)    
+                
         self._fnct_inv_arg = fnct_inv_arg
         if not fnct_inv:
             self.readonly = 1
diff --git a/bin/osv/orm.py b/bin/osv/orm.py
index 53bc94c7a61..280497e9751 100644
--- a/bin/osv/orm.py
+++ b/bin/osv/orm.py
@@ -301,7 +301,10 @@ def get_pg_type(f):
         t = eval('fields.'+(f._type))
         f_type = (type_dict[t], type_dict[t])
     elif isinstance(f, fields.function) and f._type == 'float':
-        f_type = ('float8', 'DOUBLE PRECISION')
+        if f.digits:
+            f_type = ('numeric', 'NUMERIC(%d,%d)' % (f.digits[0], f.digits[1]))
+        else:
+            f_type = ('float8', 'DOUBLE PRECISION')
     elif isinstance(f, fields.function) and f._type == 'selection':
         f_type = ('text', 'text')
     elif isinstance(f, fields.function) and f._type == 'char':
@@ -1000,9 +1003,10 @@ class orm_template(object):
                     attrs = {'views': views}
                     if node.get('widget') and node.get('widget') == 'selection':
                         # We can not use the 'string' domain has it is defined according to the record !
-                        dom = None
+                        dom = []
                         if column._domain and not isinstance(column._domain, (str, unicode)):
                             dom = column._domain
+                        
                         attrs['selection'] = self.pool.get(relation).name_search(cr, user, '', dom, context=context)
                         if (node.get('required') and not int(node.get('required'))) or not column.required:
                             attrs['selection'].append((False,''))
@@ -1876,6 +1880,8 @@ class orm(orm_template):
                                 ('varchar', 'text', 'TEXT', ''),
                                 ('int4', 'float', get_pg_type(f)[1], '::'+get_pg_type(f)[1]),
                                 ('date', 'datetime', 'TIMESTAMP', '::TIMESTAMP'),
+                                ('numeric', 'float', get_pg_type(f)[1], '::'+get_pg_type(f)[1]),
+                                ('float8', 'float', get_pg_type(f)[1], '::'+get_pg_type(f)[1]),
                             ]
                             # !!! Avoid reduction of varchar field !!!
                             if f_pg_type == 'varchar' and f._type == 'char' and f_pg_size < f.size:
@@ -1888,13 +1894,15 @@ class orm(orm_template):
                                 cr.commit()
                             for c in casts:
                                 if (f_pg_type==c[0]) and (f._type==c[1]):
-                                    logger.notifyChannel('orm', netsvc.LOG_INFO, "column '%s' in table '%s' changed type to %s." % (k, self._table, c[1]))
-                                    ok = True
-                                    cr.execute('ALTER TABLE "%s" RENAME COLUMN "%s" TO temp_change_size' % (self._table, k))
-                                    cr.execute('ALTER TABLE "%s" ADD COLUMN "%s" %s' % (self._table, k, c[2]))
-                                    cr.execute(('UPDATE "%s" SET "%s"=temp_change_size'+c[3]) % (self._table, k))
-                                    cr.execute('ALTER TABLE "%s" DROP COLUMN temp_change_size CASCADE' % (self._table,))
-                                    cr.commit()
+                                    if f_pg_type != f_obj_type:
+                                        logger.notifyChannel('orm', netsvc.LOG_INFO, "column '%s' in table '%s' changed type to %s." % (k, self._table, c[1]))
+                                        ok = True
+                                        cr.execute('ALTER TABLE "%s" RENAME COLUMN "%s" TO temp_change_size' % (self._table, k))
+                                        cr.execute('ALTER TABLE "%s" ADD COLUMN "%s" %s' % (self._table, k, c[2]))
+                                        cr.execute(('UPDATE "%s" SET "%s"=temp_change_size'+c[3]) % (self._table, k))
+                                        cr.execute('ALTER TABLE "%s" DROP COLUMN temp_change_size CASCADE' % (self._table,))
+                                        cr.commit()
+                                    break
 
                             if f_pg_type != f_obj_type:
                                 if not ok:
@@ -2568,9 +2576,10 @@ class orm(orm_template):
             if c[0].startswith('default_'):
                 del rel_context[c[0]]
 
+        result = []
         for field in upd_todo:
             for id in ids:
-                self._columns[field].set(cr, self, id, field, vals[field], user, context=rel_context)
+                result += self._columns[field].set(cr, self, id, field, vals[field], user, context=rel_context) or []
 
         for table in self._inherits:
             col = self._inherits[table]
@@ -2632,7 +2641,7 @@ class orm(orm_template):
                         cr.execute('update '+self._table+' set parent_right=parent_right+%s where parent_right>=%s', (distance, position))
                         cr.execute('update '+self._table+' set parent_left=parent_left-%s, parent_right=parent_right-%s where parent_left>=%s and parent_left<%s', (pleft-position+distance,pleft-position+distance, pleft+distance, pright+distance))
 
-        result = self._store_get_values(cr, user, ids, vals.keys(), context)
+        result += self._store_get_values(cr, user, ids, vals.keys(), context)
         for order, object, ids, fields in result:
             self.pool.get(object)._store_set_values(cr, user, ids, fields, context)
 
@@ -2831,6 +2840,8 @@ class orm(orm_template):
         for fnct in range(len(fncts)):
             if fncts[fnct][3]:
                 ok = False
+                if not fields:
+                    ok = True
                 for f in (fields or []):
                     if f in fncts[fnct][3]:
                         ok = True
diff --git a/bin/release.py b/bin/release.py
index 158af8793e4..935d2136460 100644
--- a/bin/release.py
+++ b/bin/release.py
@@ -22,7 +22,7 @@
 ##############################################################################
 
 name = 'openerp-server'
-version = '5.0.5-bzr'
+version = '5.0.6'
 major_version = '5.0'
 description = 'OpenERP Server'
 long_desc = '''\
diff --git a/bin/report/printscreen/ps_list.py b/bin/report/printscreen/ps_list.py
index 8534fd5c887..d2f946e6715 100644
--- a/bin/report/printscreen/ps_list.py
+++ b/bin/report/printscreen/ps_list.py
@@ -51,7 +51,10 @@ class report_printscreen_list(report_int):
         return result
 
     def _parse_string(self, view):
-        dom = etree.XML(view)
+        try:
+            dom = etree.XML(view.encode('utf-8'))
+        except:
+            dom = etree.XML(view)   
         return self._parse_node(dom)
 
     def create(self, cr, uid, ids, datas, context=None):
diff --git a/bin/tools/translate.py b/bin/tools/translate.py
index e4dd6588054..2d92778c380 100644
--- a/bin/tools/translate.py
+++ b/bin/tools/translate.py
@@ -426,14 +426,14 @@ def trans_generate(lang, modules, dbname=None):
         xml_name = "%s.%s" % (module, encode(xml_name))
 
         if not pool.get(model):
-            logger.notifyChannel("db", netsvc.LOG_ERROR, "unable to find object %r" % (model,))
+            logger.notifyChannel("db", netsvc.LOG_ERROR, "Unable to find object %r" % (model,))
             continue
         
-        try:
-            obj = pool.get(model).browse(cr, uid, res_id)
-        except BrowseRecordError:
-            logger.notifyChannel("db", netsvc.LOG_ERROR, "unable to find object %r with id %d" % (model, res_id))
+        exists = pool.get(model).exists(cr, uid, res_id)
+        if not exists:
+            logger.notifyChannel("db", netsvc.LOG_WARNING, "Unable to find object %r with id %d" % (model, res_id))
             continue
+        obj = pool.get(model).browse(cr, uid, res_id)
 
         if model=='ir.ui.view':
             d = etree.XML(encode(obj.arch))