Initial commit: Core packages

odoo-bringout-oca-ocb-loyalty/loyalty/models/__init__.py

@@ -0,0 +1,10 @@
+# -*- coding: utf-8 -*-
+# Part of Odoo. See LICENSE file for full copyright and licensing details.
+
+from . import loyalty_card
+from . import loyalty_mail
+from . import loyalty_reward
+from . import loyalty_rule
+from . import loyalty_program
+from . import product_product
+from . import product_template

odoo-bringout-oca-ocb-loyalty/loyalty/models/loyalty_card.py

@@ -0,0 +1,197 @@
+# -*- coding: utf-8 -*-
+# Part of Odoo. See LICENSE file for full copyright and licensing details.
+
+from uuid import uuid4
+
+from odoo import _, api, fields, models
+from odoo.exceptions import ValidationError
+from odoo.tools import format_amount
+
+
+class LoyaltyCard(models.Model):
+    _name = 'loyalty.card'
+    _inherit = ['mail.thread']
+    _description = 'Loyalty Coupon'
+    _rec_name = 'code'
+
+    @api.model
+    def _generate_code(self):
+        """
+        Barcode identifiable codes.
+        """
+        return '044' + str(uuid4())[7:-18]
+
+    def name_get(self):
+        return [(card.id, f'{card.program_id.name}: {card.code}') for card in self]
+
+    program_id = fields.Many2one('loyalty.program', ondelete='restrict', default=lambda self: self.env.context.get('active_id', None))
+    program_type = fields.Selection(related='program_id.program_type')
+    company_id = fields.Many2one(related='program_id.company_id', store=True)
+    currency_id = fields.Many2one(related='program_id.currency_id')
+    # Reserved for this partner if non-empty
+    partner_id = fields.Many2one('res.partner', index=True)
+    points = fields.Float(tracking=True)
+    point_name = fields.Char(related='program_id.portal_point_name', readonly=True)
+    points_display = fields.Char(compute='_compute_points_display')
+
+    code = fields.Char(default=lambda self: self._generate_code(), required=True)
+    expiration_date = fields.Date()
+
+    use_count = fields.Integer(compute='_compute_use_count')
+
+    _sql_constraints = [
+        ('card_code_unique', 'UNIQUE(code)', 'A coupon/loyalty card must have a unique code.')
+    ]
+
+    @api.constrains('code')
+    def _contrains_code(self):
+        # Prevent a coupon from having the same code a program
+        if self.env['loyalty.rule'].search_count([('mode', '=', 'with_code'), ('code', 'in', self.mapped('code'))]):
+            raise ValidationError(_('A trigger with the same code as one of your coupon already exists.'))
+
+    @api.depends('points', 'point_name')
+    def _compute_points_display(self):
+        for card in self:
+            card.points_display = card._format_points(card.points)
+
+    @api.onchange('expiration_date')
+    def _restrict_expiration_on_loyalty(self):
+        for card in self:
+            if card.program_type == 'loyalty' and card.expiration_date:
+                raise ValidationError(_("Expiration date cannot be set on a loyalty card."))
+
+    def _format_points(self, points):
+        self.ensure_one()
+        if self.point_name == self.program_id.currency_id.symbol:
+            return format_amount(self.env, points, self.program_id.currency_id)
+        if points == int(points):
+            return f"{int(points)} {self.point_name or ''}"
+        return f"{points:.2f} {self.point_name or ''}"
+
+    # Meant to be overriden
+    def _compute_use_count(self):
+        self.use_count = 0
+
+    def _get_default_template(self):
+        self.ensure_one()
+        return self.program_id.communication_plan_ids.filtered(lambda m: m.trigger == 'create').mail_template_id[:1]
+
+    def _get_mail_partner(self):
+        self.ensure_one()
+        return self.partner_id
+
+    def _get_mail_author(self):
+        self.ensure_one()
+        return (
+            self.env.user._is_internal() and self.env.user or self.company_id or self.env.company
+        ).partner_id
+
+    def _get_signature(self):
+        """To be overriden"""
+        self.ensure_one()
+        return None
+
+    def _has_source_order(self):
+        return False
+
+    def action_coupon_send(self):
+        """ Open a window to compose an email, with the default template returned by `_get_default_template`
+            message loaded by default
+        """
+        self.ensure_one()
+        default_template = self._get_default_template()
+        compose_form = self.env.ref('mail.email_compose_message_wizard_form', False)
+        ctx = dict(
+            default_model='loyalty.card',
+            default_res_id=self.id,
+            default_use_template=bool(default_template),
+            default_template_id=default_template and default_template.id,
+            default_composition_mode='comment',
+            default_email_layout_xmlid='mail.mail_notification_light',
+            mark_coupon_as_sent=True,
+            force_email=True,
+        )
+        return {
+            'name': _('Compose Email'),
+            'type': 'ir.actions.act_window',
+            'view_mode': 'form',
+            'res_model': 'mail.compose.message',
+            'views': [(compose_form.id, 'form')],
+            'view_id': compose_form.id,
+            'target': 'new',
+            'context': ctx,
+        }
+
+    def _send_creation_communication(self, force_send=False):
+        """
+        Sends the 'At Creation' communication plan if it exist for the given coupons.
+        """
+        if self.env.context.get('loyalty_no_mail', False) or self.env.context.get('action_no_send_mail', False):
+            return
+        # Ideally one per program, but multiple is supported
+        create_comm_per_program = dict()
+        for program in self.program_id:
+            create_comm_per_program[program] = program.communication_plan_ids.filtered(lambda c: c.trigger == 'create')
+        for coupon in self:
+            if not create_comm_per_program[coupon.program_id] or not coupon._get_mail_partner():
+                continue
+            for comm in create_comm_per_program[coupon.program_id]:
+                mail_template = comm.mail_template_id
+                email_values = {}
+                if not mail_template.email_from:
+                    # provide author_id & email_from values to ensure the email gets sent
+                    author = coupon._get_mail_author()
+                    email_values.update(author_id=author.id, email_from=author.email_formatted)
+                mail_template.send_mail(
+                    res_id=coupon.id,
+                    force_send=force_send,
+                    email_layout_xmlid='mail.mail_notification_light',
+                    email_values=email_values,
+                )
+
+    def _send_points_reach_communication(self, points_changes):
+        """
+        Send the 'When Reaching' communicaton plans for the given coupons.
+
+        If a coupons passes multiple milestones we will only send the one with the highest target.
+        """
+        if self.env.context.get('loyalty_no_mail', False):
+            return
+        milestones_per_program = dict()
+        for program in self.program_id:
+            milestones_per_program[program] = program.communication_plan_ids\
+                .filtered(lambda c: c.trigger == 'points_reach')\
+                .sorted('points', reverse=True)
+        for coupon in self:
+            if not coupon._get_mail_partner():
+                continue
+            coupon_change = points_changes[coupon]
+            # Do nothing if coupon lost points or did not change
+            if not milestones_per_program[coupon.program_id] or\
+                not coupon.partner_id or\
+                coupon_change['old'] >= coupon_change['new']:
+                continue
+            this_milestone = False
+            for milestone in milestones_per_program[coupon.program_id]:
+                if coupon_change['old'] < milestone.points and milestone.points <= coupon_change['new']:
+                    this_milestone = milestone
+                    break
+            if not this_milestone:
+                continue
+            this_milestone.mail_template_id.send_mail(res_id=coupon.id, email_layout_xmlid='mail.mail_notification_light')
+
+
+    @api.model_create_multi
+    def create(self, vals_list):
+        res = super().create(vals_list)
+        res._send_creation_communication()
+        return res
+
+    def write(self, vals):
+        if not self.env.context.get('loyalty_no_mail', False) and 'points' in vals:
+            points_before = {coupon: coupon.points for coupon in self}
+        res = super().write(vals)
+        if not self.env.context.get('loyalty_no_mail', False) and 'points' in vals:
+            points_changes = {coupon: {'old': points_before[coupon], 'new': coupon.points} for coupon in self}
+            self._send_points_reach_communication(points_changes)
+        return res

odoo-bringout-oca-ocb-loyalty/loyalty/models/loyalty_mail.py

@@ -0,0 +1,20 @@
+# -*- coding: utf-8 -*-
+# Part of Odoo. See LICENSE file for full copyright and licensing details.
+
+from odoo import fields, models
+
+# Allow promo programs to send mails upon certain triggers
+# Like : 'At creation' and 'When reaching X points'
+
+class LoyaltyMail(models.Model):
+    _name = 'loyalty.mail'
+    _description = 'Loyalty Communication'
+
+    active = fields.Boolean(default=True)
+    program_id = fields.Many2one('loyalty.program', required=True, ondelete='cascade')
+    trigger = fields.Selection([
+        ('create', 'At Creation'),
+        ('points_reach', 'When Reaching')], string='When', required=True
+    )
+    points = fields.Float()
+    mail_template_id = fields.Many2one('mail.template', string="Email Template", required=True, domain=[('model', '=', 'loyalty.card')])

odoo-bringout-oca-ocb-loyalty/loyalty/models/loyalty_program.py

@@ -0,0 +1,594 @@
+# -*- coding: utf-8 -*-
+# Part of Odoo. See LICENSE file for full copyright and licensing details.
+
+from collections import defaultdict
+
+from odoo import _, api, fields, models
+from odoo.exceptions import UserError, ValidationError
+
+from uuid import uuid4
+
+class LoyaltyProgram(models.Model):
+    _name = 'loyalty.program'
+    _description = 'Loyalty Program'
+    _order = 'sequence'
+    _rec_name = 'name'
+
+    name = fields.Char('Program Name', required=True, translate=True)
+    active = fields.Boolean(default=True)
+    sequence = fields.Integer(copy=False)
+    company_id = fields.Many2one('res.company', 'Company', default=lambda self: self.env.company)
+    currency_id = fields.Many2one('res.currency', 'Currency', compute='_compute_currency_id',
+        readonly=False, required=True, store=True, precompute=True)
+    currency_symbol = fields.Char(related='currency_id.symbol')
+
+    total_order_count = fields.Integer("Total Order Count", compute="_compute_total_order_count")
+
+    rule_ids = fields.One2many('loyalty.rule', 'program_id', 'Conditional rules', copy=True,
+         compute='_compute_from_program_type', readonly=False, store=True)
+    reward_ids = fields.One2many('loyalty.reward', 'program_id', 'Rewards', copy=True,
+         compute='_compute_from_program_type', readonly=False, store=True)
+    communication_plan_ids = fields.One2many('loyalty.mail', 'program_id', copy=True,
+         compute='_compute_from_program_type', readonly=False, store=True)
+
+    # These fields are used for the simplified view of gift_card and ewallet
+    mail_template_id = fields.Many2one('mail.template', compute='_compute_mail_template_id', inverse='_inverse_mail_template_id', string="Email template", readonly=False)
+    trigger_product_ids = fields.Many2many(related='rule_ids.product_ids', readonly=False)
+
+    coupon_ids = fields.One2many('loyalty.card', 'program_id')
+    coupon_count = fields.Integer(compute='_compute_coupon_count')
+    coupon_count_display = fields.Char(compute='_compute_coupon_count_display', string="Items")
+
+    program_type = fields.Selection([
+        ('coupons', 'Coupons'),
+        ('gift_card', 'Gift Card'),
+        ('loyalty', 'Loyalty Cards'),
+        ('promotion', 'Promotions'),
+        ('ewallet', 'eWallet'),
+        ('promo_code', 'Discount Code'),
+        ('buy_x_get_y', 'Buy X Get Y'),
+        ('next_order_coupons', 'Next Order Coupons')],
+        default='promotion', required=True,
+    )
+    date_to = fields.Date(string='Validity')
+    limit_usage = fields.Boolean(string='Limit Usage')
+    max_usage = fields.Integer()
+    # Dictates when the points can be used:
+    # current: if the order gives enough points on that order, the reward may directly be claimed, points lost otherwise
+    # future: if the order gives enough points on that order, a coupon is generated for a next order
+    # both: points are accumulated on the coupon to claim rewards, the reward may directly be claimed
+    applies_on = fields.Selection([
+        ('current', 'Current order'),
+        ('future', 'Future orders'),
+        ('both', 'Current & Future orders')], default='current', required=True,
+         compute='_compute_from_program_type', readonly=False, store=True,
+    )
+    trigger = fields.Selection([
+        ('auto', 'Automatic'),
+        ('with_code', 'Use a code')],
+        compute='_compute_from_program_type', readonly=False, store=True,
+        help="""
+        Automatic: Customers will be eligible for a reward automatically in their cart.
+        Use a code: Customers will be eligible for a reward if they enter a code.
+        """
+    )
+    portal_visible = fields.Boolean(default=False,
+        help="""
+        Show in web portal, PoS customer ticket, eCommerce checkout, the number of points available and used by reward.
+        """)
+    portal_point_name = fields.Char(default='Points', translate=True,
+         compute='_compute_portal_point_name', readonly=False, store=True)
+    is_nominative = fields.Boolean(compute='_compute_is_nominative')
+    is_payment_program = fields.Boolean(compute='_compute_is_payment_program')
+
+    payment_program_discount_product_id = fields.Many2one(
+        'product.product',
+        string='Discount Product',
+        compute='_compute_payment_program_discount_product_id',
+        readonly=True,
+        help="Product used in the sales order to apply the discount."
+    )
+
+    # Technical field used for a label
+    available_on = fields.Boolean("Available On", store=False,
+        help="""
+        Manage where your program should be available for use.
+        """
+    )
+
+    _sql_constraints = [
+        ('check_max_usage', 'CHECK (limit_usage = False OR max_usage > 0)',
+            'Max usage must be strictly positive if a limit is used.'),
+    ]
+
+    @api.constrains('reward_ids')
+    def _constrains_reward_ids(self):
+        if self.env.context.get('loyalty_skip_reward_check'):
+            return
+        if any(not program.reward_ids for program in self):
+            raise ValidationError(_('A program must have at least one reward.'))
+
+    def _compute_total_order_count(self):
+        self.total_order_count = 0
+
+    @api.depends('coupon_count', 'program_type')
+    def _compute_coupon_count_display(self):
+        program_items_name = self._program_items_name()
+        for program in self:
+            program.coupon_count_display = "%i %s" % (program.coupon_count or 0, program_items_name[program.program_type] or '')
+
+    @api.depends("communication_plan_ids.mail_template_id")
+    def _compute_mail_template_id(self):
+        for program in self:
+            program.mail_template_id = program.communication_plan_ids.mail_template_id[:1]
+
+    def _inverse_mail_template_id(self):
+        for program in self:
+            if program.program_type not in ("gift_card", "ewallet"):
+                continue
+            if not program.mail_template_id:
+                program.communication_plan_ids = [(5, 0, 0)]
+            elif not program.communication_plan_ids:
+                program.communication_plan_ids = self.env['loyalty.mail'].create({
+                    'program_id': program.id,
+                    'trigger': 'create',
+                    'mail_template_id': program.mail_template_id.id,
+                })
+            else:
+                program.communication_plan_ids.write({
+                    'trigger': 'create',
+                    'mail_template_id': program.mail_template_id.id,
+                })
+
+    @api.depends('company_id')
+    def _compute_currency_id(self):
+        for program in self:
+            program.currency_id = program.company_id.currency_id or program.currency_id
+
+    @api.depends('coupon_ids')
+    def _compute_coupon_count(self):
+        read_group_data = self.env['loyalty.card']._read_group([('program_id', 'in', self.ids)], ['program_id'], ['program_id'])
+        count_per_program = {r['program_id'][0]: r['program_id_count'] for r in read_group_data}
+        for program in self:
+            program.coupon_count = count_per_program.get(program.id, 0)
+
+    @api.depends('program_type', 'applies_on')
+    def _compute_is_nominative(self):
+        for program in self:
+            program.is_nominative = program.applies_on == 'both' or\
+                (program.program_type == 'ewallet' and program.applies_on == 'future')
+
+    @api.depends('program_type')
+    def _compute_is_payment_program(self):
+        for program in self:
+            program.is_payment_program = program.program_type in ('gift_card', 'ewallet')
+
+    @api.depends('reward_ids.discount_line_product_id')
+    def _compute_payment_program_discount_product_id(self):
+        for program in self:
+            if program.is_payment_program:
+                program.payment_program_discount_product_id = program.reward_ids[:1].discount_line_product_id
+            else:
+                program.payment_program_discount_product_id = False
+
+    @api.model
+    def _program_items_name(self):
+        return {
+            'coupons': _('Coupons'),
+            'promotion': _('Promos'),
+            'gift_card': _('Gift Cards'),
+            'loyalty': _('Loyalty Cards'),
+            'ewallet': _('eWallets'),
+            'promo_code': _('Discounts'),
+            'buy_x_get_y': _('Promos'),
+            'next_order_coupons': _('Coupons'),
+        }
+
+    @api.model
+    def _program_type_default_values(self):
+        # All values to change when program_type changes
+        # NOTE: any field used in `rule_ids`, `reward_ids` and `communication_plan_ids` MUST be present in the kanban view for it to work properly.
+        first_sale_product = self.env['product.product'].search([
+            '|', ('company_id', '=', False), ('company_id', '=', self.company_id.id),
+            ('sale_ok', '=', True)
+        ], limit=1)
+        return {
+            'coupons': {
+                'applies_on': 'current',
+                'trigger': 'with_code',
+                'portal_visible': False,
+                'portal_point_name': _('Coupon point(s)'),
+                'rule_ids': [(5, 0, 0)],
+                'reward_ids': [(5, 0, 0), (0, 0, {
+                    'required_points': 1,
+                    'discount': 10,
+                })],
+                'communication_plan_ids': [(5, 0, 0), (0, 0, {
+                    'trigger': 'create',
+                    'mail_template_id': (self.env.ref('loyalty.mail_template_loyalty_card', raise_if_not_found=False) or self.env['mail.template']).id,
+                })],
+            },
+            'promotion': {
+                'applies_on': 'current',
+                'trigger': 'auto',
+                'portal_visible': False,
+                'portal_point_name': _('Promo point(s)'),
+                'rule_ids': [(5, 0, 0), (0, 0, {
+                    'reward_point_amount': 1,
+                    'reward_point_mode': 'order',
+                    'minimum_amount': 50,
+                    'minimum_qty': 0,
+                })],
+                'reward_ids': [(5, 0, 0), (0, 0, {
+                    'required_points': 1,
+                    'discount': 10,
+                })],
+                'communication_plan_ids': [(5, 0, 0)],
+            },
+            'gift_card': {
+                'applies_on': 'future',
+                'trigger': 'auto',
+                'portal_visible': True,
+                'portal_point_name': self.env.company.currency_id.symbol,
+                'rule_ids': [(5, 0, 0), (0, 0, {
+                    'reward_point_amount': 1,
+                    'reward_point_mode': 'money',
+                    'reward_point_split': True,
+                    'product_ids': self.env.ref('loyalty.gift_card_product_50', raise_if_not_found=False),
+                    'minimum_qty': 0,
+                })],
+                'reward_ids': [(5, 0, 0), (0, 0, {
+                    'reward_type': 'discount',
+                    'discount_mode': 'per_point',
+                    'discount': 1,
+                    'discount_applicability': 'order',
+                    'required_points': 1,
+                    'description': _('Gift Card'),
+                })],
+                'communication_plan_ids': [(5, 0, 0), (0, 0, {
+                    'trigger': 'create',
+                    'mail_template_id': (self.env.ref('loyalty.mail_template_gift_card', raise_if_not_found=False) or self.env['mail.template']).id,
+                })],
+            },
+            'loyalty': {
+                'applies_on': 'both',
+                'trigger': 'auto',
+                'portal_visible': True,
+                'portal_point_name': _('Loyalty point(s)'),
+                'rule_ids': [(5, 0, 0), (0, 0, {
+                    'reward_point_mode': 'money',
+                })],
+                'reward_ids': [(5, 0, 0), (0, 0, {
+                    'discount': 5,
+                    'required_points': 200,
+                })],
+                'communication_plan_ids': [(5, 0, 0)],
+            },
+            'ewallet': {
+                'trigger': 'auto',
+                'applies_on': 'future',
+                'portal_visible': True,
+                'portal_point_name': self.env.company.currency_id.symbol,
+                'rule_ids': [(5, 0, 0), (0, 0, {
+                    'reward_point_amount': '1',
+                    'reward_point_mode': 'money',
+                    'product_ids': self.env.ref('loyalty.ewallet_product_50', raise_if_not_found=False),
+                })],
+                'reward_ids': [(5, 0, 0), (0, 0, {
+                    'reward_type': 'discount',
+                    'discount_mode': 'per_point',
+                    'discount': 1,
+                    'discount_applicability': 'order',
+                    'required_points': 1,
+                    'description': _('eWallet'),
+                })],
+                'communication_plan_ids': [(5, 0, 0)],
+            },
+            'promo_code': {
+                'applies_on': 'current',
+                'trigger': 'with_code',
+                'portal_visible': False,
+                'portal_point_name': _('Discount point(s)'),
+                'rule_ids': [(5, 0, 0), (0, 0, {
+                    'mode': 'with_code',
+                    'code': 'PROMO_CODE_' + str(uuid4())[:4], # We should try not to trigger any unicity constraint
+                    'minimum_qty': 0,
+                })],
+                'reward_ids': [(5, 0, 0), (0, 0, {
+                    'discount_applicability': 'specific',
+                    'discount_product_ids': first_sale_product,
+                    'discount_mode': 'percent',
+                    'discount': 10,
+                })],
+                'communication_plan_ids': [(5, 0, 0)],
+            },
+            'buy_x_get_y': {
+                'applies_on': 'current',
+                'trigger': 'auto',
+                'portal_visible': False,
+                'portal_point_name': _('Credit(s)'),
+                'rule_ids': [(5, 0, 0), (0, 0, {
+                    'reward_point_mode': 'unit',
+                    'product_ids': first_sale_product,
+                    'minimum_qty': 2,
+                })],
+                'reward_ids': [(5, 0, 0), (0, 0, {
+                    'reward_type': 'product',
+                    'reward_product_id': first_sale_product.id,
+                    'required_points': 2,
+                })],
+                'communication_plan_ids': [(5, 0, 0)],
+            },
+            'next_order_coupons': {
+                'applies_on': 'future',
+                'trigger': 'auto',
+                'portal_visible': True,
+                'portal_point_name': _('Coupon point(s)'),
+                'rule_ids': [(5, 0, 0), (0, 0, {
+                    'minimum_amount': 100,
+                    'minimum_qty': 0,
+                })],
+                'reward_ids': [(5, 0, 0), (0, 0, {
+                    'reward_type': 'discount',
+                    'discount_mode': 'percent',
+                    'discount': 15,
+                    'discount_applicability': 'order',
+                })],
+                'communication_plan_ids': [(5, 0, 0), (0, 0, {
+                    'trigger': 'create',
+                    'mail_template_id': (
+                        self.env.ref('loyalty.mail_template_loyalty_card', raise_if_not_found=False)
+                        or self.env['mail.template']
+                    ).id,
+                })],
+            },
+        }
+
+    @api.depends('program_type')
+    def _compute_from_program_type(self):
+        program_type_defaults = self._program_type_default_values()
+        grouped_programs = defaultdict(lambda: self.env['loyalty.program'])
+        for program in self:
+            grouped_programs[program.program_type] |= program
+        for program_type, programs in grouped_programs.items():
+            if program_type in program_type_defaults:
+                programs.write(program_type_defaults[program_type])
+
+    @api.depends("currency_id", "program_type")
+    def _compute_portal_point_name(self):
+        for program in self:
+            if program.program_type not in ('ewallet', 'gift_card'):
+                continue
+            program.portal_point_name = program.currency_id.symbol or ''
+
+    def _get_valid_products(self, products):
+        '''
+        Returns a dict containing the products that match per rule of the program
+        '''
+        rule_products = dict()
+        for rule in self.rule_ids:
+            domain = rule._get_valid_product_domain()
+            if domain:
+                rule_products[rule] = products.filtered_domain(domain)
+            elif not domain and rule.program_type != "gift_card":
+                rule_products[rule] = products
+            else:
+                continue
+        return rule_products
+
+    def action_open_loyalty_cards(self):
+        self.ensure_one()
+        action = self.env['ir.actions.act_window']._for_xml_id("loyalty.loyalty_card_action")
+        action['name'] = self._program_items_name()[self.program_type]
+        action['display_name'] = action['name']
+        action['context'] = {
+            'program_type': self.program_type,
+            'program_item_name': self._program_items_name()[self.program_type],
+            'default_program_id': self.id,
+            # For the wizard
+            'default_mode': self.program_type == 'ewallet' and 'selected' or 'anonymous',
+        }
+        return action
+
+    @api.ondelete(at_uninstall=False)
+    def _unlink_except_active(self):
+        if any(program.active for program in self):
+            raise UserError(_('You can not delete a program in an active state'))
+
+    def toggle_active(self):
+        res = super().toggle_active()
+        # Propagate active state to children
+        for program in self.with_context(active_test=False):
+            program.rule_ids.active = program.active
+            program.reward_ids.active = program.active
+            program.communication_plan_ids.active = program.active
+            program.reward_ids.with_context(active_test=True).discount_line_product_id.active = program.active
+        return res
+
+    def write(self, vals):
+        # There is an issue when we change the program type, since we clear the rewards and create new ones.
+        # The orm actually does it in this order upon writing, triggering the constraint before creating the new rewards.
+        # However we can check that the result of reward_ids would actually be empty or not, and if not, skip the constraint.
+        if 'reward_ids' in vals and self._fields['reward_ids'].convert_to_cache(vals['reward_ids'], self):
+            self = self.with_context(loyalty_skip_reward_check=True)
+            # We need add the program type to the context to avoid getting the default value
+            # ('discount') for reward type when calling the `default_get` method of
+            #`loyalty.reward`.
+            if 'program_type' in vals:
+                self = self.with_context(program_type=vals['program_type'])
+                return super().write(vals)
+            else:
+                for program in self:
+                    program = program.with_context(program_type=program.program_type)
+                    super(LoyaltyProgram, program).write(vals)
+                return True
+        else:
+            return super().write(vals)
+
+    @api.model
+    def get_program_templates(self):
+        '''
+        Returns the templates to be used for promotional programs.
+        '''
+        ctx_menu_type = self.env.context.get('menu_type')
+        if ctx_menu_type == 'gift_ewallet':
+            return {
+                'gift_card': {
+                    'title': _("Gift Card"),
+                    'description': _("Sell Gift Cards, that can be used to purchase products."),
+                    'icon': 'gift_card',
+                },
+                'ewallet': {
+                    'title': _("eWallet"),
+                    'description': _("Fill in your eWallet, and use it to pay future orders."),
+                    'icon': 'ewallet',
+                },
+            }
+        return {
+            'promotion': {
+                'title': _("Promotion Program"),
+                'description': _(
+                    "Define promotions to apply automatically on your customers' orders."
+                ),
+                'icon': 'promotional_program',
+            },
+            'promo_code': {
+                'title': _("Discount Code"),
+                'description': _(
+                    "Share a discount code with your customers to create a purchase incentive."
+                ),
+                'icon': 'promo_code',
+            },
+            'buy_x_get_y': {
+                'title': _("Buy X Get Y"),
+                'description': _(
+                    "Offer Y to your customers if they are buying X; for example, 2+1 free."
+                ),
+                'icon': '2_plus_1',
+            },
+            'next_order_coupons': {
+                'title': _("Next Order Coupons"),
+                'description': _(
+                    "Reward your customers for a purchase with a coupon to use on their next order."
+                ),
+                'icon': 'coupons',
+            },
+            'loyalty': {
+                'title': _("Loyalty Cards"),
+                'description': _("Win points with each purchase, and use points to get gifts."),
+                'icon': 'loyalty_cards',
+            },
+            'coupons': {
+                'title': _("Coupons"),
+                'description': _("Generate and share unique coupons with your customers."),
+                'icon': 'coupons',
+            },
+            'fidelity': {
+                'title': _("Fidelity Cards"),
+                'description': _("Buy 10 products, and get 10$ discount on the 11th one."),
+                'icon': 'fidelity_cards',
+            },
+        }
+
+    @api.model
+    def create_from_template(self, template_id):
+        '''
+        Creates the program from the template id defined in `get_program_templates`.
+
+        Returns an action leading to that new record.
+        '''
+        template_values = self._get_template_values()
+        if template_id not in template_values:
+            return False
+        program = self.create(template_values[template_id])
+        action = {}
+        if self.env.context.get('menu_type') == 'gift_ewallet':
+            action = self.env['ir.actions.act_window']._for_xml_id('loyalty.loyalty_program_gift_ewallet_action')
+            action['views'] = [[False, 'form']]
+        else:
+            action = self.env['ir.actions.act_window']._for_xml_id('loyalty.loyalty_program_discount_loyalty_action')
+            view_id = self.env.ref('loyalty.loyalty_program_view_form').id
+            action['views'] = [[view_id, 'form']]
+        action['view_mode'] = 'form'
+        action['res_id'] = program.id
+        return action
+
+    @api.model
+    def _get_template_values(self):
+        '''
+        Returns the values to create a program using the template keys defined above.
+        '''
+        program_type_defaults = self._program_type_default_values()
+        # For programs that require a product get the first sellable.
+        product = self.env['product.product'].search([('sale_ok', '=', True)], limit=1)
+        return {
+            'gift_card': {
+                'name': _('Gift Card'),
+                'program_type': 'gift_card',
+                **program_type_defaults['gift_card']
+            },
+            'ewallet': {
+                'name': _('eWallet'),
+                'program_type': 'ewallet',
+                **program_type_defaults['ewallet'],
+            },
+            'loyalty': {
+                'name': _('Loyalty Cards'),
+                'program_type': 'loyalty',
+                **program_type_defaults['loyalty'],
+            },
+            'coupons': {
+                'name': _('Coupons'),
+                'program_type': 'coupons',
+                **program_type_defaults['coupons'],
+            },
+            'promotion': {
+                'name': _('Promotional Program'),
+                'program_type': 'promotion',
+                **program_type_defaults['promotion'],
+            },
+            'promo_code': {
+                'name': _('Discount code'),
+                'program_type': 'promo_code',
+                **program_type_defaults['promo_code'],
+            },
+            'buy_x_get_y': {
+                'name': _('2+1 Free'),
+                'program_type': 'buy_x_get_y',
+                **program_type_defaults['buy_x_get_y'],
+            },
+            'next_order_coupons': {
+                'name': _('Next Order Coupons'),
+                'program_type': 'next_order_coupons',
+                **program_type_defaults['next_order_coupons'],
+            },
+            'fidelity': {
+                'name': _('Fidelity Cards'),
+                'program_type': 'loyalty',
+                'applies_on': 'both',
+                'trigger': 'auto',
+                'rule_ids': [(0, 0, {
+                    'reward_point_mode': 'unit',
+                    'product_ids': product,
+                })],
+                'reward_ids': [(0, 0, {
+                    'discount_mode': 'per_order',
+                    'required_points': 11,
+                    'discount_applicability': 'specific',
+                    'discount_product_ids': product,
+                    'discount': 10,
+                })]
+            },
+        }
+
+    @api.model_create_multi
+    def create(self, vals_list):
+        """
+        trigger_product_ids will overwrite product ids defined in a loyalty rule in certain instances. Thus, it should
+        be explicitly removed from an incoming vals dict unless, of course, it was actually a visible field.
+        """
+        for vals in vals_list:
+            if 'trigger_product_ids' in vals and vals.get('program_type') not in ['gift_card', 'ewallet']:
+                del vals['trigger_product_ids']
+
+        return super().create(vals_list)

odoo-bringout-oca-ocb-loyalty/loyalty/models/loyalty_reward.py

@@ -0,0 +1,287 @@
+# -*- coding: utf-8 -*-
+# Part of Odoo. See LICENSE file for full copyright and licensing details.
+
+import ast
+import json
+
+from odoo import _, api, fields, models
+from odoo.exceptions import UserError
+from odoo.osv import expression
+
+class LoyaltyReward(models.Model):
+    _name = 'loyalty.reward'
+    _description = 'Loyalty Reward'
+    _rec_name = 'description'
+    _order = 'required_points asc'
+
+    @api.model
+    def default_get(self, fields_list):
+        # Try to copy the values of the program types default's
+        result = super().default_get(fields_list)
+        if 'program_type' in self.env.context:
+            program_type = self.env.context['program_type']
+            program_default_values = self.env['loyalty.program']._program_type_default_values()
+            if program_type in program_default_values and\
+                len(program_default_values[program_type]['reward_ids']) == 2 and\
+                isinstance(program_default_values[program_type]['reward_ids'][1][2], dict):
+                result.update({
+                    k: v for k, v in program_default_values[program_type]['reward_ids'][1][2].items() if k in fields_list
+                })
+        return result
+
+    def _get_discount_mode_select(self):
+        # The value is provided in the loyalty program's view since we may not have a program_id yet
+        #  and makes sure to display the currency related to the program instead of the company's.
+        symbol = self.env.context.get('currency_symbol', self.env.company.currency_id.symbol)
+        return [
+            ('percent', '%'),
+            ('per_point', _('%s per point', symbol)),
+            ('per_order', _('%s per order', symbol))
+        ]
+
+    def name_get(self):
+        return [(reward.id, '%s - %s' % (reward.program_id.name, reward.description)) for reward in self]
+
+    active = fields.Boolean(default=True)
+    program_id = fields.Many2one('loyalty.program', required=True, ondelete='cascade')
+    program_type = fields.Selection(related="program_id.program_type")
+    # Stored for security rules
+    company_id = fields.Many2one(related='program_id.company_id', store=True)
+    currency_id = fields.Many2one(related='program_id.currency_id')
+
+    description = fields.Char(compute='_compute_description', readonly=False, store=True, translate=True)
+
+    reward_type = fields.Selection([
+        ('product', 'Free Product'),
+        ('discount', 'Discount')],
+        default='discount', required=True,
+    )
+    user_has_debug = fields.Boolean(compute='_compute_user_has_debug')
+
+    # Discount rewards
+    discount = fields.Float('Discount', default=10)
+    discount_mode = fields.Selection(selection=_get_discount_mode_select, required=True, default='percent')
+    discount_applicability = fields.Selection([
+        ('order', 'Order'),
+        ('cheapest', 'Cheapest Product'),
+        ('specific', 'Specific Products')], default='order',
+    )
+    discount_product_domain = fields.Char(default="[]")
+    discount_product_ids = fields.Many2many('product.product', string="Discounted Products")
+    discount_product_category_id = fields.Many2one('product.category', string="Discounted Prod. Categories")
+    discount_product_tag_id = fields.Many2one('product.tag', string="Discounted Prod. Tag")
+    all_discount_product_ids = fields.Many2many('product.product', compute='_compute_all_discount_product_ids')
+    reward_product_domain = fields.Char(compute='_compute_reward_product_domain', store=False)
+    discount_max_amount = fields.Monetary('Max Discount', 'currency_id',
+        help="This is the max amount this reward may discount, leave to 0 for no limit.")
+    discount_line_product_id = fields.Many2one('product.product', copy=False, ondelete='restrict',
+        help="Product used in the sales order to apply the discount. Each reward has its own product for reporting purpose")
+    is_global_discount = fields.Boolean(compute='_compute_is_global_discount')
+
+    # Product rewards
+    reward_product_id = fields.Many2one('product.product', string='Product')
+    reward_product_tag_id = fields.Many2one('product.tag', string='Product Tag')
+    multi_product = fields.Boolean(compute='_compute_multi_product')
+    reward_product_ids = fields.Many2many(
+        'product.product', string="Reward Products", compute='_compute_multi_product',
+        search='_search_reward_product_ids',
+        help="These are the products that can be claimed with this rule.")
+    reward_product_qty = fields.Integer(default=1)
+    reward_product_uom_id = fields.Many2one('uom.uom', compute='_compute_reward_product_uom_id')
+
+    required_points = fields.Float('Points needed', default=1)
+    point_name = fields.Char(related='program_id.portal_point_name', readonly=True)
+    clear_wallet = fields.Boolean(default=False)
+
+    _sql_constraints = [
+        ('required_points_positive', 'CHECK (required_points > 0)',
+            'The required points for a reward must be strictly positive.'),
+        ('product_qty_positive', "CHECK (reward_type != 'product' OR reward_product_qty > 0)",
+            'The reward product quantity must be strictly positive.'),
+        ('discount_positive', "CHECK (reward_type != 'discount' OR discount > 0)",
+            'The discount must be strictly positive.'),
+    ]
+
+    @api.depends('reward_product_id.product_tmpl_id.uom_id', 'reward_product_tag_id')
+    def _compute_reward_product_uom_id(self):
+        for reward in self:
+            reward.reward_product_uom_id = reward.reward_product_ids.product_tmpl_id.uom_id[:1]
+
+    def _find_all_category_children(self, category_id, child_ids):
+        if len(category_id.child_id) > 0:
+            for child_id in category_id.child_id:
+                child_ids.append(child_id.id)
+                self._find_all_category_children(child_id, child_ids)
+        return child_ids
+
+    def _get_discount_product_domain(self):
+        self.ensure_one()
+        domain = []
+        if self.discount_product_ids:
+            domain = [('id', 'in', self.discount_product_ids.ids)]
+        if self.discount_product_category_id:
+            product_category_ids = self._find_all_category_children(self.discount_product_category_id, [])
+            product_category_ids.append(self.discount_product_category_id.id)
+            domain = expression.OR([domain, [('categ_id', 'in', product_category_ids)]])
+        if self.discount_product_tag_id:
+            domain = expression.OR([domain, [('all_product_tag_ids', 'in', self.discount_product_tag_id.id)]])
+        if self.discount_product_domain and self.discount_product_domain != '[]':
+            domain = expression.AND([domain, ast.literal_eval(self.discount_product_domain)])
+        return domain
+
+    @api.model
+    def _get_active_products_domain(self):
+        return [
+            '|',
+                ('reward_type', '!=', 'product'),
+                '&',
+                    ('reward_type', '=', 'product'),
+                    '|',
+                        '&',
+                            ('reward_product_tag_id', '=', False),
+                            ('reward_product_id.active', '=', True),
+                        '&',
+                            ('reward_product_tag_id', '!=', False),
+                            ('reward_product_ids.active', '=', True)
+        ]
+
+    @api.depends('discount_product_domain')
+    def _compute_reward_product_domain(self):
+        compute_all_discount_product = self.env['ir.config_parameter'].sudo().get_param('loyalty.compute_all_discount_product_ids', 'enabled')
+        for reward in self:
+            if compute_all_discount_product == 'enabled':
+                reward.reward_product_domain = "null"
+            else:
+                reward.reward_product_domain = json.dumps(reward._get_discount_product_domain())
+
+    @api.depends('discount_product_ids', 'discount_product_category_id', 'discount_product_tag_id', 'discount_product_domain')
+    def _compute_all_discount_product_ids(self):
+        compute_all_discount_product = self.env['ir.config_parameter'].sudo().get_param('loyalty.compute_all_discount_product_ids', 'enabled')
+        for reward in self:
+            if compute_all_discount_product == 'enabled':
+                reward.all_discount_product_ids = self.env['product.product'].search(reward._get_discount_product_domain())
+            else:
+                reward.all_discount_product_ids = self.env['product.product']
+
+    @api.depends('reward_product_id', 'reward_product_tag_id', 'reward_type')
+    def _compute_multi_product(self):
+        for reward in self:
+            products = reward.reward_product_id + reward.reward_product_tag_id.product_ids
+            reward.multi_product = reward.reward_type == 'product' and len(products) > 1
+            reward.reward_product_ids = reward.reward_type == 'product' and products or self.env['product.product']
+
+    def _search_reward_product_ids(self, operator, value):
+        if operator not in ('=', '!=', 'in'):
+            raise NotImplementedError(_("Unsupported search operator"))
+        return [
+            '&', ('reward_type', '=', 'product'),
+            '|', ('reward_product_id', operator, value),
+            ('reward_product_tag_id.product_ids', operator, value)
+        ]
+
+    @api.depends('reward_type', 'reward_product_id', 'discount_mode', 'reward_product_tag_id',
+                 'discount', 'currency_id', 'discount_applicability', 'all_discount_product_ids')
+    def _compute_description(self):
+        for reward in self:
+            reward_string = ""
+            if reward.program_type == 'gift_card':
+                reward_string = _("Gift Card")
+            elif reward.program_type == 'ewallet':
+                reward_string = _("eWallet")
+            elif reward.reward_type == 'product':
+                products = reward.reward_product_ids
+                if len(products) == 0:
+                    reward_string = _('Free Product')
+                elif len(products) == 1:
+                    reward_string = _('Free Product - %s', reward.reward_product_id.with_context(display_default_code=False).display_name)
+                else:
+                    reward_string = _('Free Product - [%s]', ', '.join(products._origin.with_context(display_default_code=False).mapped('display_name')))
+            elif reward.reward_type == 'discount':
+                format_string = '%(amount)g %(symbol)s'
+                if reward.currency_id.position == 'before':
+                    format_string = '%(symbol)s %(amount)g'
+                formatted_amount = format_string % {'amount': reward.discount, 'symbol': reward.currency_id.symbol}
+                if reward.discount_mode == 'percent':
+                    reward_string = _('%g%% on ', reward.discount)
+                elif reward.discount_mode == 'per_point':
+                    reward_string = _('%s per point on ', formatted_amount)
+                elif reward.discount_mode == 'per_order':
+                    reward_string = _('%s per order on ', formatted_amount)
+                if reward.discount_applicability == 'order':
+                    reward_string += _('your order')
+                elif reward.discount_applicability == 'cheapest':
+                    reward_string += _('the cheapest product')
+                elif reward.discount_applicability == 'specific':
+                    product_available = self.env['product.product'].search(reward._get_discount_product_domain(), limit=2)
+                    if len(product_available) == 1:
+                        reward_string += product_available.with_context(display_default_code=False).display_name
+                    else:
+                        reward_string += _('specific products')
+                if reward.discount_max_amount:
+                    format_string = '%(amount)g %(symbol)s'
+                    if reward.currency_id.position == 'before':
+                        format_string = '%(symbol)s %(amount)g'
+                    formatted_amount = format_string % {'amount': reward.discount_max_amount, 'symbol': reward.currency_id.symbol}
+                    reward_string += _(' (Max %s)', formatted_amount)
+            reward.description = reward_string
+
+    @api.depends('reward_type', 'discount_applicability', 'discount_mode')
+    def _compute_is_global_discount(self):
+        for reward in self:
+            reward.is_global_discount = reward.reward_type == 'discount' and\
+                                        reward.discount_applicability == 'order' and\
+                                        reward.discount_mode == 'percent'
+
+    @api.depends_context('uid')
+    @api.depends("reward_type")
+    def _compute_user_has_debug(self):
+        self.user_has_debug = self.user_has_groups('base.group_no_one')
+
+    @api.onchange('description')
+    def _ensure_reward_has_description(self):
+        for reward in self:
+            if not reward.description:
+                raise UserError(_("The reward description field cannot be empty."))
+
+    def _create_missing_discount_line_products(self):
+        # Make sure we create the product that will be used for our discounts
+        rewards = self.filtered(lambda r: not r.discount_line_product_id)
+        products = self.env['product.product'].create(rewards._get_discount_product_values())
+        for reward, product in zip(rewards, products):
+            reward.discount_line_product_id = product
+
+    @api.model_create_multi
+    def create(self, vals_list):
+        res = super().create(vals_list)
+        res._create_missing_discount_line_products()
+        return res
+
+    def write(self, vals):
+        res = super().write(vals)
+        if 'description' in vals:
+            self._create_missing_discount_line_products()
+            # Keep the name of our discount product up to date
+            for reward in self:
+                reward.discount_line_product_id.write({'name': reward.description})
+        if 'active' in vals:
+            if vals['active']:
+                self.discount_line_product_id.action_unarchive()
+            else:
+                self.discount_line_product_id.action_archive()
+        return res
+
+    def unlink(self):
+        programs = self.program_id
+        res = super().unlink()
+        # Not guaranteed to trigger the constraint
+        programs._constrains_reward_ids()
+        return res
+
+    def _get_discount_product_values(self):
+        return [{
+            'name': reward.description,
+            'type': 'service',
+            'sale_ok': False,
+            'purchase_ok': False,
+            'lst_price': 0,
+        } for reward in self]

odoo-bringout-oca-ocb-loyalty/loyalty/models/loyalty_rule.py

@@ -0,0 +1,141 @@
+# -*- coding: utf-8 -*-
+# Part of Odoo. See LICENSE file for full copyright and licensing details.
+
+import ast
+
+from odoo import _, api, fields, models
+from odoo.exceptions import ValidationError
+from odoo.osv import expression
+
+class LoyaltyRule(models.Model):
+    _name = 'loyalty.rule'
+    _description = 'Loyalty Rule'
+
+    @api.model
+    def default_get(self, fields_list):
+        # Try to copy the values of the program types default's
+        result = super().default_get(fields_list)
+        if 'program_type' in self.env.context:
+            program_type = self.env.context['program_type']
+            program_default_values = self.env['loyalty.program']._program_type_default_values()
+            if program_type in program_default_values and\
+                len(program_default_values[program_type]['rule_ids']) == 2 and\
+                isinstance(program_default_values[program_type]['rule_ids'][1][2], dict):
+                result.update({
+                    k: v for k, v in program_default_values[program_type]['rule_ids'][1][2].items() if k in fields_list
+                })
+        return result
+
+    def _get_reward_point_mode_selection(self):
+        # The value is provided in the loyalty program's view since we may not have a program_id yet
+        #  and makes sure to display the currency related to the program instead of the company's.
+        symbol = self.env.context.get('currency_symbol', self.env.company.currency_id.symbol)
+        return [
+            ('order', _('per order')),
+            ('money', _('per %s spent', symbol)),
+            ('unit', _('per unit paid')),
+        ]
+
+    active = fields.Boolean(default=True)
+    program_id = fields.Many2one('loyalty.program', required=True, ondelete='cascade')
+    program_type = fields.Selection(related="program_id.program_type")
+    # Stored for security rules
+    company_id = fields.Many2one(related='program_id.company_id', store=True)
+    currency_id = fields.Many2one(related='program_id.currency_id')
+
+    # Only for dev mode
+    user_has_debug = fields.Boolean(compute='_compute_user_has_debug')
+    product_domain = fields.Char(default="[]")
+
+    product_ids = fields.Many2many('product.product', string='Products')
+    product_category_id = fields.Many2one('product.category', string='Categories')
+    product_tag_id = fields.Many2one('product.tag', string='Product Tag')
+
+    reward_point_amount = fields.Float(default=1, string="Reward")
+    # Only used for program_id.applies_on == 'future'
+    reward_point_split = fields.Boolean(string='Split per unit', default=False,
+        help="Whether to separate reward coupons per matched unit, only applies to 'future' programs and trigger mode per money spent or unit paid..")
+    reward_point_name = fields.Char(related='program_id.portal_point_name', readonly=True)
+    reward_point_mode = fields.Selection(selection=_get_reward_point_mode_selection, required=True, default='order')
+
+    minimum_qty = fields.Integer('Minimum Quantity', default=1)
+    minimum_amount = fields.Monetary('Minimum Purchase', 'currency_id')
+    minimum_amount_tax_mode = fields.Selection([
+        ('incl', 'Included'),
+        ('excl', 'Excluded')], default='incl', required=True,
+    )
+
+    mode = fields.Selection([
+        ('auto', 'Automatic'),
+        ('with_code', 'With a promotion code'),
+    ], string="Application", compute='_compute_mode', store=True, readonly=False)
+    code = fields.Char(string='Discount code', compute='_compute_code', store=True, readonly=False)
+
+    _sql_constraints = [
+        ('reward_point_amount_positive', 'CHECK (reward_point_amount > 0)', 'Rule points reward must be strictly positive.'),
+    ]
+
+    @api.constrains('reward_point_split')
+    def _constraint_trigger_multi(self):
+        # Prevent setting trigger multi in case of nominative programs, it does not make sense to allow this
+        for rule in self:
+            if rule.reward_point_split and (rule.program_id.applies_on == 'both' or rule.program_id.program_type == 'ewallet'):
+                raise ValidationError(_('Split per unit is not allowed for Loyalty and eWallet programs.'))
+
+    @api.constrains('code')
+    def _constrains_code(self):
+        mapped_codes = self.filtered('code').mapped('code')
+        # Program code must be unique
+        if len(mapped_codes) != len(set(mapped_codes)) or\
+            self.env['loyalty.rule'].search_count(
+                [('mode', '=', 'with_code'), ('code', 'in', mapped_codes), ('id', 'not in', self.ids)]):
+            raise ValidationError(_('The promo code must be unique.'))
+        # Prevent coupons and programs from sharing a code
+        if self.env['loyalty.card'].search_count([('code', 'in', mapped_codes)]):
+            raise ValidationError(_('A coupon with the same code was found.'))
+
+    @api.depends('mode')
+    def _compute_code(self):
+        # Reset code when mode is set to auto
+        for rule in self:
+            if rule.mode == 'auto':
+                rule.code = False
+
+    @api.depends('code')
+    def _compute_mode(self):
+        for rule in self:
+            if rule.code:
+                rule.mode = 'with_code'
+            else:
+                rule.mode = 'auto'
+
+    @api.depends_context('uid')
+    @api.depends("mode")
+    def _compute_user_has_debug(self):
+        self.user_has_debug = self.user_has_groups('base.group_no_one')
+
+    def _get_valid_product_domain(self):
+        self.ensure_one()
+        domain = []
+        if self.product_ids:
+            domain = [('id', 'in', self.product_ids.ids)]
+        if self.product_category_id:
+            domain = expression.OR([domain, [('categ_id', 'child_of', self.product_category_id.id)]])
+        if self.product_tag_id:
+            domain = expression.OR([domain, [('all_product_tag_ids', 'in', self.product_tag_id.id)]])
+        if self.product_domain and self.product_domain != '[]':
+            domain = expression.AND([domain, ast.literal_eval(self.product_domain)])
+        return domain
+
+    def _get_valid_products(self):
+        self.ensure_one()
+        return self.env['product.product'].search(self._get_valid_product_domain())
+
+    def _compute_amount(self, currency_to):
+        self.ensure_one()
+        return self.currency_id._convert(
+            self.minimum_amount,
+            currency_to,
+            self.company_id or self.env.company,
+            fields.Date.today()
+        )

odoo-bringout-oca-ocb-loyalty/loyalty/models/product_product.py

@@ -0,0 +1,35 @@
+# -*- coding: utf-8 -*-
+# Part of Odoo. See LICENSE file for full copyright and licensing details.
+
+from odoo import _, api, models
+from odoo.exceptions import UserError, ValidationError
+
+
+class ProductProduct(models.Model):
+    _inherit = 'product.product'
+
+    def write(self, vals):
+        if not vals.get('active', True) and any(product.active for product in self):
+            # Prevent archiving products used for giving rewards
+            rewards = self.env['loyalty.reward'].sudo().search([
+                ('active', '=', True),
+                '|',
+                ('discount_line_product_id', 'in', self.ids),
+                ('discount_product_ids', 'in', self.ids),
+            ], limit=1)
+            if rewards:
+                raise ValidationError(_("This product may not be archived. It is being used for an active promotion program."))
+        return super().write(vals)
+
+    @api.ondelete(at_uninstall=False)
+    def _unlink_except_loyalty_products(self):
+        product_data = [
+            self.env.ref('loyalty.gift_card_product_50', False),
+            self.env.ref('loyalty.ewallet_product_50', False),
+        ]
+        for product in self.filtered(lambda p: p in product_data):
+            raise UserError(_(
+                "You cannot delete %(name)s as it is used in 'Coupons & Loyalty'."
+                " Please archive it instead.",
+                name=product.with_context(display_default_code=False).display_name
+            ))

odoo-bringout-oca-ocb-loyalty/loyalty/models/product_template.py

@@ -0,0 +1,22 @@
+# -*- coding: utf-8 -*-
+# Part of Odoo. See LICENSE file for full copyright and licensing details.
+
+from odoo import _, api, models
+from odoo.exceptions import UserError
+
+
+class ProductTemplate(models.Model):
+    _inherit = 'product.template'
+
+    @api.ondelete(at_uninstall=False)
+    def _unlink_except_loyalty_products(self):
+        product_data = [
+            self.env.ref('loyalty.gift_card_product_50', False),
+            self.env.ref('loyalty.ewallet_product_50', False),
+        ]
+        for product in self.filtered(lambda p: p.product_variant_id in product_data):
+            raise UserError(_(
+                "You cannot delete %(name)s as it is used in 'Coupons & Loyalty'."
+                " Please archive it instead.",
+                name=product.with_context(display_default_code=False).display_name
+            ))