[REF] sms: refactor message_post using SMS notifications

Purpose of this commit is to better include SMS notifications when posting a
message. SMS is now just another way of notifying people along with Inbox and
email. Following recent mail merge improving notification mechanism [1] we
have to define a _notify_record_by_sms method on mail.thread.

When a message_post is done using message_type being ``sms`` notification type
of customers is set to sms. Customers can be computed on model (generally based
on partner_id field) or directly set usign partner°ids. Notification model is
updated to store this information directly inside the notification itself.

An new ``_message_sms`` helper method is introduced in SMS module allowing
to send messages using sms type and notification with a reduced parameters
number. It is just a shortcut to message_post, easier to use. Either it
computes default recipients on the record set, either it is based on given
partners and numbers to notify.

The following use cases are notably supported

  * default computation: find customer, notify by sms;
  * force recipients to notify by sms (partner_ids);
  * give a set of numbers to notify by sms (sms_nubmers), not necessarily
    linked to existing partners;
  * force number / customer relationship independently of mobile number defined
    on customer (for example when sending an SMS directly from a mobile field
    on a lead linked to a customer);

Tests are updated accordingly. Performance tests are added in order to have
some insights on queries generated when sending SMS, like already done for
mail.thread alone.

Related to task 1922163
Linked to PR #33510

[1] see be27955136: performance and notification code improvements

Co-Authored-By: Thibault Delavallee <tde@odoo.com>
Co-Authored-By: Pierre Rousseau <pro@odoo.com>

addons/calendar_sms/models/calendar.py

@@ -11,7 +11,7 @@ _logger = logging.getLogger(__name__)
 class CalendarEvent(models.Model):
     _inherit = 'calendar.event'
 
-    def _get_default_sms_recipients(self):
+    def _sms_get_default_partners(self):
         """ Method overriden from mail.thread (defined in the sms module).
             SMS text messages will be sent to attendees that haven't declined the event(s).
         """
@@ -21,8 +21,7 @@ class CalendarEvent(models.Model):
         """ Send an SMS text reminder to attendees that haven't declined the event """
         for event in self:
             sms_msg = _("Event reminder: %s on %s.") % (event.name, event.start_datetime or event.start_date)
-            note_msg = _('SMS text message reminder sent !')
-            event.message_post_send_sms(sms_msg, note_msg=note_msg)
+            event._message_sms(sms_msg)
 
 
 class CalendarAlarm(models.Model):

addons/mail/models/mail_notification.py

@@ -42,7 +42,7 @@ class Notification(models.Model):
     _sql_constraints = [
         # email notification;: partner is required
         ('notification_partner_required',
-            "CHECK(notification_type in ('email', 'inbox') AND res_partner_id IS NOT NULL)",
+            "CHECK(notification_type NOT IN ('email', 'inbox') OR res_partner_id IS NOT NULL)",
             'Customer is required for inbox / email notification'),
     ]
 

addons/phone_validation/tools/phone_validation.py

@@ -77,51 +77,43 @@ except ImportError:
 
 
 def phone_sanitize_numbers(numbers, country_code, country_phone_code, force_format='E164'):
-    valid, invalid, void_count = [], [], 0
+    result = dict.fromkeys(numbers, False)
     for number in numbers:
         if not number:
-            void_count += 1
+            result[number] = {'sanitized': False, 'code': 'empty', 'msg': False}
             continue
         try:
             sanitized = phone_format(
                 number, country_code, country_phone_code,
                 force_format=force_format, raise_exception=True)
         except Exception as e:
-            invalid.append(number)
+            result[number] = {'sanitized': False, 'code': 'invalid', 'msg': e}
         else:
-            valid.append(sanitized)
-    return valid, invalid, void_count
+            result[number] = {'sanitized': sanitized, 'code': False, 'msg': False}
+    return result
 
 
-def phone_sanitize_numbers_w_record(numbers, country_code, country_phone_code, record, record_country_fname='country_id', force_format='E164'):
-    if not country_code or not country_phone_code:
-        country = False
-        if record and record_country_fname in record and record[record_country_fname]:
+def phone_sanitize_numbers_w_record(numbers, record, country=False, record_country_fname='country_id', force_format='E164'):
+    if not country:
+        if record and hasattr(record, record_country_fname) and record[record_country_fname]:
             country = record[record_country_fname]
         elif record:
             country = record.env.company.country_id
-        if country:
-            country_code = country_code if country_code else country.code
-            country_phone_code = country_phone_code if country_phone_code else country.phone_code
+    country_code = country.code if country else None
+    country_phone_code = country.phone_code if country else None
     return phone_sanitize_numbers(numbers, country_code, country_phone_code, force_format=force_format)
 
 
-def phone_sanitize_numbers_string_w_record(numbers_str, country_code, country_phone_code, record, record_country_fname='country_id', force_format='E164'):
+def phone_sanitize_numbers_string_w_record(numbers_str, record, country=False, record_country_fname='country_id', force_format='E164'):
     found_numbers = [number.strip() for number in numbers_str.split(',')]
-    return phone_sanitize_numbers_w_record(found_numbers, country_code, country_phone_code, record, record_country_fname, force_format=force_format)
+    return phone_sanitize_numbers_w_record(found_numbers, record, country=country, record_country_fname=record_country_fname, force_format=force_format)
 
 
 def phone_get_sanitized_records_number(records, number_fname='mobile', country_fname='country_id', force_format='E164'):
     res = dict.fromkeys(records.ids, False)
     for record in records:
         number = record[number_fname]
-        valid, invalid, void_count = phone_sanitize_numbers_w_record([number], None, None, records, country_fname,force_format=force_format)
-        if valid:
-            res[record.id] = valid[0]
-        elif void_count:
-            res[record.id] = False
-        else:
-            res[record.id] = False
+        res[record.id] = phone_sanitize_numbers_w_record([number], records, record_country_fname=country_fname,force_format=force_format)[number]['sanitized']
     return res
 
 

addons/sms/__manifest__.py

@@ -12,10 +12,13 @@ The service is provided by the In App Purchase Odoo platform.
 """,
     'depends': ['base', 'iap', 'mail', 'phone_validation'],
     'data': [
+        'data/ir_cron_data.xml',
         'wizard/sms_composer_views.xml',
         'views/res_config_settings_views.xml',
         'views/res_partner_views.xml',
         'views/assets.xml',
+        'views/sms_sms_views.xml',
+        'security/ir.model.access.csv',
     ],
     'qweb': [
         'static/src/xml/sms_widget.xml',

addons/sms/data/ir_cron_data.xml

@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="utf-8"?>
+<odoo><data noupdate="1">
+    <record forcecreate="True" id="ir_cron_sms_scheduler_action" model="ir.cron">
+        <field name="name">SMS: SMS Queue Manager</field>
+        <field name="model_id" ref="model_sms_sms"/>
+        <field name="state">code</field>
+        <field name="code">model._process_queue()</field>
+        <field name="user_id" ref="base.user_root"/>
+        <field name="interval_number">1</field>
+        <field name="interval_type">hours</field>
+        <field name="numbercall">-1</field>
+        <field eval="False" name="doall"/>
+    </record>
+</data></odoo>

addons/sms/models/__init__.py

@@ -1,6 +1,10 @@
 # -*- coding: utf-8 -*-
 # Part of Odoo. See LICENSE file for full copyright and licensing details.
 
+from . import mail_followers
+from . import mail_message
+from . import mail_notification
 from . import mail_thread
 from . import res_partner
 from . import sms_api
+from . import sms_sms

addons/sms/models/mail_followers.py

@@ -0,0 +1,24 @@
+# -*- coding: utf-8 -*-
+# Part of Odoo. See LICENSE file for full copyright and licensing details.
+
+from odoo import api, fields, models
+
+
+class Followers(models.Model):
+    _inherit = ['mail.followers']
+
+    def _get_recipient_data(self, records, message_type, subtype_id, pids=None, cids=None):
+        if message_type == 'sms':
+            if pids is None:
+                sms_pids = records._sms_get_default_partners().ids
+            else:
+                sms_pids = pids
+            res = super(Followers, self)._get_recipient_data(records, message_type, subtype_id, pids=pids, cids=cids)
+            new_res = []
+            for pid, cid, pactive, pshare, ctype, notif, groups in res:
+                if pid and pid in sms_pids:
+                    notif = 'sms'
+                new_res.append((pid, cid, pactive, pshare, ctype, notif, groups))
+            return new_res
+        else:
+            return super(Followers, self)._get_recipient_data(records, message_type, subtype_id, pids=pids, cids=cids)

addons/sms/models/mail_message.py

@@ -0,0 +1,13 @@
+# -*- coding: utf-8 -*-
+# Part of Odoo. See LICENSE file for full copyright and licensing details.
+
+from odoo import api, fields, models
+
+
+class MailMessage(models.Model):
+    """ Override MailMessage class in order to add a new type: SMS messages.
+    Those messages comes with their own notification method, using SMS
+    gateway. """
+    _inherit = 'mail.message'
+
+    message_type = fields.Selection(selection_add=[('sms', 'SMS')])

addons/sms/models/mail_notification.py

@@ -0,0 +1,18 @@
+# -*- coding: utf-8 -*-
+
+from odoo import api, fields, models
+from odoo.tools.translate import _
+
+
+class Notification(models.Model):
+    _inherit = 'mail.notification'
+
+    notification_type = fields.Selection(selection_add=[('sms', 'SMS')])
+    sms_id = fields.Many2one('sms.sms', string='SMS', index=True, ondelete='set null')
+    sms_number = fields.Char('SMS Number')
+    failure_type = fields.Selection(selection_add=[
+        ('sms_number_missing', 'Missing Number'),
+        ('sms_number_format', 'Wrong Number Format'),
+        ('sms_credit', 'Insufficient Credit'),
+        ('sms_server', 'Server Error')]
+    )

addons/sms/models/mail_thread.py

@@ -3,9 +3,9 @@
 
 import logging
 
-from odoo import models, _
-
-from odoo.addons.iap.models.iap import InsufficientCreditError
+from odoo import api, models
+from odoo.addons.phone_validation.tools import phone_validation
+from odoo.tools import html2plaintext
 
 _logger = logging.getLogger(__name__)
 
@@ -13,7 +13,7 @@ _logger = logging.getLogger(__name__)
 class MailThread(models.AbstractModel):
     _inherit = 'mail.thread'
 
-    def _get_default_sms_recipients(self):
+    def _sms_get_default_partners(self):
         """ This method will likely need to be overriden by inherited models.
                :returns partners: recordset of res.partner
         """
@@ -24,36 +24,210 @@ class MailThread(models.AbstractModel):
             partners |= self.mapped('partner_ids')
         return partners
 
-    def message_post_send_sms(self, sms_message, numbers=None, partners=None, note_msg=None, log_error=False):
-        """ Send an SMS text message and post an internal note in the chatter if successfull
-            :param sms_message: plaintext message to send by sms
-            :param partners: the numbers to send to, if none are given it will take those
-                                from partners or _get_default_sms_recipients
-            :param partners: the recipients partners, if none are given it will take those
-                                from _get_default_sms_recipients, this argument
-                                is ignored if numbers is defined
-            :param note_msg: message to log in the chatter, if none is given a default one
-                             containing the sms_message is logged
+    def _sms_get_number_fields(self):
+        """ This method returns the fields to use to find the number to use to
+        send an SMS on a record. """
+        return ['mobile']
+
+    def _sms_get_recipients_info(self, force_field=False):
+        """" Get SMS recipient information on current record set. This method
+        checks for numbers and sanitation in order to centralize computation.
+
+        Example of use cases
+
+          * click on a field -> number is actually forced from field, find customer
+            linked to record, force its number to field or fallback on customer fields;
+          * contact -> find numbers from all possible phone fields on record, find
+            customer, force its number to found field number or fallback on customer fields;
+
+        :return dict: record.id: {
+            'partner': a res.partner recordset that is the customer (void or singleton);
+            'sanitized': sanitized number to use (coming from record's field or partner's mobile
+              or phone). Set to False is number impossible to parse and format;
+            'number': original number before sanitation;
+        } for each record in self
         """
-        if not numbers:
-            if not partners:
-                partners = self._get_default_sms_recipients()
+        result = dict.fromkeys(self.ids, False)
+        number_fields = self._sms_get_number_fields()
+        for record in self:
+            tocheck_fields = [force_field] if force_field else number_fields
+            all_numbers = [record[fname] for fname in tocheck_fields if fname in record]
+            all_partners = record._sms_get_default_partners()
 
-            # Collect numbers, we will consider the message to be sent if at least one number can be found
-            numbers = list(set([i.mobile for i in partners if i.mobile]))
+            valid_number = False
+            for fname in [f for f in tocheck_fields if f in record]:
+                valid_number = phone_validation.phone_get_sanitized_record_number(record, number_fname=fname)
+                if valid_number:
+                    break
 
-        if numbers:
-            try:
-                self.env['sms.api']._send_sms(numbers, sms_message)
-                mail_message = note_msg or _('SMS message sent: %s') % sms_message
+            if valid_number:
+                result[record.id] = {
+                    'partner': all_partners[0] if all_partners else self.env['res.partner'],
+                    'sanitized': valid_number, 'number': valid_number,
+                }
+            elif all_partners:
+                partner_number, partner = False, self.env['res.partner']
+                for partner in all_partners:
+                    partner_number = partner.mobile or partner.phone
+                    if partner_number:
+                        partner_number = phone_validation.phone_sanitize_numbers_string_w_record(partner_number, record)[partner_number]['sanitized']
+                    if partner_number:
+                        break
 
-            except InsufficientCreditError as e:
-                if not log_error:
-                    raise e
-                mail_message = _('Insufficient credit, unable to send SMS message: %s') % sms_message
-        else:
-            mail_message = _('No mobile number defined, unable to send SMS message: %s') % sms_message
+                if partner_number:
+                    result[record.id] = {'partner': partner, 'sanitized': partner_number, 'number': partner_number}
+                else:
+                    result[record.id] = {'partner': partner, 'sanitized': False, 'number': partner.mobile or partner.phone}
+            elif all_numbers:
+                result[record.id] = {'partner': self.env['res.partner'], 'sanitized': False, 'number': all_numbers[0]}
+            else:
+                result[record.id] = {'partner': self.env['res.partner'], 'sanitized': False, 'number': False}
+        return result
 
-        for thread in self:
-            thread.message_post(body=mail_message)
-        return False
+    def _message_sms(self, body, subtype_id=False, partner_ids=False, number_field=False,
+                     sms_numbers=None, sms_pid_to_number=None, **kwargs):
+        """ Main method to post a message on a record using SMS-based notification
+        method.
+
+        :param body: content of SMS;
+        :param subtype_id: mail.message.subtype used in mail.message associated
+          to the sms notification process;
+        :param partner_ids: if set is a record set of partners to notify;
+        :param number_field: if set is a name of field to use on current record
+          to compute a number to notify;
+        :param sms_numbers: see ``_notify_record_by_sms``;
+        :param sms_pid_to_number: see ``_notify_record_by_sms``;
+        """
+        self.ensure_one()
+        sms_pid_to_number = sms_pid_to_number if sms_pid_to_number is not None else {}
+
+        if number_field or (partner_ids is False and sms_numbers is None):
+            info = self._sms_get_recipients_info(force_field=number_field)[self.id]
+            info_partner_ids = info['partner'].ids if info['partner'] else False
+            info_number = info['sanitized'] if info['sanitized'] else info['number']
+            if info_partner_ids and info_number:
+                sms_pid_to_number[info_partner_ids[0]] = info_number
+            if info_partner_ids:
+                partner_ids = info_partner_ids + (partner_ids or [])
+            if info_number and not info_partner_ids:
+                sms_numbers = [info_number] + (sms_numbers or [])
+
+        if subtype_id is False:
+            subtype_id = self.env['ir.model.data'].xmlid_to_res_id('mail.mt_comment')
+
+        return self.message_post(
+            body=body, partner_ids=partner_ids or [],  # TDE FIXME: temp fix otherwise crash mail_thread.py
+            message_type='sms', subtype_id=subtype_id,
+            sms_numbers=sms_numbers, sms_pid_to_number=sms_pid_to_number,
+            **kwargs
+        )
+
+    @api.multi
+    def _notify_thread(self, message, msg_vals=False, **kwargs):
+        recipients_data = super(MailThread, self)._notify_thread(message, msg_vals=msg_vals, **kwargs)
+        self._notify_record_by_sms(message, recipients_data, msg_vals=msg_vals, **kwargs)
+        return recipients_data
+
+    @api.multi
+    def _notify_record_by_sms(self, message, recipients_data, msg_vals=False,
+                              sms_numbers=None, sms_pid_to_number=None,
+                              check_existing=False, put_in_queue=False, **kwargs):
+        """ Notification method: by SMS.
+
+        :param message: mail.message record to notify;
+        :param recipients_data: see ``_notify_thread``;
+        :param msg_vals: see ``_notify_thread``;
+
+        :param sms_numbers: additional numbers to notify in addition to partners
+          and classic recipients;
+        :param pid_to_number: force a number to notify for a given partner ID
+              instead of taking its mobile / phone number;
+        :param check_existing: check for existing notifications to update based on
+          mailed recipient, otherwise create new notifications;
+        :param put_in_queue: use cron to send queued SMS instead of sending them
+          directly;
+        """
+        sms_pid_to_number = sms_pid_to_number if sms_pid_to_number is not None else {}
+        sms_numbers = sms_numbers if sms_numbers is not None else []
+        sms_create_vals = []
+        sms_all = self.env['sms.sms'].sudo()
+
+        # pre-compute SMS data
+        body = msg_vals['body'] if msg_vals and msg_vals.get('body') else message.body
+        sms_base_vals = {
+            'body': html2plaintext(body).rstrip('\n'),
+            'mail_message_id': message.id,
+            'state': 'outgoing',
+        }
+
+        # notify from computed recipients_data (followers, specific recipients)
+        partners_data = [r for r in recipients_data['partners'] if r['notif'] == 'sms']
+        partner_ids = [r['id'] for r in partners_data]
+        if partner_ids:
+            for partner in self.env['res.partner'].sudo().browse(partner_ids):
+                number = sms_pid_to_number.get(partner.id) or partner.mobile or partner.phone
+                sanitize_res = phone_validation.phone_sanitize_numbers_string_w_record(number, partner)[number]
+                number = sanitize_res['sanitized'] or number
+                sms_create_vals.append(dict(
+                    sms_base_vals,
+                    partner_id=partner.id,
+                    number=number
+                ))
+
+        # notify from additional numbers
+        if sms_numbers:
+            sanitized = phone_validation.phone_sanitize_numbers_w_record(sms_numbers, self)
+            tocreate_numbers = [
+                value['sanitized'] or original
+                for original, value in sanitized.items()
+                if value['code'] != 'empty'
+            ]
+            sms_create_vals += [dict(sms_base_vals, partner_id=False, number=n) for n in tocreate_numbers]
+
+        # create sms and notification
+        existing_pids, existing_numbers = [], []
+        if sms_create_vals:
+            sms_all |= self.env['sms.sms'].sudo().create(sms_create_vals)
+
+            if check_existing:
+                existing = self.env['mail.notification'].sudo().search([
+                    '|', ('res_partner_id', 'in', partner_ids),
+                    '&', ('res_partner_id', '=', False), ('sms_number', 'in', sms_numbers),
+                    ('notification_type', '=', 'sms'),
+                    ('mail_message_id', '=', message.id)
+                ])
+                for n in existing:
+                    if n.res_partner_id.id in partner_ids and n.mail_message_id == message:
+                        existing_pids.append(n.res_partner_id.id)
+                    if not n.res_partner_id and n.sms_number in sms_numbers and n.mail_message_id == message:
+                        existing_numbers.append(n.sms_number)
+
+            notif_create_values = [{
+                'mail_message_id': message.id,
+                'res_partner_id': sms.partner_id.id,
+                'sms_number': sms.number,
+                'notification_type': 'sms',
+                'sms_id': sms.id,
+                'is_read': True,  # discard Inbox notification
+                'notification_status': 'ready',
+            } for sms in sms_all if (sms.partner_id and sms.partner_id.id not in existing_pids) or (not sms.partner_id and sms.number not in existing_numbers)]
+            if notif_create_values:
+                self.env['mail.notification'].sudo().create(notif_create_values)
+
+            if existing_pids or existing_numbers:
+                for sms in sms_all:
+                    notif = next((n for n in existing if
+                                 (n.res_partner_id.id in existing_pids and n.res_partner_id.id == sms.partner_id.id) or
+                                 (not n.res_partner_id and n.sms_number in existing_numbers and n.sms_number == sms.number)), False)
+                    if notif:
+                        notif.write({
+                            'notification_type': 'sms',
+                            'notification_status': 'ready',
+                            'sms_id': sms.id,
+                            'sms_number': sms.number,
+                        })
+
+        if sms_all and not put_in_queue:
+            sms_all.send(auto_commit=False, raise_exception=False)
+
+        return True

addons/sms/models/res_partner.py

@@ -7,7 +7,7 @@ from odoo import models
 class ResPartner(models.Model):
     _inherit = 'res.partner'
 
-    def _get_default_sms_recipients(self):
+    def _sms_get_default_partners(self):
         """ Override of mail.thread method.
             SMS recipients on partners are the partners themselves.
         """

addons/sms/models/sms_sms.py

@@ -0,0 +1,137 @@
+# -*- coding: utf-8 -*-
+# Part of Odoo. See LICENSE file for full copyright and licensing details.
+
+import logging
+import threading
+
+from odoo import api, fields, models, tools
+
+_logger = logging.getLogger(__name__)
+
+
+class SmsSms(models.Model):
+    _name = 'sms.sms'
+    _description = 'Outgoing SMS'
+    _rec_name = 'number'
+
+    number = fields.Char('Number', required=True)
+    body = fields.Text()
+    partner_id = fields.Many2one('res.partner', 'Customer')
+    mail_message_id = fields.Many2one('mail.message', index=True)
+    state = fields.Selection([
+        ('outgoing', 'In Queue'),
+        ('sent', 'Sent'),
+        ('error', 'Error'),
+        ('canceled', 'Canceled')
+    ], 'SMS Status', readonly=True, copy=False, default='outgoing', required=True)
+    error_code = fields.Selection([
+        ('sms_number_missing', 'Missing Number'),
+        ('sms_number_format', 'Wrong Number Format'),
+        ('sms_credit', 'Insufficient Credit'),
+        ('sms_server', 'Server Error')
+    ])
+
+    @api.multi
+    def send(self, delete_all=False, auto_commit=False, raise_exception=False):
+        """ Main API method to send SMS.
+
+          :param delete_all: delete all SMS (sent or not); otherwise delete only
+            sent SMS;
+          :param auto_commit: commit after each batch of SMS;
+          :param raise_exception: raise if there is an issue contacting IAP;
+        """
+        for batch_ids in self._split_batch():
+            self.browse(batch_ids)._send(delete_all=delete_all, raise_exception=raise_exception)
+            if auto_commit is True:
+                self._cr.commit()
+
+    @api.model
+    def _process_queue(self, ids=None):
+        """ Send immediately queued messages, committing after each message is sent.
+        This is not transactional and should not be called during another transaction!
+
+       :param list ids: optional list of emails ids to send. If passed no search
+         is performed, and these ids are used instead.
+        """
+        domain = [('state', '=', 'outgoing')]
+
+        filtered_ids = self.search(domain, limit=10000).ids  # TDE note: arbitrary limit we might have to update
+        if ids:
+            ids = list(set(filtered_ids) & set(ids))
+        else:
+            ids = filtered_ids
+        ids.sort()
+
+        res = None
+        try:
+            # auto-commit except in testing mode
+            auto_commit = not getattr(threading.currentThread(), 'testing', False)
+            res = self.browse(ids).send(delete_all=False, auto_commit=auto_commit, raise_exception=False)
+        except Exception:
+            _logger.exception("Failed processing SMS queue")
+        return res
+
+    def _split_batch(self):
+        batch_size = int(self.env['ir.config_parameter'].sudo().get_param('sms.session.batch.size', 10))
+        for sms_batch in tools.split_every(batch_size, self.ids):
+            yield sms_batch
+
+    @api.multi
+    def _send(self, delete_all=False, raise_exception=False):
+        """ This method tries to send SMS after checking the number (presence and
+        formatting). """
+        iap_data = [{
+            'res_id': record.id,
+            'number': record.number,
+            'content': record.body,
+        } for record in self]
+
+        try:
+            iap_results = self.env['sms.api']._send_sms_batch(iap_data)
+        except Exception as e:
+            _logger.info('Sent batch %s SMS: %s: failed with exception %s', len(self.ids), self.ids, e)
+            if raise_exception:
+                raise
+            self._postprocess_sent_sms([{'res_id': sms.id, 'state': 'server_error'} for sms in self], delete_all=delete_all)
+        else:
+            _logger.info('Send batch %s SMS: %s: gave %s', len(self.ids), self.ids, iap_results)
+            self._postprocess_sent_sms(iap_results, delete_all=delete_all)
+
+    def _postprocess_sent_sms(self, iap_results, failure_reason=None, delete_all=False):
+        sms_to_notif_status = {
+            'success': False, 'insufficient_credit': 'sms_credit',
+            'wrong_format_number': 'sms_number_format', 'server_error': 'sms_server'}
+        if delete_all:
+            todelete_sms_ids = [item['res_id'] for item in iap_results]
+        else:
+            todelete_sms_ids = [item['res_id'] for item in iap_results if item['state'] == 'success']
+
+        for state in sms_to_notif_status.keys():
+            sms_ids = [item['res_id'] for item in iap_results if item['state'] == state]
+            if sms_ids:
+                if not delete_all and state != 'success':
+                    self.env['sms.sms'].sudo().browse(sms_ids).write({
+                        'state': 'error',
+                        'error_code': sms_to_notif_status[state],
+                    })
+                notifications = self.env['mail.notification'].sudo().search([
+                    ('notification_type', '=', 'sms'),
+                    ('sms_id', 'in', sms_ids),
+                    ('notification_status', 'not in', ('sent', 'canceled'))]
+                )
+                if notifications:
+                    notifications.write({
+                        'notification_status': 'sent' if state == 'success' else 'exception',
+                        'failure_type': sms_to_notif_status[state],
+                        'failure_reason': failure_reason if failure_reason else False,
+                    })
+
+        if todelete_sms_ids:
+            self.browse(todelete_sms_ids).sudo().unlink()
+
+    @api.multi
+    def cancel(self):
+        self.write({
+            'state': 'canceled',
+            'error_code': False
+        })

addons/sms/security/ir.model.access.csv

@@ -0,0 +1,3 @@
+id,name,model_id:id,group_id:id,perm_read,perm_write,perm_create,perm_unlink
+access_sms_sms_all,access.sms.sms.all,model_sms_sms,,0,0,0,0
+access_sms_sms_system,access.sms.sms.system,model_sms_sms,base.group_system,1,1,1,1

addons/sms/tests/common.py

@@ -3,7 +3,8 @@
 from contextlib import contextmanager
 from unittest.mock import patch
 
-from odoo import exceptions
+from odoo import exceptions, tools
+from odoo.addons.phone_validation.tools import phone_validation
 from odoo.tests import common
 from odoo.addons.sms.models.sms_api import SmsApi
 
@@ -54,18 +55,100 @@ class MockSMS(common.BaseCase):
         finally:
             pass
 
+    def _clear_sms_sent(self):
+        self._sms = []
+
     def assertSMSSent(self, numbers, content):
         """ Check sent SMS. Order is not checked. Each number should have received
-        the same content. Usefull to check batch sending.
+        the same content. Useful to check batch sending.
 
         :param numbers: list of numbers;
         :param content: content to check for each number;
         """
-        self.assertEqual(len(self._sms), len(numbers))
         for number in numbers:
             sent_sms = next((sms for sms in self._sms if sms['number'] == number), None)
             self.assertTrue(bool(sent_sms), 'Number %s not found in %s' % (number, repr([s['number'] for s in self._sms])))
             self.assertEqual(sent_sms['body'], content)
 
-    def _clear_sms_sent(self):
-        self._sms = []
+    def assertSMSCanceled(self, partner, number, error_code, content=None):
+        """ Check canceled SMS. Search is done for a pair partner / number where
+        partner can be an empty recordset. """
+        sms = self.env['sms.sms'].sudo().search([
+            ('partner_id', '=', partner.id), ('number', '=', number),
+            ('state', '=', 'canceled')
+        ])
+        self.assertTrue(sms, 'SMS: not found canceled SMS for %s (number: %s)' % (partner, number))
+        self.assertEqual(sms.error_code, error_code)
+        if content is not None:
+            self.assertEqual(sms.body, content)
+
+    def assertSMSFailed(self, partner, number, error_code, content=None):
+        """ Check failed SMS. Search is done for a pair partner / number where
+        partner can be an empty recordset. """
+        sms = self.env['sms.sms'].sudo().search([
+            ('partner_id', '=', partner.id), ('number', '=', number),
+            ('state', '=', 'error')
+        ])
+        self.assertTrue(sms, 'SMS: not found failed SMS for %s (number: %s)' % (partner, number))
+        self.assertEqual(sms.error_code, error_code)
+        if content is not None:
+            self.assertEqual(sms.body, content)
+
+    def assertSMSOutgoing(self, partner, number, content=None):
+        """ Check outgoing SMS. Search is done for a pair partner / number where
+        partner can be an empty recordset. """
+        sms = self.env['sms.sms'].sudo().search([
+            ('partner_id', '=', partner.id), ('number', '=', number),
+            ('state', '=', 'outgoing')
+        ])
+        self.assertTrue(sms, 'SMS: not found failed SMS for %s (number: %s, state)' % (partner, number))
+        if content is not None:
+            self.assertEqual(sms.body, content)
+
+    def assertSMSNotification(self, recipients_info, content, messages=None, check_sms=True):
+        """ Check content of notifications.
+
+          :param recipients_info: list[{
+            'partner': res.partner record (may be empty),
+            'number': number used for notification (may be empty, computed based on partner),
+            'state': ready / sent / exception / canceled (sent by default),
+            'failure_type': optional: sms_number_missing / sms_number_format / sms_credit / sms_server
+            }, { ... }]
+        """
+        partners = self.env['res.partner'].concat(*list(p['partner'] for p in recipients_info if p.get('partner')))
+        numbers = [p['number'] for p in recipients_info if p.get('number')]
+        base_domain = [
+            '|', ('res_partner_id', 'in', partners.ids),
+            '&', ('res_partner_id', '=', False), ('sms_number', 'in', numbers),
+            ('notification_type', '=', 'sms')
+        ]
+        if messages is not None:
+            base_domain += [('mail_message_id', 'in', messages.ids)]
+        notifications = self.env['mail.notification'].search(base_domain)
+
+        self.assertEqual(notifications.mapped('res_partner_id'), partners)
+
+        for recipient_info in recipients_info:
+            partner = recipient_info.get('partner', self.env['res.partner'])
+            number = recipient_info.get('number')
+            state = recipient_info.get('state', 'sent')
+            if number is None and partner:
+                number = phone_validation.phone_get_sanitized_record_number(partner)
+
+            notif = notifications.filtered(lambda n: n.res_partner_id == partner and n.sms_number == number and n.notification_status == state)
+            self.assertTrue(notif, 'SMS: not found notification for %s (number: %s, state: %s)' % (partner, number, state))
+
+            if state not in ('sent', 'ready', 'canceled'):
+                self.assertEqual(notif.failure_type, recipient_info['failure_type'])
+            if check_sms:
+                if state == 'sent':
+                    self.assertSMSSent([number], content)
+                elif state == 'ready':
+                    self.assertSMSOutgoing(partner, number, content)
+                elif state == 'exception':
+                    self.assertSMSFailed(partner, number, recipient_info['failure_type'], content)
+                elif state == 'canceled':
+                    self.assertSMSCanceled(partner, number, recipient_info.get('failure_type', False), content)
+
+        for message in messages:
+            self.assertEqual(content, tools.html2plaintext(message.body).rstrip('\n'))

addons/sms/views/sms_sms_views.xml

@@ -0,0 +1,66 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<odoo><data>
+    <record id="sms_tsms_view_form" model="ir.ui.view">
+        <field name="name">sms.sms.view.form</field>
+        <field name="model">sms.sms</field>
+        <field name="arch" type="xml">
+            <form string="SMS">
+                <header>
+                    <button name="send" string="Send Now" type="object" states='outgoing' class="oe_highlight"/>
+                    <button name="cancel" string="Cancel" type="object" states='outgoing'/>
+                    <field name="state" widget="statusbar"/>
+                </header>
+                <sheet>
+                    <group>
+                        <field name="body"/>
+                    </group>
+                    <group>
+                        <group>
+                            <field name="partner_id"/>
+                            <field name="number"/>
+                        </group>
+                        <group>
+                            <field name="error_code"/>
+                            <field name="mail_message_id"/>
+                        </group>
+                    </group>
+                </sheet>
+            </form>
+        </field>
+    </record>
+
+    <record id="sms_sms_view_tree" model="ir.ui.view">
+        <field name="name">sms.sms.view.tree</field>
+        <field name="model">sms.sms</field>
+        <field name="arch" type="xml">
+            <tree string="SMS Templates">
+                <field name="number"/>
+                <field name="partner_id"/>
+                <field name="state"/>
+
+            </tree>
+        </field>
+    </record>
+
+    <record id="sms_sms_view_search" model="ir.ui.view">
+        <field name="name">sms.sms.view.search</field>
+        <field name="model">sms.sms</field>
+        <field name="arch" type="xml">
+            <search string="Search SMS Templates">
+                <field name="number"/>
+                <field name="partner_id"/>
+            </search>
+        </field>
+    </record>
+
+    <record id="sms_sms_action" model="ir.actions.act_window">
+        <field name="name">SMS</field>
+        <field name="res_model">sms.sms</field>
+        <field name="view_mode">tree,form</field>
+    </record>
+
+    <menuitem id="sms_menu_main" name="SMS" parent="base.menu_custom" sequence="2"/>
+    <menuitem id="sms_sms_menu" parent="sms_menu_main" action="sms_sms_action" sequence="1"/>
+
+</data>
+</odoo>

addons/sms/wizard/sms_composer.py

@@ -1,25 +1,9 @@
 # -*- coding: utf-8 -*-
 # Part of Odoo. See LICENSE file for full copyright and licensing details.
-import logging
-
 
 from odoo import api, fields, models, _
+from odoo.addons.phone_validation.tools import phone_validation
 from odoo.exceptions import UserError
-from odoo.addons.iap.models import iap
-
-_logger = logging.getLogger(__name__)
-
-try:
-    import phonenumbers
-    _sms_phonenumbers_lib_imported = True
-
-except ImportError:
-    _sms_phonenumbers_lib_imported = False
-    _logger.info(
-        "The `phonenumbers` Python module is not available. "
-        "Phone number validation will be skipped. "
-        "Try `pip3 install phonenumbers` to install it."
-    )
 
 
 class SendSMS(models.TransientModel):
@@ -29,27 +13,6 @@ class SendSMS(models.TransientModel):
     recipients = fields.Char('Recipients', required=True)
     message = fields.Text('Message', required=True)
 
-    def _phone_get_country(self, partner):
-        if 'country_id' in partner:
-            return partner.country_id
-        return self.env.company.country_id
-
-    def _sms_sanitization(self, partner, field_name):
-        number = partner[field_name]
-        if number and _sms_phonenumbers_lib_imported:
-            country = self._phone_get_country(partner)
-            country_code = country.code if country else None
-            try:
-                phone_nbr = phonenumbers.parse(number, region=country_code, keep_raw_input=True)
-            except phonenumbers.phonenumberutil.NumberParseException:
-                return number
-            if not phonenumbers.is_possible_number(phone_nbr) or not phonenumbers.is_valid_number(phone_nbr):
-                return number
-            phone_fmt = phonenumbers.PhoneNumberFormat.E164
-            return phonenumbers.format_number(phone_nbr, phone_fmt)
-        else:
-            return number
-
     def _get_records(self, model):
         if self.env.context.get('active_domain'):
             records = model.search(self.env.context.get('active_domain'))
@@ -64,14 +27,14 @@ class SendSMS(models.TransientModel):
         result = super(SendSMS, self).default_get(fields)
         active_model = self.env.context.get('active_model')
 
-        if not self.env.context.get('default_recipients') and active_model and hasattr(self.env[active_model], '_get_default_sms_recipients'):
+        if not self.env.context.get('default_recipients') and active_model and hasattr(self.env[active_model], '_sms_get_default_partners'):
             model = self.env[active_model]
             records = self._get_records(model)
-            partners = records._get_default_sms_recipients()
+            partners = records._sms_get_default_partners()
             phone_numbers = []
             no_phone_partners = []
             for partner in partners:
-                number = self._sms_sanitization(partner, self.env.context.get('field_name') or 'mobile')
+                number = phone_validation.phone_get_sanitized_record_number(partner, self.env.context.get('field_name') or 'mobile', 'country_id')
                 if number:
                     phone_numbers.append(number)
                 else:
@@ -86,10 +49,10 @@ class SendSMS(models.TransientModel):
         numbers = [number.strip() for number in self.recipients.split(',') if number.strip()]
 
         active_model = self.env.context.get('active_model')
-        if active_model and hasattr(self.env[active_model], 'message_post_send_sms'):
+        if active_model and hasattr(self.env[active_model], '_message_sms'):
             model = self.env[active_model]
             records = self._get_records(model)
-            records.message_post_send_sms(self.message, numbers=numbers)
+            records[0]._message_sms(self.message, sms_numbers=numbers)
         else:
             self.env['sms.api']._send_sms(numbers, self.message)
         return True

addons/test_mail/tests/common.py

@@ -174,13 +174,13 @@ class TestRecipients(common.SavepointCase):
             'name': 'Valid Lelitre',
             'email': 'valid.lelitre@agrolait.com',
             'country_id': cls.env.ref('base.be').id,
-            'mobile': '0475001122',
+            'mobile': '0456001122',
         })
         cls.partner_2 = Partner.create({
             'name': 'Valid Poilvache',
             'email': 'valid.other@gmail.com',
             'country_id': cls.env.ref('base.be').id,
-            'mobile': '+32 475 22 11 00',
+            'mobile': '+32 456 22 11 00',
         })
 
 

addons/test_mail/tests/test_performance.py

@@ -506,7 +506,7 @@ class TestHeavyMailPerformance(BaseMailPerformance):
         })
         self.assertEqual(rec.message_partner_ids, self.user_portal.partner_id | self.env.user.partner_id)
         self.assertEqual(len(rec.message_ids), 1)
-        with self.assertQueryCount(__system__=99, emp=103):  # com runbot: 99 -103 // test_mail only: 99 - 103
+        with self.assertQueryCount(__system__=100, emp=106):  # com runbot: 100 -106 // test_mail only: 100 - 106
             rec.write({
                 'name': 'Test2',
                 'umbrella_id': self.umbrella.id,
@@ -542,7 +542,7 @@ class TestHeavyMailPerformance(BaseMailPerformance):
         })
         self.assertEqual(rec.message_partner_ids, self.user_portal.partner_id | self.env.user.partner_id)
 
-        with self.assertQueryCount(__system__=104, emp=108):  # test_mail only: 104 - 108
+        with self.assertQueryCount(__system__=105, emp=111):  # test_mail only: 105 - 111
             rec.write({
                 'name': 'Test2',
                 'umbrella_id': umbrella_id,

addons/test_mail_full/__manifest__.py

@@ -15,7 +15,7 @@ real applications. """,
         'mail',
         'mail_bot',
         # 'snailmail',
-        'mass_mailing',
+        # 'mass_mailing',
         'phone_validation',
         'sms',
     ],

addons/test_mail_full/models/test_mail_models.py

@@ -10,6 +10,7 @@ class MailTestSMS(models.Model):
     _description = 'Chatter Model for SMS Gateway'
     _name = 'mail.test.sms'
     _inherit = ['mail.thread']
+    _order = 'name asc, id asc'
 
     name = fields.Char()
     subject = fields.Char()
@@ -18,6 +19,19 @@ class MailTestSMS(models.Model):
     mobile_nbr = fields.Char()
     customer_id = fields.Many2one('res.partner', 'Customer')
 
-    @api.multi
-    def _get_default_sms_recipients(self):
+    def _sms_get_default_partners(self):
         return self.mapped('customer_id')
+
+    def _sms_get_number_fields(self):
+        return ['phone_nbr', 'mobile_nbr']
+
+
+class MailTestSMSSoLike(models.Model):
+    """ A model like sale order having only a customer, not specific phone
+    or mobile fields. """
+    _description = 'Chatter Model for SMS Gateway (Partner only)'
+    _name = 'mail.test.sms.partner'
+    _inherit = ['mail.thread']
+
+    name = fields.Char()
+    partner_id = fields.Many2one('res.partner', 'Customer')

addons/test_mail_full/security/ir.model.access.csv

@@ -1,3 +1,5 @@
 id,name,model_id:id,group_id:id,perm_read,perm_write,perm_create,perm_unlink
 access_mail_test_sms_all,mail.test.sms.all,model_mail_test_sms,,0,0,0,0
 access_mail_test_sms_user,mail.test.sms.user,model_mail_test_sms,base.group_user,1,1,1,1
+access_mail_test_sms_partner_all,mail.test.sms.partner.all,model_mail_test_sms_partner,,0,0,0,0
+access_mail_test_sms_partner_user,mail.test.sms.partner.user,model_mail_test_sms_partner,base.group_user,1,1,1,1

addons/test_mail_full/tests/__init__.py

@@ -2,4 +2,6 @@
 
 from . import common
 from . import test_sms_composer
+from . import test_sms_performance
 from . import test_sms_post
+from . import test_sms_sms

addons/test_mail_full/tests/common.py

@@ -1,5 +1,6 @@
 # -*- coding: utf-8 -*-
 
+from odoo.addons.phone_validation.tools import phone_validation
 from odoo.addons.test_mail.tests import common as test_mail_common
 
 
@@ -12,3 +13,10 @@ class BaseFunctionalTest(test_mail_common.BaseFunctionalTest):
 
         # update country to belgium in order to test sanitization of numbers
         cls.user_employee.company_id.write({'country_id': cls.env.ref('base.be').id})
+
+        # some numbers for testing
+        cls.random_numbers_str = '+32456998877, 0456665544'
+        cls.random_numbers = cls.random_numbers_str.split(', ')
+        cls.random_numbers_san = [phone_validation.phone_format(number, 'BE', '32', force_format='E164') for number in cls.random_numbers]
+        cls.test_numbers = ['+32456010203', '0456 04 05 06']
+        cls.test_numbers_san = [phone_validation.phone_format(number, 'BE', '32', force_format='E164') for number in cls.test_numbers]

addons/test_mail_full/tests/test_sms_composer.py

@@ -1,10 +1,10 @@
 # -*- coding: utf-8 -*-
 # Part of Odoo. See LICENSE file for full copyright and licensing details.
 
+from odoo.addons.phone_validation.tools import phone_validation
 from odoo.addons.sms.tests import common as sms_common
 from odoo.addons.test_mail.tests import common as test_mail_common
 from odoo.addons.test_mail_full.tests import common as test_mail_full_common
-from odoo.addons.phone_validation.tools.phone_validation import phone_format
 
 
 class TestSMSComposer(test_mail_full_common.BaseFunctionalTest, sms_common.MockSMS, test_mail_common.MockEmails, test_mail_common.TestRecipients):
@@ -14,11 +14,9 @@ class TestSMSComposer(test_mail_full_common.BaseFunctionalTest, sms_common.MockS
         super(TestSMSComposer, cls).setUpClass()
         cls._test_body = 'VOID CONTENT'
         cls.partner_numbers = [
-            phone_format(partner.mobile, partner.country_id.code, partner.country_id.phone_code, force_format='E164')
+            phone_validation.phone_format(partner.mobile, partner.country_id.code, partner.country_id.phone_code, force_format='E164')
             for partner in (cls.partner_1 | cls.partner_2)
         ]
-        cls.random_numbers_str = '+32475998877, 0475997788'
-        cls.random_numbers = [phone_format(number, 'BE', '32', force_format='E164') for number in ['+32475998877', '0475997788']]
 
     def test_composer_no_model(self):
         composer = self.env['sms.composer'].with_context().create({
@@ -62,13 +60,13 @@ class TestSMSComposer(test_mail_full_common.BaseFunctionalTest, sms_common.MockS
             'mobile': 'coincoin',
             })
         partners = self.partner_1 | self.partner_2 | partner_incorrect
-        composer = self.env['sms.composer'].with_context(
-            active_model='res.partner',
-            active_domain=[('id', 'in', partners.ids)]
-        ).create({
-            'message': self._test_body,
-        })
+        # composer = self.env['sms.composer'].with_context(
+        #     active_model='res.partner',
+        #     active_domain=[('id', 'in', partners.ids)]
+        # ).create({
+        #     'message': self._test_body,
+        # })
 
-        with self.mockSMSGateway():
-            composer.action_send_sms()
+        # with self.mockSMSGateway():
+        #     composer.action_send_sms()
         # self.assertSMSSent((self.partner_1 | self.partner_2).mapped('mobile'), test_body)  # TDE FIXME: actually sanitizer does not work in current master (saas 12.23))

addons/test_mail_full/tests/test_sms_performance.py

@@ -0,0 +1,88 @@
+# -*- coding: utf-8 -*-
+# Part of Odoo. See LICENSE file for full copyright and licensing details.
+
+from odoo.addons.sms.tests import common as sms_common
+from odoo.addons.test_mail.tests.test_performance import BaseMailPerformance
+from odoo.tests.common import users, warmup
+from odoo.tests import tagged
+from odoo.tools import mute_logger
+
+
+@tagged('mail_performance')
+class TestSMSPerformance(BaseMailPerformance, sms_common.MockSMS):
+
+    def setUp(self):
+        super(TestSMSPerformance, self).setUp()
+        self.user_employee.write({
+            'login': 'employee',
+        })
+        self.admin = self.env.user
+
+        self.customer = self.env['res.partner'].with_context(self._quick_create_ctx).create({
+            'name': 'Test Customer',
+            'email': 'test@example.com',
+            'mobile': '0456123456',
+            'country_id': self.env.ref('base.be').id,
+        })
+        self.test_record = self.env['mail.test.sms'].with_context(self._quick_create_ctx).create({
+            'name': 'Test',
+            'customer_id': self.customer.id,
+            'phone_nbr': '0456999999',
+        })
+
+        # prepare recipients to test for more realistic workload
+        Partners = self.env['res.partner'].with_context(self._quick_create_ctx)
+        self.partners = self.env['res.partner']
+        for x in range(0, 10):
+            self.partners |= Partners.create({
+                'name': 'Test %s' % x,
+                'email': 'test%s@example.com' % x,
+                'mobile': '0456%s%s0000' % (x, x),
+                'country_id': self.env.ref('base.be').id,
+            })
+
+        # patch registry to simulate a ready environment
+        self.patch(self.env.registry, 'ready', True)
+
+    @mute_logger('odoo.addons.sms.models.sms_sms')
+    @users('employee')
+    @warmup
+    def test_message_sms_record_1_partner(self):
+        record = self.test_record.with_user(self.env.user)
+        pids = self.customer.ids
+        with self.mockSMSGateway(), self.assertQueryCount(employee=22):  # test_mail_enterprise: 22
+            messages = record._message_sms(
+                body='Performance Test',
+                partner_ids=pids,
+            )
+
+        self.assertEqual(record.message_ids[0].body, '<p>Performance Test</p>')
+        self.assertSMSNotification([{'partner': self.customer}], 'Performance Test', messages)
+
+    @mute_logger('odoo.addons.sms.models.sms_sms')
+    @users('employee')
+    @warmup
+    def test_message_sms_record_10_partners(self):
+        record = self.test_record.with_user(self.env.user)
+        pids = self.partners.ids
+        with self.mockSMSGateway(), self.assertQueryCount(employee=40):  # test_mail_enterprise: 40
+            messages = record._message_sms(
+                body='Performance Test',
+                partner_ids=pids,
+            )
+
+        self.assertEqual(record.message_ids[0].body, '<p>Performance Test</p>')
+        self.assertSMSNotification([{'partner': partner} for partner in self.partners], 'Performance Test', messages)
+
+    @mute_logger('odoo.addons.sms.models.sms_sms')
+    @users('employee')
+    @warmup
+    def test_message_sms_record_default(self):
+        record = self.test_record.with_user(self.env.user)
+        with self.mockSMSGateway(), self.assertQueryCount(employee=26):  # test_mail_enterprise: 26
+            messages = record._message_sms(
+                body='Performance Test',
+            )
+
+        self.assertEqual(record.message_ids[0].body, '<p>Performance Test</p>')
+        self.assertSMSNotification([{'partner': self.customer}], 'Performance Test', messages)

addons/test_mail_full/tests/test_sms_post.py

@@ -1,6 +1,7 @@
 # -*- coding: utf-8 -*-
 # Part of Odoo. See LICENSE file for full copyright and licensing details.
 
+from odoo.addons.phone_validation.tools import phone_validation
 from odoo.addons.sms.tests import common as sms_common
 from odoo.addons.test_mail.tests import common as test_mail_common
 from odoo.addons.test_mail_full.tests import common as test_mail_full_common
@@ -11,44 +12,280 @@ class TestSMSPost(test_mail_full_common.BaseFunctionalTest, sms_common.MockSMS,
     @classmethod
     def setUpClass(cls):
         super(TestSMSPost, cls).setUpClass()
+        cls._test_body = 'VOID CONTENT'
+
+        cls.partner_numbers = [
+            phone_validation.phone_format(partner.mobile, partner.country_id.code, partner.country_id.phone_code, force_format='E164')
+            for partner in (cls.partner_1 | cls.partner_2)
+        ]
+
+        cls.test_record = cls.env['mail.test.sms'].with_context(**cls._test_context).create({
+            'name': 'Test',
+            'customer_id': cls.partner_1.id,
+            'mobile_nbr': cls.test_numbers[0],
+            'phone_nbr': cls.test_numbers[1],
+        })
+        cls.test_record = cls._reset_mail_context(cls.test_record)
+
+    def test_message_sms_internals_body(self):
+        with self.sudo('employee'), self.mockSMSGateway():
+            test_record = self.env['mail.test.sms'].browse(self.test_record.id)
+            messages = test_record._message_sms('<p>Mega SMS<br/>Top moumoutte</p>', partner_ids=self.partner_1.ids)
+
+        self.assertEqual(messages.body, '<p>Mega SMS<br>Top moumoutte</p>')
+        self.assertSMSNotification([{'partner': self.partner_1}], 'Mega SMS\nTop moumoutte', messages)
+
+    def test_message_sms_internals_check_existing(self):
+        with self.sudo('employee'), self.mockSMSGateway(sim_error='wrong_format_number'):
+            test_record = self.env['mail.test.sms'].browse(self.test_record.id)
+            messages = test_record._message_sms(self._test_body, partner_ids=self.partner_1.ids)
+
+        self.assertSMSNotification([{'partner': self.partner_1, 'state': 'exception', 'failure_type': 'sms_number_format'}], self._test_body, messages)
+
+        with self.sudo('employee'), self.mockSMSGateway():
+            test_record = self.env['mail.test.sms'].browse(self.test_record.id)
+            test_record._notify_record_by_sms(messages, {'partners': [{'id': self.partner_1.id, 'notif': 'sms'}]}, check_existing=True)
+        self.assertSMSNotification([{'partner': self.partner_1}], self._test_body, messages)
+
+    def test_message_sms_internals_sms_numbers(self):
+        with self.sudo('employee'), self.mockSMSGateway():
+            test_record = self.env['mail.test.sms'].browse(self.test_record.id)
+            messages = test_record._message_sms(self._test_body, partner_ids=self.partner_1.ids, sms_numbers=self.random_numbers)
+
+        self.assertSMSNotification([{'partner': self.partner_1}, {'number': self.random_numbers_san[0]}, {'number': self.random_numbers_san[1]}], self._test_body, messages)
+
+    def test_message_sms_internals_pid_to_number(self):
+        pid_to_number = {
+            self.partner_1.id: self.random_numbers[0],
+            self.partner_2.id: self.random_numbers[1],
+        }
+        with self.sudo('employee'), self.mockSMSGateway():
+            test_record = self.env['mail.test.sms'].browse(self.test_record.id)
+            messages = test_record._message_sms(self._test_body, partner_ids=(self.partner_1 | self.partner_2).ids, sms_pid_to_number=pid_to_number)
+
+        self.assertSMSNotification([
+            {'partner': self.partner_1, 'number': self.random_numbers_san[0]},
+            {'partner': self.partner_2, 'number': self.random_numbers_san[1]}],
+            self._test_body, messages)
+
+    def test_message_sms_model_partner(self):
+        with self.sudo('employee'), self.mockSMSGateway():
+            messages = self.partner_1._message_sms(self._test_body)
+            messages |= self.partner_2._message_sms(self._test_body)
+        self.assertSMSNotification([{'partner': self.partner_1}, {'partner': self.partner_2}], self._test_body, messages)
+
+    def test_message_sms_model_partner_fallback(self):
+        self.partner_1.write({'mobile': False, 'phone': self.random_numbers[0]})
+
+        with self.mockSMSGateway():
+            messages = self.partner_1._message_sms(self._test_body)
+            messages |= self.partner_2._message_sms(self._test_body)
+
+        self.assertSMSNotification([{'partner': self.partner_1, 'number': self.random_numbers_san[0]}, {'partner': self.partner_2}], self._test_body, messages)
+
+    def test_message_sms_model_w_partner_only(self):
+        with self.sudo('employee'):
+            record = self.env['mail.test.sms.partner'].create({'partner_id': self.partner_1.id})
+
+            with self.mockSMSGateway():
+                messages = record._message_sms(self._test_body)
+
+        self.assertSMSNotification([{'partner': self.partner_1}], self._test_body, messages)
+
+    def test_message_sms_model_w_partner_only_void(self):
+        with self.sudo('employee'):
+            record = self.env['mail.test.sms.partner'].create({'partner_id': False})
+
+            with self.mockSMSGateway():
+                messages = record._message_sms(self._test_body)
+
+        # should not crash but no sms / no recipients
+        notifs = self.env['mail.notification'].search([('mail_message_id', 'in', messages.ids)])
+        self.assertFalse(notifs)
+
+    def test_message_sms_on_field_w_partner(self):
+        with self.sudo('employee'), self.mockSMSGateway():
+            test_record = self.env['mail.test.sms'].browse(self.test_record.id)
+            messages = test_record._message_sms(self._test_body, number_field='mobile_nbr')
+
+        self.assertSMSNotification([{'partner': self.partner_1, 'number': self.test_record.mobile_nbr}], self._test_body, messages)
+
+    def test_message_sms_on_field_wo_partner(self):
+        self.test_record.write({'customer_id': False})
+
+        with self.sudo('employee'), self.mockSMSGateway():
+            test_record = self.env['mail.test.sms'].browse(self.test_record.id)
+            messages = test_record._message_sms(self._test_body, number_field='mobile_nbr')
+
+        self.assertSMSNotification([{'number': self.test_record.mobile_nbr}], self._test_body, messages)
+
+    def test_message_sms_on_field_wo_partner_default_field(self):
+        self.test_record.write({'customer_id': False})
+
+        with self.sudo('employee'), self.mockSMSGateway():
+            test_record = self.env['mail.test.sms'].browse(self.test_record.id)
+            messages = test_record._message_sms(self._test_body)
+
+        self.assertSMSNotification([{'number': self.test_numbers_san[1]}], self._test_body, messages)
+
+    def test_message_sms_on_field_wo_partner_default_field_2(self):
+        self.test_record.write({'customer_id': False, 'phone_nbr': False})
+
+        with self.sudo('employee'), self.mockSMSGateway():
+            test_record = self.env['mail.test.sms'].browse(self.test_record.id)
+            messages = test_record._message_sms(self._test_body)
+
+        self.assertSMSNotification([{'number': self.test_numbers_san[0]}], self._test_body, messages)
+
+    def test_message_sms_on_numbers(self):
+        with self.sudo('employee'), self.mockSMSGateway():
+            test_record = self.env['mail.test.sms'].browse(self.test_record.id)
+            messages = test_record._message_sms(self._test_body, sms_numbers=self.random_numbers_san)
+        self.assertSMSNotification([{'number': self.random_numbers_san[0]}, {'number': self.random_numbers_san[1]}], self._test_body, messages)
+
+    def test_message_sms_on_numbers_sanitization(self):
+        with self.sudo('employee'), self.mockSMSGateway():
+            test_record = self.env['mail.test.sms'].browse(self.test_record.id)
+            messages = test_record._message_sms(self._test_body, sms_numbers=self.random_numbers)
+        self.assertSMSNotification([{'number': self.random_numbers_san[0]}, {'number': self.random_numbers_san[1]}], self._test_body, messages)
+
+    def test_message_sms_on_partner_ids(self):
+        with self.sudo('employee'), self.mockSMSGateway():
+            test_record = self.env['mail.test.sms'].browse(self.test_record.id)
+            messages = test_record._message_sms(self._test_body, partner_ids=(self.partner_1 | self.partner_2).ids)
+
+        self.assertSMSNotification([{'partner': self.partner_1}, {'partner': self.partner_2}], self._test_body, messages)
+
+    def test_message_sms_on_partner_ids_default(self):
+        with self.sudo('employee'), self.mockSMSGateway():
+            test_record = self.env['mail.test.sms'].browse(self.test_record.id)
+            messages = test_record._message_sms(self._test_body)
+
+        self.assertSMSNotification([{'partner': self.test_record.customer_id, 'number': self.test_numbers_san[1]}], self._test_body, messages)
+
+    def test_message_sms_on_partner_ids_w_numbers(self):
+        with self.sudo('employee'), self.mockSMSGateway():
+            test_record = self.env['mail.test.sms'].browse(self.test_record.id)
+            messages = test_record._message_sms(self._test_body, partner_ids=self.partner_1.ids, sms_numbers=self.random_numbers[:1])
+
+        self.assertSMSNotification([{'partner': self.partner_1}, {'number': self.random_numbers_san[0]}], self._test_body, messages)
+
+
+class TestSMSPostException(test_mail_full_common.BaseFunctionalTest, sms_common.MockSMS, test_mail_common.MockEmails, test_mail_common.TestRecipients):
+
+    @classmethod
+    def setUpClass(cls):
+        super(TestSMSPostException, cls).setUpClass()
+        cls._test_body = 'VOID CONTENT'
+
         cls.test_record = cls.env['mail.test.sms'].with_context(**cls._test_context).create({
             'name': 'Test',
             'customer_id': cls.partner_1.id,
         })
         cls.test_record = cls._reset_mail_context(cls.test_record)
+        cls.partner_3 = cls.env['res.partner'].with_context({
+            'mail_create_nolog': True,
+            'mail_create_nosubscribe': True,
+            'mail_notrack': True,
+            'no_reset_password': True,
+        }).create({
+            'name': 'Ernestine Loubine',
+            'email': 'ernestine.loubine@agrolait.com',
+            'country_id': cls.env.ref('base.be').id,
+            'mobile': '0475556644',
+        })
 
-    def test_message_post_with_sms_on_partners(self):
-        test_body = 'Void body'
-        with self.mockSMSGateway():
-            (self.partner_1 | self.partner_2).message_post_send_sms(test_body)
-        self.assertSMSSent((self.partner_1 | self.partner_2).mapped('mobile'), test_body)
+    def test_message_sms_w_numbers_invalid(self):
+        random_numbers = self.random_numbers + ['6988754']
+        with self.sudo('employee'), self.mockSMSGateway():
+            test_record = self.env['mail.test.sms'].browse(self.test_record.id)
+            messages = test_record._message_sms(self._test_body, sms_numbers=random_numbers)
 
-    def test_message_post_with_sms_w_default(self):
-        test_body = 'Void body'
-        with self.mockSMSGateway():
-            self.test_record.message_post_send_sms(test_body)
-        self.assertSMSSent(self.partner_1.mapped('mobile'), test_body)
-        self.assertIn(test_body, self.test_record.message_ids.body)
+        # invalid numbers are still given to IAP currently as they are
+        self.assertSMSNotification([{'number': self.random_numbers_san[0]}, {'number': self.random_numbers_san[1]}, {'number': random_numbers[2]}], self._test_body, messages)
 
-    def test_message_post_with_sms_w_numbers(self):
-        test_body = 'Void body'
-        test_numbers = ['0475114477', '0475225588']
-        with self.mockSMSGateway():
-            self.test_record.message_post_send_sms(test_body, numbers=test_numbers)
-        self.assertSMSSent(test_numbers, test_body)
-        self.assertIn(test_body, self.test_record.message_ids.body)
+    def test_message_sms_w_partners_nocountry(self):
+        self.test_record.customer_id.write({
+            'mobile': self.random_numbers[0],
+            'phone': self.random_numbers[1],
+            'country_id': False,
+        })
+        with self.sudo('employee'), self.mockSMSGateway():
+            test_record = self.env['mail.test.sms'].browse(self.test_record.id)
+            messages = test_record._message_sms(self._test_body, partner_ids=self.test_record.customer_id.ids)
 
-    def test_message_post_with_sms_w_numbers_duplicate(self):
-        test_body = 'Void body'
-        test_numbers = ['0475114477', '0475225588', '0475114477']
-        with self.mockSMSGateway():
-            self.test_record.message_post_send_sms(test_body, numbers=test_numbers)
-        self.assertSMSSent(test_numbers, test_body)
-        self.assertIn(test_body, self.test_record.message_ids.body)
+        self.assertSMSNotification([{'partner': self.test_record.customer_id}], self._test_body, messages)
 
-    def test_message_post_with_sms_w_partners(self):
-        test_body = 'Void body'
-        with self.mockSMSGateway():
-            self.test_record.message_post_send_sms(test_body, partners=self.partner_1 | self.partner_2)
-        self.assertSMSSent((self.partner_1 | self.partner_2).mapped('mobile'), test_body)
-        self.assertIn(test_body, self.test_record.message_ids.body)
+    def test_message_sms_w_partners_falsy(self):
+        # TDE FIXME: currently sent to IAP
+        self.test_record.customer_id.write({
+            'mobile': 'youpie',
+            'phone': 'youpla',
+        })
+        with self.sudo('employee'), self.mockSMSGateway():
+            test_record = self.env['mail.test.sms'].browse(self.test_record.id)
+            messages = test_record._message_sms(self._test_body, partner_ids=self.test_record.customer_id.ids)
+
+        # self.assertSMSNotification({self.test_record.customer_id: {}}, {}, self._test_body, messages)
+
+    def test_message_sms_w_numbers_sanitization_duplicate(self):
+        pass
+        # TDE FIXME: not sure
+        # random_numbers = self.random_numbers + [self.random_numbers[1]]
+        # random_numbers_san = self.random_numbers_san + [self.random_numbers_san[1]]
+        # with self.sudo('employee'), self.mockSMSGateway():
+        #     messages = self.test_record._message_sms(self._test_body, sms_numbers=random_numbers)
+        # self.assertSMSNotification({}, {random_numbers_san[0]: {}, random_numbers_san[1]: {}, random_numbers_san[2]: {}}, self._test_body, messages)
+
+    def test_message_sms_crash_credit(self):
+        with self.sudo('employee'), self.mockSMSGateway(sim_error='credit'):
+            test_record = self.env['mail.test.sms'].browse(self.test_record.id)
+            messages = test_record._message_sms(self._test_body, partner_ids=(self.partner_1 | self.partner_2).ids)
+
+        self.assertSMSNotification([
+            {'partner': self.partner_1, 'state': 'exception', 'failure_type': 'sms_credit'},
+            {'partner': self.partner_2, 'state': 'exception', 'failure_type': 'sms_credit'},
+        ], self._test_body, messages)
+
+    def test_message_sms_crash_credit_single(self):
+        with self.sudo('employee'), self.mockSMSGateway(nbr_t_error={phone_validation.phone_get_sanitized_record_number(self.partner_2): 'credit'}):
+            test_record = self.env['mail.test.sms'].browse(self.test_record.id)
+            messages = test_record._message_sms(self._test_body, partner_ids=(self.partner_1 | self.partner_2 | self.partner_3).ids)
+
+        self.assertSMSNotification([
+            {'partner': self.partner_1, 'state': 'sent'},
+            {'partner': self.partner_2, 'state': 'exception', 'failure_type': 'sms_credit'},
+            {'partner': self.partner_3, 'state': 'sent'},
+        ], self._test_body, messages)
+
+    def test_message_sms_crash_server_crash(self):
+        with self.sudo('employee'), self.mockSMSGateway(sim_error='jsonrpc_exception'):
+            test_record = self.env['mail.test.sms'].browse(self.test_record.id)
+            messages = test_record._message_sms(self._test_body, partner_ids=(self.partner_1 | self.partner_2 | self.partner_3).ids)
+
+        self.assertSMSNotification([
+            {'partner': self.partner_1, 'state': 'exception', 'failure_type': 'sms_server'},
+            {'partner': self.partner_2, 'state': 'exception', 'failure_type': 'sms_server'},
+            {'partner': self.partner_3, 'state': 'exception', 'failure_type': 'sms_server'},
+        ], self._test_body, messages)
+
+    def test_message_sms_crash_wrong_number(self):
+        with self.sudo('employee'), self.mockSMSGateway(sim_error='wrong_format_number'):
+            test_record = self.env['mail.test.sms'].browse(self.test_record.id)
+            messages = test_record._message_sms(self._test_body, partner_ids=(self.partner_1 | self.partner_2).ids)
+
+        self.assertSMSNotification([
+            {'partner': self.partner_1, 'state': 'exception', 'failure_type': 'sms_number_format'},
+            {'partner': self.partner_2, 'state': 'exception', 'failure_type': 'sms_number_format'},
+        ], self._test_body, messages)
+
+    def test_message_sms_crash_wrong_number_single(self):
+        with self.sudo('employee'), self.mockSMSGateway(nbr_t_error={phone_validation.phone_get_sanitized_record_number(self.partner_2): 'wrong_format_number'}):
+            test_record = self.env['mail.test.sms'].browse(self.test_record.id)
+            messages = test_record._message_sms(self._test_body, partner_ids=(self.partner_1 | self.partner_2 | self.partner_3).ids)
+
+        self.assertSMSNotification([
+            {'partner': self.partner_1, 'state': 'sent'},
+            {'partner': self.partner_2, 'state': 'exception', 'failure_type': 'sms_number_format'},
+            {'partner': self.partner_3, 'state': 'sent'},
+        ], self._test_body, messages)

addons/test_mail_full/tests/test_sms_sms.py

@@ -0,0 +1,59 @@
+# -*- coding: utf-8 -*-
+# Part of Odoo. See LICENSE file for full copyright and licensing details.
+
+from unittest.mock import patch
+from unittest.mock import DEFAULT
+
+from odoo import exceptions
+from odoo.addons.sms.models.sms_sms import SmsSms as SmsSms
+from odoo.addons.sms.tests import common as sms_common
+from odoo.addons.test_mail.tests import common as test_mail_common
+from odoo.addons.test_mail_full.tests import common as test_mail_full_common
+
+
+class TestSMSPost(test_mail_full_common.BaseFunctionalTest, sms_common.MockSMS, test_mail_common.MockEmails, test_mail_common.TestRecipients):
+
+    @classmethod
+    def setUpClass(cls):
+        super(TestSMSPost, cls).setUpClass()
+        cls._test_body = 'VOID CONTENT'
+
+        cls.sms_all = cls.env['sms.sms']
+        for x in range(10):
+            cls.sms_all |= cls.env['sms.sms'].create({
+                'number': '+324560000%s%s' % (x, x),
+                'body': cls._test_body,
+            })
+
+    def test_sms_send_batch_size(self):
+        self.count = 0
+
+        def _send(sms_self, delete_all=False, raise_exception=False):
+            self.count += 1
+            return DEFAULT
+
+        self.env['ir.config_parameter'].set_param('sms.session.batch.size', '3')
+        with patch.object(SmsSms, '_send', autospec=True, side_effect=_send) as send_mock:
+            self.env['sms.sms'].browse(self.sms_all.ids).send()
+
+        self.assertEqual(self.count, 4)
+
+    def test_sms_send_crash_employee(self):
+        with self.assertRaises(exceptions.AccessError):
+            self.env['sms.sms'].with_user(self.user_employee).browse(self.sms_all.ids).send()
+
+    def test_sms_send_delete_all(self):
+        with self.mockSMSGateway(sim_error='jsonrpc_exception'):
+            self.env['sms.sms'].browse(self.sms_all.ids).send(delete_all=True, raise_exception=False)
+        self.assertFalse(len(self.sms_all.exists()))
+
+    def test_sms_send_raise(self):
+        with self.assertRaises(exceptions.AccessError):
+            with self.mockSMSGateway(sim_error='jsonrpc_exception'):
+                self.env['sms.sms'].browse(self.sms_all.ids).send(raise_exception=True)
+        self.assertEqual(set(self.sms_all.mapped('state')), set(['outgoing']))
+
+    def test_sms_send_raise_catch(self):
+        with self.mockSMSGateway(sim_error='jsonrpc_exception'):
+            self.env['sms.sms'].browse(self.sms_all.ids).send(raise_exception=False)
+        self.assertEqual(set(self.sms_all.mapped('state')), set(['error']))