[FIX] #563 Updated deprecated method calls to avoid warnings

currency_rate_update/company.py

@@ -26,29 +26,29 @@ class ResCompany(models.Model):
 
     """override company to add currency update"""
 
-    def _multi_curr_enable(self, cr, uid, ids, field_name, arg, context=None):
+    def _multi_curr_enable(self, field_name, arg):
         "check if multi company currency is enabled"
         result = {}
-        if self.pool.get('ir.model.fields').search(cr, uid, [('name', '=', 'company_id'), ('model', '=', 'res.currency')]) == []:
+        if not self.env['ir.model.fields'].search([('name', '=', 'company_id'), ('model', '=', 'res.currency')]):
             enable = 0
         else:
             enable = 1
-        for id in ids:
-            result[id] = enable
+        for company in self:
+            result[company.id] = enable
         return result
 
-    def button_refresh_currency(self, cr, uid, ids, context=None):
+    def button_refresh_currency(self):
         """Refrech  the currency !!for all the company
         now"""
-        currency_updater_obj = self.pool.get('currency.rate.update')
+        currency_updater_obj = self.env['currency.rate.update']
         try:
-            currency_updater_obj.run_currency_update(cr, uid)
+            currency_updater_obj.run_currency_update()
         except Exception as e:
             raise e
         # print "ok"
         return True
 
-    def write(self, cr, uid, ids, vals, context=None):
+    def write(self, vals):
         """handle the activation of the currecny update on compagnies.
         There are two ways of implementing multi_company currency,
         the currency is shared or not. The module take care of the two
@@ -58,41 +58,37 @@ def write(self, cr, uid, ids, vals, context=None):
         If yours currency are not share you will be able to activate the
         auto update on each separated company"""
         save_cron = {}
-        for company in self.browse(cr, uid, ids, context=context):
+        for company in self:
             if 'auto_currency_up' in vals:
                 enable = company.multi_company_currency_enable
-                compagnies = self.search(cr, uid, [])
+                compagnies = self.search()
                 activate_cron = 'f'
                 value = vals.get('auto_currency_up')
                 if not value:
                     for comp in compagnies:
-                        if self.browse(cr, uid, comp).auto_currency_up:
+                        if comp.auto_currency_up:
                             activate_cron = 't'
                             break
                     save_cron.update({'active': activate_cron})
                 else:
                     for comp in compagnies:
-                        if comp != company.id and not enable:
-                            if self.browse(cr, uid, comp).multi_company_currency_enable:
+                        if comp.id != company.id and not enable:
+                            if comp.multi_company_currency_enable:
                                 raise Exception('Yon can not activate auto currency ' +
                                                 'update on more thant one company with this ' +
                                                 'multi company configuration')
                     for comp in compagnies:
-                        if self.browse(cr, uid, comp).auto_currency_up:
+                        if comp.auto_currency_up:
                             activate_cron = 't'
                             break
                     save_cron.update({'active': activate_cron})
 
         if 'interval_type' in vals:
             save_cron.update({'interval_type': vals.get('interval_type')})
         if save_cron:
-            self.pool.get('currency.rate.update').save_cron(
-                cr,
-                uid,
-                save_cron
-            )
+            self.env['currency.rate.update'].save_cron(save_cron)
 
-        return super(ResCompany, self).write(cr, uid, ids, vals, context=context)
+        return super(ResCompany, self).write(vals)
 
     _inherit = "res.company"
 

currency_rate_update/currency_rate_update.py

@@ -78,10 +78,9 @@ class CurrencyRateUpdateService(models.Model):
         )
     ]
 
-    @api.v7
-    def _check_max_delta_days(self, cr, uid, ids):
-        for company in self.read(cr, uid, ids, ['max_delta_days']):
-            if company['max_delta_days'] >= 0:
+    def _check_max_delta_days(self):
+        for company in self:
+            if self.max_delta_days >= 0:
                 continue
             else:
                 return False
@@ -114,26 +113,20 @@ class CurrencyRateUpdate(models.Model):
     LOG_NAME = 'cron-rates'
     MOD_NAME = 'currency_rate_update: '
 
-    @api.v7
-    def get_cron_id(self, cr, uid, context):
+    def get_cron_id(self):
         """return the updater cron's id. Create one if the cron does not exists """
 
         cron_id = 0
-        cron_obj = self.pool.get('ir.cron')
+        cron_obj = self.env['ir.cron']
         try:
             # find the cron that send messages
-            cron_id = cron_obj.search(
-                cr,
-                uid,
+            cron_id = cron_obj.with_context(active_test=False).search(
                 [
                     ('function', 'ilike', self.cron['function']),
                     ('model', 'ilike', self.cron['model'])
-                ],
-                context={
-                    'active_test': False
-                }
+                ]
             )
-            cron_id = int(cron_id[0])
+            cron_id = cron_id[0].id
         except Exception:
             _logger.info('warning cron not found one will be created')
             pass  # ignore if the cron is missing cause we are going to create it in db
@@ -142,38 +135,35 @@ def get_cron_id(self, cr, uid, context):
         if not cron_id:
             # translate
             self.cron['name'] = _('Currency Rate Update')
-            cron_id = cron_obj.create(cr, uid, self.cron, context)
+            cron_id = cron_obj.create(self.cron)
 
         return cron_id
 
-    @api.v7
-    def save_cron(self, cr, uid, datas, context=None):
+    def save_cron(self, datas):
         """save the cron config data should be a dict"""
-        context = context or {}
         # modify the cron
-        cron_id = self.get_cron_id(cr, uid, context)
-        self.pool.get('ir.cron').write(cr, uid, [cron_id], datas)
+        cron_id = self.get_cron_id()
+        self.env['ir.cron'].write([cron_id], datas)
 
-    @api.v7
-    def run_currency_update(self, cr, uid):
+    def run_currency_update(self):
         "update currency at the given frequence"
         factory = CurrencyGetterFactory()
-        curr_obj = self.pool.get('res.currency')
-        rate_obj = self.pool.get('res.currency.rate')
-        companies = self.pool.get('res.company').search(cr, uid, [])
-        for comp in self.pool.get('res.company').browse(cr, uid, companies):
+        curr_obj = self.env['res.currency']
+        rate_obj = self.env['res.currency.rate']
+        companies = self.env['res.company'].search()
+        for comp in companies:
             # the multi company currency can beset or no so we handle
             # the two case
             if not comp.auto_currency_up:
                 continue
             # we initialise the multi compnay search filter or not serach filter
             # we fetch the main currency looking for currency with base = true. The main rate should be set at  1.00
-            main_curr_ids = curr_obj.search(cr, uid, [('base', '=', True), ('company_id', '=', comp.id)])
+            main_curr_ids = curr_obj.search([('base', '=', True), ('company_id', '=', comp.id)])
             if not main_curr_ids:
                 # If we can not find a base currency for this company we look for one with no company set
-                main_curr_ids = curr_obj.search(cr, uid, [('base', '=', True), ('company_id', '=', False)])
+                main_curr_ids = curr_obj.search([('base', '=', True), ('company_id', '=', False)])
             if main_curr_ids:
-                main_curr_rec = curr_obj.browse(cr, uid, main_curr_ids[0])
+                main_curr_rec = main_curr_ids[0]
             else:
                 raise orm.except_orm(_('Error!'), ('There is no base currency set!'))
             if main_curr_rec.rate != 1:
@@ -205,11 +195,7 @@ def run_currency_update(self, cr, uid):
                                 'rate': res[curr.name],
                                 'name': rate_name
                             }
-                            rate_obj.create(
-                                cr,
-                                uid,
-                                vals,
-                            )
+                            rate_obj.create(vals)
 
                     # show the most recent note at the top
                     note = "\n%s currency updated. "\