[ADD] event_crm: create leads from attendees

PURPOSE

Introduce an automated tool to create leads from event registrations. Events
are a powerful source of leads as they attract attention. This leads to leads
with good quality as they mark interest while gathering contact information
which allows to follow-up.

This merge aims at automating this process by automatically creating leads
based on user-defined rules.

SPECIFICATIONS

Add a new module event_crm. It allows to create leads automatically based on
event registrations. This is done based on rules defined in a new model
event_lead_rule.

Add a new menu "Lead Generation" in the configuration tab of an event. It
allows to create generation rules. Those are a set of conditions to generate
a lead with some pre-filled values as the type of lead, tags or salesperson.

SPECIFICATIONS: CREATION TYPE

There are two types of lead creation:

  * per attendee: create a lead for each registration;
  * per order: create a lead for a group of registrations;

The last one is only available through interface if it is possible to register
a group of attendees in one action (when event_sale or website_event are
installed). Behavior itself is implemented directly in event_crm.

Basically a group is either a list of registrations belonging to the same
event and created in batch (website_event flow). With event_sale this
definition will be improved to be based on sale_order.

SPECIFICATIONS: CREATION TRIGGERS

There are three options to trigger lead creation. We consider basically that
lead quality increases if attendees confirmed or went to the event. Triggers
allow therefore to run rules:

  * at attendee creation;
  * at attendee confirmation;
  * at attendee venue;

This trigger defines when the rule will run.

SPECIFICATIONS: FILTERING REGISTRATIONS

When a batch of registrations matches the rule trigger we filter them based
on conditions and rules defines on event_lead_rule model. Heuristic is the
following:

  * the rule is active;
  * if a filter is set: filter registrations based on this filter. This is
    done like a search, and filter is a domain;
  * if a company is set on the rule, it must match event's company. Note
    that multi-company rules apply on event_lead_rule;
  * if an event category is set, it must match;
  * if an event is set, it must match;
  * if both event and category are set, one of them must match (OR). If none
    of those are set, it is considered as passing;

If conditions are met, leads are created with pre-filled informations defined
on the rule (type, user_id, team_id). Contact information coming from the
registrations are computed (customer, name, email, phone, mobile, contact_name).

SPECIFICATIONS: OTHER POINTS

Note that all rules matching their conditions are applied. This means more
than one lead can be created depending on the configuration. This is
intended in order to give more freedom to the user using the automatic
lead generation.

Once a lead is created for an event registration, a stat button on the event
is available to show the number of leads generated for this event and to
be able to find them in one click.

Additionally on the lead form, a stat button will be display to show the
registrations linked to this lead. On registrations a stat button is also
displayed to find the leads created from it or from its group.

Most of code has been written to run in batch, in case multiples rules have
to run on a set of new registrations. Tests are added to ensure behavior.

LINKS

Task ID 2166679
PR #52334
Upgrade PR odoo/upgrade#1292

Co-Authored-By: Jérémy Hennecart <jeh@odoo.com>
Co-Authored-By: Thibault Delavallée <tde@odoo.com>

5 files changed, 595 insertions, 0 deletions

diff --git a/addons/event_crm/models/__init__.py b/addons/event_crm/models/__init__.py
new file mode 100644
index 00000000000..1ddbf2c4d6b
--- /dev/null
+++ b/addons/event_crm/models/__init__.py
@@ -0,0 +1,7 @@
+# -*- coding: utf-8 -*-
+# Part of Odoo. See LICENSE file for full copyright and licensing details.
+
+from . import event_lead_rule
+from . import event_registration
+from . import crm_lead
+from . import event_event
diff --git a/addons/event_crm/models/crm_lead.py b/addons/event_crm/models/crm_lead.py
new file mode 100644
index 00000000000..e51aadc104f
--- /dev/null
+++ b/addons/event_crm/models/crm_lead.py
@@ -0,0 +1,24 @@
+# -*- coding: utf-8 -*-
+# Part of Odoo. See LICENSE file for full copyright and licensing details.
+
+from odoo import fields, models, api
+
+
+class Lead(models.Model):
+    _inherit = 'crm.lead'
+
+    event_lead_rule_id = fields.Many2one('event.lead.rule', string="Registration Rule", help="Rule that created this lead")
+    event_id = fields.Many2one('event.event', string="Source Event", help="Event triggering the rule that created this lead")
+    registration_ids = fields.Many2many(
+        'event.registration', string="Source Registrations",
+        groups='event.group_event_user',
+        help="Registrations triggering the rule that created this lead")
+    registration_count = fields.Integer(
+        string="# Registrations", compute='_compute_registration_count',
+        groups='event.group_event_user',
+        help="Counter for the registrations linked to this lead")
+
+    @api.depends('registration_ids')
+    def _compute_registration_count(self):
+        for record in self:
+            record.registration_count = len(record.registration_ids)
diff --git a/addons/event_crm/models/event_event.py b/addons/event_crm/models/event_event.py
new file mode 100644
index 00000000000..ac71958cd93
--- /dev/null
+++ b/addons/event_crm/models/event_event.py
@@ -0,0 +1,26 @@
+# -*- coding: utf-8 -*-
+# Part of Odoo. See LICENSE file for full copyright and licensing details.
+
+from odoo import fields, models, api
+
+
+class EventEvent(models.Model):
+    _name = "event.event"
+    _inherit = "event.event"
+
+    lead_ids = fields.One2many(
+        'crm.lead', 'event_id', string="Leads", groups='sales_team.group_sale_salesman',
+        help="Leads generated from this event")
+    lead_count = fields.Integer(
+        string="# Leads", compute='_compute_lead_count', groups='sales_team.group_sale_salesman',
+        help="Counter for the leads linked to this event")
+
+    @api.depends('lead_ids')
+    def _compute_lead_count(self):
+        lead_data = self.env['crm.lead'].read_group(
+            [('event_id', 'in', self.ids)],
+            ['event_id'], ['event_id']
+        )
+        mapped_data = {item['event_id'][0]: item['event_id_count'] for item in lead_data}
+        for event in self:
+            event.lead_count = mapped_data.get(event.id, 0)
diff --git a/addons/event_crm/models/event_lead_rule.py b/addons/event_crm/models/event_lead_rule.py
new file mode 100644
index 00000000000..47c425fef26
--- /dev/null
+++ b/addons/event_crm/models/event_lead_rule.py
@@ -0,0 +1,218 @@
+# -*- coding: utf-8 -*-
+# Part of Odoo. See LICENSE file for full copyright and licensing details.
+
+from ast import literal_eval
+from collections import defaultdict
+
+from odoo import fields, models, _
+from odoo.osv import expression
+
+
+class EventLeadRule(models.Model):
+    """ Rule model for creating / updating leads from event registrations.
+
+    SPECIFICATIONS: CREATION TYPE
+
+    There are two types of lead creation:
+
+      * per attendee: create a lead for each registration;
+      * per order: create a lead for a group of registrations;
+
+    The last one is only available through interface if it is possible to register
+    a group of attendees in one action (when event_sale or website_event are
+    installed). Behavior itself is implemented directly in event_crm.
+
+    Basically a group is either a list of registrations belonging to the same
+    event and created in batch (website_event flow). With event_sale this
+    definition will be improved to be based on sale_order.
+
+    SPECIFICATIONS: CREATION TRIGGERS
+
+    There are three options to trigger lead creation. We consider basically that
+    lead quality increases if attendees confirmed or went to the event. Triggers
+    allow therefore to run rules:
+
+      * at attendee creation;
+      * at attendee confirmation;
+      * at attendee venue;
+
+    This trigger defines when the rule will run.
+
+    SPECIFICATIONS: FILTERING REGISTRATIONS
+
+    When a batch of registrations matches the rule trigger we filter them based
+    on conditions and rules defines on event_lead_rule model. Heuristic is the
+    following:
+
+      * the rule is active;
+      * if a filter is set: filter registrations based on this filter. This is
+        done like a search, and filter is a domain;
+      * if a company is set on the rule, it must match event's company. Note
+        that multi-company rules apply on event_lead_rule;
+      * if an event category it set, it must match;
+      * if an event is set, it must match;
+      * if both event and category are set, one of them must match (OR). If none
+        of those are set, it is considered as OK;
+
+    If conditions are met, leads are created with pre-filled informations defined
+    on the rule (type, user_id, team_id). Contact information coming from the
+    registrations are computed (customer, name, email, phone, mobile, contact_name).
+
+    SPECIFICATIONS: OTHER POINTS
+
+    Note that all rules matching their conditions are applied. This means more
+    than one lead can be created depending on the configuration. This is
+    intended in order to give more freedom to the user using the automatic
+    lead generation.
+    """
+    _name = "event.lead.rule"
+    _description = "Event Lead Rules"
+
+    # Definition
+    name = fields.Char('Rule Name', required=True, translate=True)
+    active = fields.Boolean('Active', default=True)
+    lead_ids = fields.One2many(
+        'crm.lead', 'event_lead_rule_id', string='Created Leads',
+        groups='sales_team.group_sale_salesman')
+    # Triggers
+    lead_creation_basis = fields.Selection([
+        ('attendee', 'Per Attendee'), ('order', 'Per Order')],
+        string='Create', default='attendee', required=True,
+        help='Per Attendee : A Lead is created for each Attendee (B2C).\n'
+             'Per Order : A single Lead is created per Ticket Batch/Sale Order (B2B)')
+    lead_creation_trigger = fields.Selection([
+        ('create', 'Attendees are created'),
+        ('confirm', 'Attendees are confirmed'),
+        ('done', 'Attendees attended')],
+        string='When', default='create', required=True,
+        help='Creation: at attendee creation;\n'
+             'Confirmation: when attendee is confirmed, manually or automatically;\n'
+             'Attended: when attendance is confirmed and registration set to done;')
+    # Filters
+    event_type_ids = fields.Many2many(
+        'event.type', string='Event Categories',
+        help='Filter the attendees to include those of this specific event category. If not set, no event category restriction will be applied.')
+    event_id = fields.Many2one(
+        'event.event', string='Event',
+        domain="[('company_id', 'in', [company_id or current_company_id, False])]",
+        help='Filter the attendees to include those of this specific event. If not set, no event restriction will be applied.')
+    company_id = fields.Many2one(
+        'res.company', string='Company',
+        help="Restrict the trigger of this rule to events belonging to a specific company.\nIf not set, no company restriction will be applied.")
+    event_registration_filter = fields.Text(string="Registrations Domain", help="Filter the attendees that will or not generate leads.")
+    # Lead default_value fields
+    lead_type = fields.Selection([
+        ('lead', 'Lead'), ('opportunity', 'Opportunity')], string="Lead Type", required=True,
+        default=lambda self: 'lead' if self.env['res.users'].has_group('crm.group_use_lead') else 'opportunity',
+        help="Default lead type when this rule is applied.")
+    lead_sales_team_id = fields.Many2one('crm.team', string='Sales Team', help="Automatically assign the created leads to this Sales Team.")
+    lead_user_id = fields.Many2one('res.users', string='Salesperson', help="Automatically assign the created leads to this Salesperson.")
+    lead_tag_ids = fields.Many2many('crm.tag', string='Tags', help="Automatically add these tags to the created leads.")
+
+    def _run_on_registrations(self, registrations):
+        """ Create or update leads based on rule configuration. Two main lead
+        management type exists
+
+          * per attendee: each registration creates a lead;
+          * per order: registrations are grouped per group and one lead is created
+            or updated with the batch (used mainly with sale order configuration
+            in event_sale);
+
+        Heuristic
+
+          * first, check existing lead linked to registrations to ensure no
+            duplication. Indeed for example attendee status change may trigger
+            the same rule several times;
+          * then for each rule, get the subset of registrations matching its
+            filters;
+          * then for each order-based rule, get the grouping information. This
+            give a list of registrations by group (event, sale_order), with maybe
+            an already-existing lead to update instead of creating a new one;
+          * finally apply rules. Attendee-based rules create a lead for each
+            attendee, group-based rules use the grouping information to create
+            or update leads;
+
+        :param registrations: event.registration recordset on which rules given by
+          self have to run. Triggers should already be checked, only filters are
+          applied here.
+
+        :return leads: newly-created leads. Updated leads are not returned.
+        """
+        # order by ID, ensure first created wins
+        registrations = registrations.sorted('id')
+
+        # first: ensure no duplicate by searching existing registrations / rule
+        existing_leads = self.env['crm.lead'].search([
+            ('registration_ids', 'in', registrations.ids),
+            ('event_lead_rule_id', 'in', self.ids)
+        ])
+        rule_to_existing_regs = defaultdict(lambda: self.env['event.registration'])
+        for lead in existing_leads:
+            rule_to_existing_regs[lead.event_lead_rule_id] += lead.registration_ids
+
+        # second: check registrations matching rules (in batch)
+        new_registrations = self.env['event.registration']
+        rule_to_new_regs = dict()
+        for rule in self:
+            new_for_rule = registrations.filtered(lambda reg: reg not in rule_to_existing_regs[rule])
+            rule_registrations = rule._filter_registrations(new_for_rule)
+            new_registrations |= rule_registrations
+            rule_to_new_regs[rule] = rule_registrations
+        new_registrations.sorted('id')  # as an OR was used, re-ensure order
+
+        # third: check grouping
+        order_based_rules = self.filtered(lambda rule: rule.lead_creation_basis == 'order')
+        rule_group_info = new_registrations._get_lead_grouping(order_based_rules, rule_to_new_regs)
+
+        lead_vals_list = []
+        for rule in self:
+            if rule.lead_creation_basis == 'attendee':
+                matching_registrations = rule_to_new_regs[rule].sorted('id')
+                for registration in matching_registrations:
+                    lead_vals_list.append(registration._get_lead_values(rule))
+            else:
+                # check if registrations are part of a group, for example a sale order, to know if we update or create leads
+                for (toupdate_leads, group_key, group_registrations) in rule_group_info[rule]:
+                    if toupdate_leads:
+                        additionnal_description = group_registrations._get_lead_description(_("New registrations"), line_counter=True)
+                        for lead in toupdate_leads:
+                            lead.write({
+                                'description': "%s\n%s" % (lead.description, additionnal_description),
+                                'registration_ids': [(4, reg.id) for reg in group_registrations],
+                            })
+                    else:
+                        lead_vals_list.append(group_registrations._get_lead_values(rule))
+
+        return self.env['crm.lead'].create(lead_vals_list)
+
+    def _filter_registrations(self, registrations):
+        """ Keep registrations matching rule conditions. Those are
+
+          * if a filter is set: filter registrations based on this filter. This is
+            done like a search, and filter is a domain;
+          * if a company is set on the rule, it must match event's company. Note
+            that multi-company rules apply on event_lead_rule;
+          * if an event category it set, it must match;
+          * if an event is set, it must match;
+          * if both event and category are set, one of them must match (OR). If none
+            of those are set, it is considered as OK;
+
+        :param registrations: event.registration recordset on which rule filters
+          will be evaluated;
+        :return: subset of registrations matching rules
+        """
+        self.ensure_one()
+        if self.event_registration_filter and self.event_registration_filter != '[]':
+            registrations = registrations.search(expression.AND([
+                [('id', 'in', registrations.ids)],
+                literal_eval(self.event_registration_filter)
+            ]))
+
+        # check from direct m2o to linked m2o / o2m to filter first without inner search
+        company_ok = lambda registration: registration.company_id == self.company_id if self.company_id else True
+        event_or_event_type_ok = \
+            lambda registration: \
+                registration.event_id == self.event_id or registration.event_id.event_type_id in self.event_type_ids \
+                if (self.event_id or self.event_type_ids) else True
+
+        return registrations.filtered(lambda r: company_ok(r) and event_or_event_type_ok(r))
diff --git a/addons/event_crm/models/event_registration.py b/addons/event_crm/models/event_registration.py
new file mode 100644
index 00000000000..7ca4765b4ec
--- /dev/null
+++ b/addons/event_crm/models/event_registration.py
@@ -0,0 +1,320 @@
+# -*- 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, _
+
+
+class EventRegistration(models.Model):
+    _inherit = 'event.registration'
+
+    lead_ids = fields.Many2many(
+        'crm.lead', string='Leads', copy=False, readonly=True,
+        groups='sales_team.group_sale_salesman',
+        help="Leads generated from the registration.")
+    lead_count = fields.Integer(
+        '# Leads', compute='_compute_lead_count', groups='sales_team.group_sale_salesman',
+        help="Counter for the leads linked to this registration")
+
+    @api.depends('lead_ids')
+    def _compute_lead_count(self):
+        for record in self:
+            record.lead_count = len(record.lead_ids)
+
+    @api.model_create_multi
+    def create(self, vals_list):
+        """ Trigger rules based on registration creation, and check state for
+        rules based on confirmed / done attendees. """
+        registrations = super(EventRegistration, self).create(vals_list)
+        self.env['event.lead.rule'].search([('lead_creation_trigger', '=', 'create')]).sudo()._run_on_registrations(registrations)
+
+        # handle triggers based on creation, then those based on confirm and done
+        # as registrations can be automatically confirmed, or even created directly
+        # with a state given in values
+        open_registrations = registrations.filtered(lambda reg: reg.state == 'open')
+        if open_registrations:
+            self.env['event.lead.rule'].search([('lead_creation_trigger', '=', 'confirm')]).sudo()._run_on_registrations(open_registrations)
+        done_registrations = registrations.filtered(lambda reg: reg.state == 'done')
+        if done_registrations:
+            self.env['event.lead.rule'].search([('lead_creation_trigger', '=', 'done')]).sudo()._run_on_registrations(done_registrations)
+
+        return registrations
+
+    def write(self, vals):
+        """ Update the lead values depending on fields updated in registrations.
+        There are 2 main use cases
+
+          * first is when we update the partner_id of multiple registrations. It
+            happens when a public user fill its information when he register to
+            an event;
+          * second is when we update specific values of one registration like
+            updating question answers or a contact information (email, phone);
+
+        Also trigger rules based on confirmed and done attendees (state written
+        to open and done).
+        """
+        to_update = self.filtered(lambda reg: reg.lead_ids)
+        if to_update:
+            lead_tracked_vals = to_update._get_lead_tracked_values()
+
+        res = super(EventRegistration, self).write(vals)
+
+        if to_update:
+            to_update.flush()  # compute notably partner-based fields if necessary
+            to_update.sudo()._update_leads(vals, lead_tracked_vals)
+
+        # handle triggers based on state
+        if vals.get('state') == 'open':
+            self.env['event.lead.rule'].search([('lead_creation_trigger', '=', 'confirm')]).sudo()._run_on_registrations(self)
+        elif vals.get('state') == 'done':
+            self.env['event.lead.rule'].search([('lead_creation_trigger', '=', 'done')]).sudo()._run_on_registrations(self)
+
+        return res
+
+    def _update_leads(self, new_vals, lead_tracked_vals):
+        """ Update leads linked to some registrations. Update is based depending
+        on updated fields, see ``_get_lead_contact_fields()`` and ``_get_lead_
+        description_fields()``. Main heuristic is
+
+          * check attendee-based leads, for each registration recompute contact
+            information if necessary (changing partner triggers the whole contact
+            computation); update description if necessary;
+          * check order-based leads, for each existing group-based lead, only
+            partner change triggers a contact and description update. We consider
+            that group-based rule works mainly with the main contact and less
+            with further details of registrations. Those can be found in stat
+            button if necessary.
+
+        :param new_vals: values given to write. Used to determine updated fields;
+        :param lead_tracked_vals: dict(registration_id, registration previous values)
+          based on new_vals;
+        """
+        for registration in self:
+            leads_attendee = registration.lead_ids.filtered(
+                lambda lead: lead.event_lead_rule_id.lead_creation_basis == 'attendee'
+            )
+            if not leads_attendee:
+                continue
+
+            old_vals = lead_tracked_vals[registration.id]
+            # if partner has been updated -> update registration contact information
+            # as they are computed (and therefore not given to write values)
+            if 'partner_id' in new_vals:
+                new_vals.update(**dict(
+                    (field, registration[field])
+                    for field in self._get_lead_contact_fields()
+                    if field != 'partner_id')
+                )
+
+            lead_values = {}
+            # update contact fields: valid for all leads of registration
+            upd_contact_fields = [field for field in self._get_lead_contact_fields() if field in new_vals.keys()]
+            if any(new_vals[field] != old_vals[field] for field in upd_contact_fields):
+                lead_values = registration._get_lead_contact_values()
+
+            # update description fields: each lead has to be updated, otherwise
+            # update in batch
+            upd_description_fields = [field for field in self._get_lead_description_fields() if field in new_vals.keys()]
+            if any(new_vals[field] != old_vals[field] for field in upd_description_fields):
+                for lead in leads_attendee:
+                    lead_values['description'] = "%s\n%s" % (
+                        lead.description,
+                        registration._get_lead_description(_("Updated registrations"), line_counter=True)
+                    )
+                    lead.write(lead_values)
+            elif lead_values:
+                leads_attendee.write(lead_values)
+
+        leads_order = self.lead_ids.filtered(lambda lead: lead.event_lead_rule_id.lead_creation_basis == 'order')
+        for lead in leads_order:
+            lead_values = {}
+            if new_vals.get('partner_id'):
+                lead_values.update(lead.registration_ids._get_lead_contact_values())
+                if not lead.partner_id:
+                    lead_values['description'] = lead.registration_ids._get_lead_description(_("Participants"), line_counter=True)
+                elif new_vals['partner_id'] != lead.partner_id.id:
+                    lead_values['description'] = lead.description + "\n" + lead.registration_ids._get_lead_description(_("Updated registrations"), line_counter=True, line_suffix=_("(updated)"))
+            if lead_values:
+                lead.write(lead_values)
+
+    def _get_lead_values(self, rule):
+        """ Get lead values from registrations. Self can contain multiple records
+        in which case first found non void value is taken. Note that all
+        registrations should belong to the same event.
+
+        :return dict lead_values: values used for create / write on a lead
+        """
+        lead_values = {
+            # from rule
+            'type': rule.lead_type,
+            'user_id': rule.lead_user_id.id,
+            'team_id': rule.lead_sales_team_id.id,
+            'tag_ids': rule.lead_tag_ids.ids,
+            'event_lead_rule_id': rule.id,
+            # event and registration
+            'event_id': self.event_id.id,
+            'referred': self.event_id.name,
+            'registration_ids': self.ids,
+            'campaign_id': self._find_first_notnull('utm_campaign_id'),
+            'source_id': self._find_first_notnull('utm_source_id'),
+            'medium_id': self._find_first_notnull('utm_medium_id'),
+        }
+        lead_values.update(self._get_lead_contact_values())
+        lead_values['description'] = self._get_lead_description(_("Participants"), line_counter=True)
+        return lead_values
+
+    def _get_lead_contact_values(self):
+        """ Specific management of contact values. Rule creation basis has some
+        effect on contact management
+
+          * in attendee mode: keep registration partner only if partner phone and
+            email match. Indeed lead are synchronized with their contact and it
+            would imply rewriting on partner, and therefore on other documents;
+          * in batch mode: if a customer is found use it as main contact. Registrations
+            details are included in lead description;
+
+        :return dict: values used for create / write on a lead
+        """
+        valid_partner = related_partner = next(
+            (reg.partner_id for reg in self if reg.partner_id != self.env.ref('base.public_partner')),
+            self.env['res.partner']
+        )  # CHECKME: broader than just public partner
+
+        # mono registration mode: keep partner only if email and phone matches, otherwise registration > partner
+        if len(self) == 1:
+            if (related_partner.phone and self.phone and related_partner.phone != self.phone) or \
+                (related_partner.email and self.email and related_partner.email != self.email):
+                valid_partner = self.env['res.partner']
+
+        if valid_partner:
+            contact_vals = self.env['crm.lead']._prepare_values_from_partner(valid_partner)
+            # force email_from / phone only if not set on partner because those fields are now synchronized automatically
+            if not valid_partner.email:
+                contact_vals['email_from'] = self._find_first_notnull('email')
+            if not valid_partner.phone:
+                contact_vals['email_from'] = self._find_first_notnull('phone')
+        else:
+            # don't force email_from + partner_id because those fields are now synchronized automatically
+            contact_vals = {
+                'contact_name': self._find_first_notnull('name'),
+                'email_from': self._find_first_notnull('email'),
+                'phone': self._find_first_notnull('phone'),
+            }
+        contact_vals.update({
+            'name': "%s - %s" % (self.event_id.name, valid_partner.name or self._find_first_notnull('name') or self._find_first_notnull('email')),
+            'partner_id': valid_partner.id,
+            'mobile': valid_partner.mobile or self._find_first_notnull('mobile'),
+        })
+        return contact_vals
+
+    def _get_lead_description(self, prefix='', line_counter=True, line_suffix=''):
+        """ Build the description for the lead using a prefix for all generated
+        lines. For example to enumerate participants or inform of an update in
+        the information of a participant.
+
+        :return string description: complete description for a lead taking into
+          account all registrations contained in self
+        """
+        reg_lines = [
+            registration._get_lead_description_registration(
+                prefix="%s. " % (index + 1) if line_counter else "",
+                line_suffix=line_suffix
+            ) for index, registration in enumerate(self)
+        ]
+        return ("%s\n" % prefix if prefix else "") + ("\n".join(reg_lines))
+
+    def _get_lead_description_registration(self, prefix='', line_suffix=''):
+        """ Build the description line specific to a given registration. """
+        self.ensure_one()
+        return "%s%s (%s)%s" % (
+            prefix or "",
+            self.name or self.partner_id.name or self.email,
+            " - ".join(self[field] for field in ('email', 'phone') if self[field]),
+            " %s" % line_suffix if line_suffix else "",
+        )
+
+    def _get_lead_tracked_values(self):
+        """ Tracked values are based on two subset of fields to track in order
+        to fill or update leads. Two main use cases are
+
+          * description fields: registration contact fields: email, phone, ...
+            on registration. Other fields are added by inheritance like
+            question answers;
+          * contact fields: registration contact fields + partner_id field as
+            contact of a lead is managed specifically. Indeed email and phone
+            synchronization of lead / partner_id implies paying attention to
+            not rewrite partner values from registration values.
+
+        Tracked values are therefore the union of those two field sets. """
+        tracked_fields = list(set(self._get_lead_contact_fields()) or set(self._get_lead_description_fields()))
+        return dict(
+            (registration.id,
+             dict((field, self._convert_value(registration[field], field)) for field in tracked_fields)
+            ) for registration in self
+        )
+
+    def _get_lead_grouping(self, rules, rule_to_new_regs):
+        """ Perform grouping of registrations in order to enable order-based
+        lead creation and update existing groups with new registrations.
+
+        Heuristic in event is the following. Registrations created in multi-mode
+        are grouped by event. Customer use case: website_event flow creates
+        several registrations in a create-multi.
+
+        Update is not supported as there is no way to determine if a registration
+        is part of an existing batch.
+
+        :param rules: lead creation rules to run on registrations given by self;
+        :param rule_to_new_regs: dict: for each rule, subset of self matching
+          rule conditions. Used to speedup batch computation;
+
+        :return dict: for each rule, rule (key of dict) gives a list of groups.
+          Each group is a tuple (
+            existing_lead: existing lead to update;
+            group_record: record used to group;
+            registrations: sub record set of self, containing registrations
+                           belonging to the same group;
+          )
+        """
+        event_to_reg_ids = defaultdict(lambda: self.env['event.registration'])
+        for registration in self:
+            event_to_reg_ids[registration.event_id] += registration
+
+        return dict(
+            (rule, [(False, event, (registrations & rule_to_new_regs[rule]).sorted('id'))
+                    for event, registrations in event_to_reg_ids.items()])
+            for rule in rules
+        )
+
+    # ------------------------------------------------------------
+    # TOOLS
+    # ------------------------------------------------------------
+
+    @api.model
+    def _get_lead_contact_fields(self):
+        """ Get registration fields linked to lead contact. Those are used notably
+        to see if an update of lead is necessary or to fill contact values
+        in ``_get_lead_contact_values())`` """
+        return ['name', 'email', 'phone', 'mobile', 'partner_id']
+
+    @api.model
+    def _get_lead_description_fields(self):
+        """ Get registration fields linked to lead description. Those are used
+        notablyto see if an update of lead is necessary or to fill description
+        in ``_get_lead_description())`` """
+        return ['name', 'email', 'phone']
+
+    def _find_first_notnull(self, field_name):
+        """ Small tool to extract the first not nullvalue of a field: its value
+        or the ids if this is a relational field. """
+        value = next((reg[field_name] for reg in self if reg[field_name]), False)
+        return self._convert_value(value, field_name)
+
+    def _convert_value(self, value, field_name):
+        """ Small tool because convert_to_write is touchy """
+        if value and self._fields[field_name].type in ['many2many', 'one2many']:
+            return value.ids
+        if value and self._fields[field_name].type == 'many2one':
+            return value.id
+        return value