[FIX] *_coupon: introduce total_order_count as replacement to get_total_order_count()

closes odoo/odoo#40325

Related: odoo/upgrade#1869
Signed-off-by: pimodoo <pimodoo@users.noreply.github.com>

addons/coupon/models/coupon_program.py

@@ -51,6 +51,7 @@ class CouponProgram(models.Model):
     currency_id = fields.Many2one(string="Currency", related='company_id.currency_id', readonly=True)
     validity_duration = fields.Integer(default=30,
         help="Validity duration for a coupon after its generation")
+    total_order_count = fields.Integer("Total Order Count", compute="_compute_total_order_count")
 
     @api.constrains('promo_code')
     def _check_promo_code_constraint(self):
@@ -155,7 +156,6 @@ class CouponProgram(models.Model):
             })
         return generated_coupons
 
-    def get_total_order_count(self):
-        '''This returns the total number of usage of this program.'''
-        self.ensure_one()
-        return 0
+    def _compute_total_order_count(self):
+        for program in self:
+            program.total_order_count = 0

addons/pos_coupon/models/coupon_program.py

@@ -79,6 +79,8 @@ class CouponProgram(models.Model):
             domain = ast.literal_eval(program.rule_partners_domain) if program.rule_partners_domain else []
             program.valid_partner_ids = self.env["res.partner"].search(domain).ids
 
-    def get_total_order_count(self):
-        res = super(CouponProgram, self).get_total_order_count()
-        return res + self.pos_order_count
+    @api.depends('pos_order_ids')
+    def _compute_total_order_count(self):
+        super(CouponProgram, self)._compute_total_order_count()
+        for program in self:
+            program.total_order_count += len(program.pos_order_ids)

addons/pos_coupon/static/src/js/coupon.js

@@ -810,20 +810,20 @@ odoo.define('pos_coupon.pos', function (require) {
 
             // Check max number usage
             if (program.maximum_use_number !== 0) {
-                const numberUse = await rpc
+                const [result] = await rpc
                     .query({
                         model: 'coupon.program',
-                        method: 'get_total_order_count',
-                        args: [program.id],
+                        method: 'read',
+                        args: [program.id, ['total_order_count']],
                         kwargs: { context: session.user_context },
                     })
-                    .catch(() => Promise.resolve(null)); // may happen because offline
-                if (numberUse === null) {
+                    .catch(() => Promise.resolve([false])); // may happen because offline
+                if (!result) {
                     return {
                         successful: false,
                         reason: 'Unable to get the number of usage of the program.',
                     };
-                } else if (!(numberUse < program.maximum_use_number)) {
+                } else if (!(result.total_order_count < program.maximum_use_number)) {
                     return {
                         successful: false,
                         reason: "Program's maximum number of usage has been reached.",

addons/sale_coupon/models/coupon_program.py

@@ -28,7 +28,7 @@ class CouponProgram(models.Model):
 
     def _check_promo_code(self, order, coupon_code):
         message = {}
-        if self.maximum_use_number != 0 and self.get_total_order_count() >= self.maximum_use_number:
+        if self.maximum_use_number != 0 and self.total_order_count >= self.maximum_use_number:
             message = {'error': _('Promo code %s has been expired.') % (coupon_code)}
         elif not self._filter_on_mimimum_amount(order):
             message = {'error': _(
@@ -100,7 +100,7 @@ class CouponProgram(models.Model):
         return self.filtered(lambda program: program.promo_code_usage == 'code_needed' and program.promo_code != order.promo_code)
 
     def _filter_unexpired_programs(self, order):
-        return self.filtered(lambda program: program.maximum_use_number == 0 or program.get_total_order_count() <= program.maximum_use_number)
+        return self.filtered(lambda program: program.maximum_use_number == 0 or program.total_order_count <= program.maximum_use_number)
 
     def _filter_programs_on_partners(self, order):
         return self.filtered(lambda program: program._is_valid_partner(order.partner_id))
@@ -193,6 +193,8 @@ class CouponProgram(models.Model):
         # remove least interesting programs
         return self - (programs - most_interesting_program)
 
-    def get_total_order_count(self):
-        res = super(CouponProgram, self).get_total_order_count()
-        return res + self.order_count
+    # The api.depends is handled in `def modified` of `sale_coupon/models/sale_order.py`
+    def _compute_total_order_count(self):
+        super(CouponProgram, self)._compute_total_order_count()
+        for program in self:
+            program.total_order_count += program.order_count

addons/sale_coupon/models/sale_order.py

@@ -474,9 +474,11 @@ class SaleOrderLine(models.Model):
         if 'product_id' in fnames:
             Program = self.env['coupon.program'].sudo()
             field_order_count = Program._fields['order_count']
+            field_total_order_count = Program._fields['total_order_count']
             programs = self.env.cache.get_records(Program, field_order_count)
+            programs |= self.env.cache.get_records(Program, field_total_order_count)
             if programs:
                 products = self.filtered('is_reward_line').mapped('product_id')
                 for program in programs:
                     if program.discount_line_product_id in products:
-                        self.env.cache.invalidate([(field_order_count, program.ids)])
+                        self.env.cache.invalidate([(field_order_count, program.ids), (field_total_order_count, program.ids)])