", body)
+ self.assertIn('href="https://example.com/track"', body)
+ self.assertIn("<b>bold</b>", body)
+ self.assertIn("41.3851,2.1734", body)
+ self.assertNotIn("<a", body)
+
+ def test_receive_message_formatting(self):
+ """Whatsapp text markers are rendered as html."""
+ message = copy.deepcopy(self.message_01)
+ content = message["entry"][0]["changes"][0]["value"]["messages"][0]
+ content["text"] = {"body": "*bold* _italic_ https://example.com/a_b_c"}
+ body = self.receive_message(message).body
+ self.assertIn("bold ", body)
+ self.assertIn("italic ", body)
+ # The markers of a link belong to the link.
+ self.assertIn('href="https://example.com/a_b_c"', body)
+
+ @mute_logger("odoo.addons.mail_gateway.controllers.gateway")
+ def test_post_no_signature_no_message(self):
+ self.gateway.webhook_key = self.webhook
+ self.gateway.set_webhook()
+ self.integrate_webhook()
+ self.set_message(self.message_01, self.webhook, False)
+ self.assertFalse(
+ self.env["discuss.channel"].search([("gateway_id", "=", self.gateway.id)])
+ )
+
+ @mute_logger("odoo.addons.mail_gateway.controllers.gateway")
+ def test_post_wrong_signature_no_message(self):
+ self.gateway.webhook_key = self.webhook
+ self.gateway.set_webhook()
+ self.integrate_webhook()
+ data = json.dumps(self.message_01)
+ hex_dig = hmac.new(
+ self.gateway.webhook_secret.encode(),
+ data.encode(),
+ hashlib.sha256,
+ ).hexdigest()
+ headers = {
+ "Content-Type": "application/json",
+ "x-hub-signature-256": f"sha256=1234{hex_dig}",
+ }
+ self.url_open(
+ f"/gateway/{self.gateway.gateway_type}/{self.webhook}/update",
+ data=data,
+ headers=headers,
+ ).raise_for_status()
+ self.assertFalse(
+ self.env["discuss.channel"].search([("gateway_id", "=", self.gateway.id)])
+ )
+
+ def test_send_image(self):
+ self.gateway.webhook_key = self.webhook
+ self.gateway.set_webhook()
+ self.integrate_webhook()
+ composer = self.env["whatsapp.composer"].create(
+ {
+ "res_model": self.partner._name,
+ "res_id": self.partner.id,
+ "number_field_name": "phone",
+ "gateway_id": self.gateway.id,
+ }
+ )
+ composer.action_view_whatsapp()
+ channel = self.env["discuss.channel"].search(
+ [("gateway_id", "=", self.gateway.id)]
+ )
+
+ with patch("requests.post") as post_mock:
+ post_mock.return_value = MagicMock()
+ channel.message_post(
+ attachments=[("demo.png", b"IMAGE")],
+ subtype_xmlid="mail.mt_comment",
+ message_type="comment",
+ )
+ post_mock.assert_called()
+ self.assertEqual(post_mock.call_count, 2)
+
+ def test_send_message_formatting(self):
+ """Html formatting is sent as whatsapp text markers."""
+ self.gateway.webhook_key = self.webhook
+ self.gateway.set_webhook()
+ self.integrate_webhook()
+ composer = self.env["whatsapp.composer"].create(
+ {
+ "res_model": self.partner._name,
+ "res_id": self.partner.id,
+ "number_field_name": "phone",
+ "gateway_id": self.gateway.id,
+ }
+ )
+ composer.action_view_whatsapp()
+ channel = self.env["discuss.channel"].search(
+ [("gateway_id", "=", self.gateway.id)]
+ )
+ with patch("requests.post") as post_mock:
+ post_mock.return_value = MagicMock()
+ channel.message_post(
+ body=Markup("
bold and italic
"),
+ subtype_xmlid="mail.mt_comment",
+ message_type="comment",
+ )
+ payload = post_mock.call_args.kwargs["json"]
+ self.assertEqual(payload["text"]["body"], "*bold* and _italic_")
+
+ def test_send_document_error(self):
+ self.gateway.webhook_key = self.webhook
+ self.gateway.set_webhook()
+ self.integrate_webhook()
+ composer = self.env["whatsapp.composer"].create(
+ {
+ "res_model": self.partner._name,
+ "res_id": self.partner.id,
+ "number_field_name": "phone",
+ "gateway_id": self.gateway.id,
+ }
+ )
+ composer.action_view_whatsapp()
+ channel = self.env["discuss.channel"].search(
+ [("gateway_id", "=", self.gateway.id)]
+ )
+ with mute_logger(
+ "odoo.addons.mail_gateway_whatsapp.models.mail_gateway_whatsapp"
+ ):
+ message = channel.message_post(
+ attachments=[("demo.xml", b"IMAGE")],
+ subtype_xmlid="mail.mt_comment",
+ message_type="comment",
+ )
+ self.assertEqual(message.notification_ids.notification_status, "exception")
+
+ def test_send_message_text(self):
+ """
+ Test that the message is sent correctly
+ - First message need a template
+ - Second message does not need a template
+ """
+ ctx = {
+ "default_res_model": self.partner._name,
+ "default_res_id": self.partner.id,
+ "default_number_field_name": "phone",
+ "default_composition_mode": "comment",
+ "default_gateway_id": self.gateway.id,
+ }
+ self.gateway.whatsapp_account_id = "123456"
+ form_composer = Form(self.env["whatsapp.composer"].with_context(**ctx))
+ form_composer.body = "Body test"
+ self.assertTrue(form_composer.is_required_template)
+ self.assertTrue(form_composer._get_modifier("template_id", "required"))
+ form_composer.template_id = self.ws_template
+ composer = form_composer.save()
+ self.assertEqual(composer.body, "Demo template")
+ channel = self.partner._whatsapp_get_channel(
+ composer.number_field_name, composer.gateway_id
+ )
+ message_domain = [
+ ("gateway_type", "=", "whatsapp"),
+ ("model", "=", channel._name),
+ ("res_id", "=", channel.id),
+ ]
+ with (
+ RecordCapturer(self.env["mail.message"], message_domain) as capture,
+ patch("requests.post") as post_mock,
+ ):
+ post_mock.return_value = MagicMock()
+ composer.action_send_whatsapp()
+ self.assertEqual(len(capture.records), 1)
+ self.assertEqual(capture.records.body, Markup("Demo template
"))
+ # second message
+ form_composer = Form(self.env["whatsapp.composer"].with_context(**ctx))
+ form_composer.body = "Body test"
+ self.assertFalse(form_composer.is_required_template)
+ self.assertFalse(form_composer._get_modifier("template_id", "required"))
+ composer = form_composer.save()
+ self.assertEqual(composer.body, "Body test")
+ channel = self.partner._whatsapp_get_channel(
+ composer.number_field_name, composer.gateway_id
+ )
+ message_domain = [
+ ("gateway_type", "=", "whatsapp"),
+ ("model", "=", channel._name),
+ ("res_id", "=", channel.id),
+ ]
+ with (
+ RecordCapturer(self.env["mail.message"], message_domain) as capture,
+ patch("requests.post") as post_mock,
+ ):
+ post_mock.return_value = MagicMock()
+ composer.action_send_whatsapp()
+ self.assertEqual(len(capture.records), 1)
+ self.assertEqual(capture.records.body, Markup("Body test
"))
+
+ def test_compose(self):
+ self.gateway.webhook_key = self.webhook
+ self.gateway.set_webhook()
+ self.integrate_webhook()
+ composer = self.env["whatsapp.composer"].create(
+ {
+ "res_model": self.partner._name,
+ "res_id": self.partner.id,
+ "number_field_name": "phone",
+ "gateway_id": self.gateway.id,
+ }
+ )
+ composer.action_view_whatsapp()
+ channel = self.env["discuss.channel"].search(
+ [("gateway_id", "=", self.gateway.id)]
+ )
+ self.assertTrue(channel)
+ self.assertFalse(channel.message_ids)
+ with self.assertRaises(UserError):
+ composer.action_send_whatsapp()
+ composer.body = "DEMO"
+ with patch("requests.post") as post_mock:
+ post_mock.return_value = MagicMock()
+ composer.action_send_whatsapp()
+ post_mock.assert_called()
+ channel.invalidate_recordset()
+ self.assertTrue(channel.message_ids)
+
+ def test_send_message_with_variable(self):
+ ctx = {
+ "default_res_model": self.partner._name,
+ "default_res_id": self.partner.id,
+ "default_number_field_name": "phone",
+ "default_composition_mode": "comment",
+ "default_gateway_id": self.gateway.id,
+ }
+ tmpl_with_vars = self.env["mail.whatsapp.template"].create(
+ {
+ "name": "Partner Vars",
+ "category": "utility",
+ "language": "es",
+ "header": "Hi {{1}}",
+ "body": "Name: {{1}} · Tel: {{2}}",
+ "gateway_id": self.gateway.id,
+ "variable_ids": [Command.clear()],
+ "state": "approved",
+ "is_supported": True,
+ "model_id": self.env["ir.model"]._get("res.partner").id,
+ }
+ )
+ self.env["mail.whatsapp.template.variable"].create(
+ {
+ "name": "{{1}}",
+ "line_type": "header",
+ "template_id": tmpl_with_vars.id,
+ "field_name": "name",
+ }
+ )
+ self.env["mail.whatsapp.template.variable"].create(
+ {
+ "name": "{{1}}",
+ "line_type": "body",
+ "template_id": tmpl_with_vars.id,
+ "field_name": "name",
+ }
+ )
+ self.env["mail.whatsapp.template.variable"].create(
+ {
+ "name": "{{2}}",
+ "line_type": "body",
+ "template_id": tmpl_with_vars.id,
+ "field_name": "phone",
+ }
+ )
+ self.env["mail.whatsapp.template.button"].create(
+ {
+ "name": "phone",
+ "button_type": "phone_number",
+ "template_id": tmpl_with_vars.id,
+ "call_number": "+34666555444",
+ }
+ )
+ self.assertEqual(len(tmpl_with_vars.variable_ids), 3)
+ self.assertEqual(len(tmpl_with_vars.button_ids), 1)
+ self.gateway.whatsapp_account_id = "123456"
+ form_composer = Form(self.env["whatsapp.composer"].with_context(**ctx))
+ form_composer.template_id = tmpl_with_vars
+ self.assertTrue(form_composer.is_required_template)
+ self.assertTrue(form_composer._get_modifier("template_id", "required"))
+ composer = form_composer.save()
+ channel = self.partner._whatsapp_get_channel(
+ composer.number_field_name, composer.gateway_id
+ )
+ message_domain = [
+ ("gateway_type", "=", "whatsapp"),
+ ("model", "=", channel._name),
+ ("res_id", "=", channel.id),
+ ]
+ with (
+ RecordCapturer(self.env["mail.message"], message_domain) as capture,
+ patch("requests.post") as post_mock,
+ ):
+ post_mock.return_value = MagicMock()
+ composer.action_send_whatsapp()
+ # Assertions
+ self.assertEqual(len(capture.records), 1)
+ channel.invalidate_recordset()
+ self.assertTrue(channel.message_ids)
+
+ def test_send_message_with_dynamic_button(self):
+ ctx = {
+ "default_res_model": self.partner._name,
+ "default_res_id": self.partner.id,
+ "default_number_field_name": "phone",
+ "default_composition_mode": "comment",
+ "default_gateway_id": self.gateway.id,
+ }
+ tmpl_with_vars_dynamic = self.env["mail.whatsapp.template"].create(
+ {
+ "name": "Dynamic Button",
+ "category": "utility",
+ "language": "es",
+ "body": "Name: {{1}} · Tel: {{2}}",
+ "gateway_id": self.gateway.id,
+ "variable_ids": [Command.clear()],
+ "state": "approved",
+ "is_supported": True,
+ "model_id": self.env["ir.model"]._get("res.partner").id,
+ }
+ )
+ self.assertEqual(len(tmpl_with_vars_dynamic.variable_ids), 0)
+ self.env["mail.whatsapp.template.variable"].create(
+ {
+ "name": "{{1}}",
+ "line_type": "body",
+ "template_id": tmpl_with_vars_dynamic.id,
+ "field_name": "name",
+ }
+ )
+ self.env["mail.whatsapp.template.variable"].create(
+ {
+ "name": "{{2}}",
+ "line_type": "body",
+ "template_id": tmpl_with_vars_dynamic.id,
+ "field_name": "phone",
+ }
+ )
+ self.env["mail.whatsapp.template.button"].create(
+ {
+ "name": "1",
+ "button_type": "url",
+ "url_type": "dynamic",
+ "template_id": tmpl_with_vars_dynamic.id,
+ "website_url": "https://www.odoo.com",
+ }
+ )
+ self.assertEqual(len(tmpl_with_vars_dynamic.variable_ids), 3)
+ button = tmpl_with_vars_dynamic.variable_ids.search(
+ [
+ ("line_type", "=", "button"),
+ ("template_id", "=", tmpl_with_vars_dynamic.id),
+ ]
+ )
+ button.field_name = "name"
+ self.gateway.whatsapp_account_id = "123456"
+ form_composer = Form(self.env["whatsapp.composer"].with_context(**ctx))
+ form_composer.template_id = tmpl_with_vars_dynamic
+ self.assertTrue(form_composer.is_required_template)
+ self.assertTrue(form_composer._get_modifier("template_id", "required"))
+ composer = form_composer.save()
+ channel = self.partner._whatsapp_get_channel(
+ composer.number_field_name, composer.gateway_id
+ )
+ message_domain = [
+ ("gateway_type", "=", "whatsapp"),
+ ("model", "=", channel._name),
+ ("res_id", "=", channel.id),
+ ]
+ with (
+ RecordCapturer(self.env["mail.message"], message_domain) as capture,
+ patch("requests.post") as post_mock,
+ ):
+ post_mock.return_value = MagicMock()
+ composer.action_send_whatsapp()
+ # Assertions
+ self.assertEqual(len(capture.records), 1)
+ channel.invalidate_recordset()
+ self.assertTrue(channel.message_ids)
diff --git a/mail_gateway_whatsapp/tests/test_mail_whatsapp_coverage.py b/mail_gateway_whatsapp/tests/test_mail_whatsapp_coverage.py
new file mode 100644
index 000000000..e943d4ca4
--- /dev/null
+++ b/mail_gateway_whatsapp/tests/test_mail_whatsapp_coverage.py
@@ -0,0 +1,1154 @@
+# Copyright 2025 Komit
+# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
+
+import json
+from unittest.mock import MagicMock, patch
+
+import requests
+
+from odoo import Command
+from odoo.exceptions import UserError, ValidationError
+from odoo.tests.common import tagged
+from odoo.tools import mute_logger
+
+from odoo.addons.base.models.ir_mail_server import MailDeliveryException
+from odoo.addons.mail_gateway.tests.common import MailGatewayTestCase
+
+
+@tagged("-at_install", "post_install")
+class TestMailWhatsAppCoverage(MailGatewayTestCase):
+ @classmethod
+ def setUpClass(cls):
+ super().setUpClass()
+ cls.gateway = cls.env["mail.gateway"].create(
+ {
+ "name": "gateway",
+ "gateway_type": "whatsapp",
+ "token": "token",
+ "whatsapp_security_key": "key",
+ "whatsapp_account_id": "123456",
+ "whatsapp_from_phone": "111",
+ "webhook_secret": "MY-SECRET",
+ "member_ids": [(4, cls.env.user.id)],
+ }
+ )
+ cls.partner = cls.env["res.partner"].create(
+ {"name": "Ada Lovelace", "phone": "+34900111222"}
+ )
+
+ def _create_template(self, **kwargs):
+ vals = {
+ "name": "Template",
+ "category": "utility",
+ "language": "es",
+ "body": "Body",
+ "gateway_id": self.gateway.id,
+ "state": "approved",
+ "is_supported": True,
+ }
+ vals.update(kwargs)
+ return self.env["mail.whatsapp.template"].create(vals)
+
+ # ------------------------------------------------------------------
+ # Template constraints
+ # ------------------------------------------------------------------
+ def test_check_buttons_max_total(self):
+ tmpl = self._create_template()
+ with self.assertRaisesRegex(ValidationError, "maximum of 10 buttons"):
+ tmpl.write(
+ {
+ "button_ids": [
+ Command.create({"name": f"B{i}", "button_type": "quick_reply"})
+ for i in range(11)
+ ]
+ }
+ )
+
+ def test_check_buttons_max_url(self):
+ tmpl = self._create_template()
+ with self.assertRaisesRegex(ValidationError, "maximum of 2 URL buttons"):
+ tmpl.write(
+ {
+ "button_ids": [
+ Command.create(
+ {
+ "name": f"U{i}",
+ "button_type": "url",
+ "website_url": "https://example.com",
+ }
+ )
+ for i in range(3)
+ ]
+ }
+ )
+
+ def test_check_buttons_max_phone(self):
+ tmpl = self._create_template()
+ with self.assertRaisesRegex(ValidationError, "maximum of 1 Call Number"):
+ tmpl.write(
+ {
+ "button_ids": [
+ Command.create(
+ {
+ "name": f"P{i}",
+ "button_type": "phone_number",
+ "call_number": "+34600000000",
+ }
+ )
+ for i in range(2)
+ ]
+ }
+ )
+
+ def test_check_variables_two_headers(self):
+ with self.assertRaisesRegex(
+ ValidationError, "exactly 1 variable in the header"
+ ):
+ self._create_template(
+ header="{{1}} {{2}}",
+ variable_ids=[
+ Command.create(
+ {"name": "{{1}}", "line_type": "header", "field_name": "name"}
+ ),
+ Command.create(
+ {"name": "{{2}}", "line_type": "header", "field_name": "phone"}
+ ),
+ ],
+ )
+
+ def test_check_variables_header_index(self):
+ with self.assertRaisesRegex(ValidationError, r"header should be used as"):
+ self._create_template(
+ header="{{2}}",
+ variable_ids=[
+ Command.create(
+ {"name": "{{2}}", "line_type": "header", "field_name": "name"}
+ ),
+ ],
+ )
+
+ def test_check_variables_body_gap(self):
+ with self.assertRaisesRegex(ValidationError, "should start at 1"):
+ self._create_template(
+ body="{{1}} {{3}}",
+ variable_ids=[
+ Command.create(
+ {"name": "{{1}}", "line_type": "body", "field_name": "name"}
+ ),
+ Command.create(
+ {"name": "{{3}}", "line_type": "body", "field_name": "phone"}
+ ),
+ ],
+ )
+
+ def test_variable_check_name_invalid(self):
+ tmpl = self._create_template()
+ with self.assertRaisesRegex(ValidationError, "format"):
+ self.env["mail.whatsapp.template.variable"].create(
+ {
+ "name": "not-a-var",
+ "line_type": "body",
+ "template_id": tmpl.id,
+ "field_name": "name",
+ }
+ )
+
+ def test_variable_check_field_name_missing(self):
+ tmpl = self._create_template()
+ with self.assertRaisesRegex(ValidationError, "associated with a field"):
+ self.env["mail.whatsapp.template.variable"].create(
+ {
+ "name": "{{1}}",
+ "line_type": "body",
+ "template_id": tmpl.id,
+ "field_name": False,
+ }
+ )
+
+ def test_variable_check_field_name_invalid_path(self):
+ tmpl = self._create_template()
+ with self.assertRaisesRegex(ValidationError, "valid field path"):
+ self.env["mail.whatsapp.template.variable"].create(
+ {
+ "name": "{{1}}",
+ "line_type": "body",
+ "template_id": tmpl.id,
+ "field_name": "not_a_real_field",
+ }
+ )
+
+ # ------------------------------------------------------------------
+ # Button constraints
+ # ------------------------------------------------------------------
+ def test_button_invalid_url(self):
+ tmpl = self._create_template()
+ with self.assertRaisesRegex(ValidationError, "valid URL"):
+ self.env["mail.whatsapp.template.button"].create(
+ {
+ "name": "Web",
+ "button_type": "url",
+ "website_url": "not-a-url",
+ "template_id": tmpl.id,
+ }
+ )
+
+ def test_button_check_variable_ids(self):
+ tmpl = self._create_template()
+ static_button = self.env["mail.whatsapp.template.button"].create(
+ {
+ "name": "Static",
+ "button_type": "url",
+ "url_type": "static",
+ "website_url": "https://example.com",
+ "template_id": tmpl.id,
+ }
+ )
+ # A dynamic url auto-creates its placeholder variable
+ dynamic_button = self.env["mail.whatsapp.template.button"].create(
+ {
+ "name": "{{1}}",
+ "button_type": "url",
+ "url_type": "dynamic",
+ "website_url": "https://example.com/",
+ "template_id": tmpl.id,
+ }
+ )
+ self.assertTrue(dynamic_button.variable_ids)
+ dynamic_button.check_variable_ids()
+ # A static url with a placeholder variable is invalid
+ static_button.variable_ids = [
+ Command.create(
+ {
+ "name": "{{1}}",
+ "line_type": "button",
+ "template_id": tmpl.id,
+ "field_name": "name",
+ }
+ )
+ ]
+ with self.assertRaises(ValidationError):
+ static_button.check_variable_ids()
+
+ # ------------------------------------------------------------------
+ # Export / import component building
+ # ------------------------------------------------------------------
+ def test_prepare_components_to_export(self):
+ tmpl = self._create_template(
+ header="Hello {{1}}",
+ footer="Bye",
+ body="Body {{1}}",
+ variable_ids=[
+ Command.create(
+ {"name": "{{1}}", "line_type": "header", "field_name": "name"}
+ ),
+ Command.create(
+ {"name": "{{1}}", "line_type": "body", "field_name": "name"}
+ ),
+ ],
+ )
+ self.env["mail.whatsapp.template.button"].create(
+ {
+ "name": "{{1}}",
+ "button_type": "url",
+ "url_type": "dynamic",
+ "website_url": "https://example.com/",
+ "template_id": tmpl.id,
+ }
+ )
+ self.env["mail.whatsapp.template.button"].create(
+ {
+ "name": "Call",
+ "button_type": "phone_number",
+ "call_number": "+34600000000",
+ "template_id": tmpl.id,
+ }
+ )
+ components = tmpl._prepare_components_to_export()
+ types = {c["type"] for c in components}
+ self.assertEqual(types, {"BODY", "HEADER", "FOOTER", "BUTTONS"})
+ buttons = next(c for c in components if c["type"] == "BUTTONS")["buttons"]
+ button_types = {b["type"] for b in buttons}
+ self.assertEqual(button_types, {"URL", "PHONE_NUMBER"})
+
+ def test_prepare_values_to_import_button_update_and_unsupported(self):
+ tmpl = self._create_template(template_uid="999")
+ existing = self.env["mail.whatsapp.template.button"].create(
+ {
+ "name": "Existing",
+ "button_type": "quick_reply",
+ "template_id": tmpl.id,
+ }
+ )
+ json_data = {
+ "name": "imported_tmpl",
+ "category": "MARKETING",
+ "language": "es",
+ "status": "APPROVED",
+ "id": "999",
+ "components": [
+ {"type": "BODY", "text": "Body"},
+ {
+ "type": "BUTTONS",
+ "buttons": [{"type": "QUICK_REPLY", "text": "Existing"}],
+ },
+ {"type": "CAROUSEL"}, # unsupported -> is_supported False
+ ],
+ }
+ vals = tmpl._prepare_values_to_import(self.gateway, json_data)
+ self.assertFalse(vals["is_supported"])
+ # button update command referencing the existing button
+ button_cmds = vals["button_ids"]
+ self.assertTrue(
+ any(
+ cmd[0] == Command.UPDATE and cmd[1] == existing.id
+ for cmd in button_cmds
+ )
+ )
+
+ def test_button_export_template_http_error(self):
+ tmpl = self._create_template()
+
+ def _bad_response(*args, **kwargs):
+ response = requests.Response()
+ response.status_code = 400
+ response._content = b'{"error": "bad"}'
+ response.url = args[0] if args else ""
+ return response
+
+ with patch.object(requests, "post", _bad_response):
+ with self.assertRaises(UserError):
+ tmpl.button_export_template()
+
+ # a non-HTTP error is also wrapped into a UserError
+ def _raise(*args, **kwargs):
+ raise ValueError("boom")
+
+ with patch.object(requests, "post", _raise):
+ with self.assertRaises(UserError):
+ tmpl.button_export_template()
+
+ def test_sync_template_error(self):
+ tmpl = self._create_template(template_uid="123")
+
+ def _raise(*args, **kwargs):
+ raise ValueError("boom")
+
+ with patch.object(requests, "get", _raise):
+ with self.assertRaises(UserError):
+ tmpl.button_sync_template()
+
+ def test_import_template_request_error(self):
+ self.gateway.whatsapp_account_id = "123456"
+
+ def _raise(*args, **kwargs):
+ raise ValueError("network down")
+
+ with patch.object(requests, "get", _raise):
+ with self.assertRaises(UserError):
+ self.gateway.button_import_whatsapp_template()
+
+ def test_button_dynamic_placeholder_name(self):
+ tmpl = self._create_template()
+ button = self.env["mail.whatsapp.template.button"].create(
+ {
+ "name": "{{2}}",
+ "button_type": "url",
+ "url_type": "dynamic",
+ "website_url": "https://example.com/",
+ "template_id": tmpl.id,
+ }
+ )
+ # the auto-generated placeholder is not named {{1}}
+ with self.assertRaisesRegex(ValidationError, r"can only be"):
+ button.check_variable_ids()
+
+ # ------------------------------------------------------------------
+ # Rendering / value extraction
+ # ------------------------------------------------------------------
+ def test_render_body_message_default_res_ids(self):
+ tmpl = self._create_template(
+ header="Hi {{1}}",
+ body="Name {{1}}",
+ variable_ids=[
+ Command.create(
+ {"name": "{{1}}", "line_type": "header", "field_name": "name"}
+ ),
+ Command.create(
+ {"name": "{{1}}", "line_type": "body", "field_name": "name"}
+ ),
+ ],
+ )
+ rendered = tmpl.with_context(
+ default_res_ids=[self.partner.id]
+ ).render_body_message()
+ self.assertIn(self.partner.name, rendered)
+
+ def test_extract_value_from_field_path_variants(self):
+ parent = self.env["res.partner"].create({"name": "Parent Co"})
+ self.partner.parent_id = parent
+ tmpl = self._create_template(
+ body="{{1}}",
+ variable_ids=[
+ Command.create(
+ {"name": "{{1}}", "line_type": "body", "field_name": "parent_id"}
+ ),
+ ],
+ )
+ var = tmpl.variable_ids
+ # relational field -> display name of the related record
+ self.assertEqual(
+ var._get_variables_value(self.partner), {"body-{{1}}": "Parent Co"}
+ )
+ # chained path -> last model + last field name
+ var.field_name = "parent_id.name"
+ self.assertEqual(var._extract_value_from_field_path(self.partner), "Parent Co")
+ # selection field -> exported label
+ var.field_name = "type"
+ self.assertTrue(var._extract_value_from_field_path(self.partner))
+
+ def test_variable_display_name_and_onchange(self):
+ tmpl = self._create_template()
+ Variable = self.env["mail.whatsapp.template.variable"]
+ # display name: header variant vs body variant
+ header_var = Variable.new(
+ {"name": "{{1}}", "line_type": "header", "template_id": tmpl.id}
+ )
+ body_var = Variable.new(
+ {"name": "{{1}}", "line_type": "body", "template_id": tmpl.id}
+ )
+ self.assertTrue(header_var.display_name)
+ self.assertIn("{{1}}", body_var.display_name)
+ # onchange resets the field on an in-memory record (no constraint flush)
+ onchange_var = Variable.new(
+ {
+ "name": "{{1}}",
+ "line_type": "body",
+ "template_id": tmpl.id,
+ "field_name": "name",
+ }
+ )
+ onchange_var._onchange_model_id()
+ self.assertFalse(onchange_var.field_name)
+
+ def test_button_back2draft(self):
+ tmpl = self._create_template()
+ tmpl.button_back2draft()
+ self.assertEqual(tmpl.state, "draft")
+
+ # ------------------------------------------------------------------
+ # discuss.channel avatar
+ # ------------------------------------------------------------------
+ def test_generate_avatar_gateway_whatsapp(self):
+ channel = self.partner._whatsapp_get_channel("phone", self.gateway)
+ avatar = channel._generate_avatar_gateway()
+ self.assertIn(" no channel, skipped
+ {
+ "recipient_id": "0000",
+ "id": "wamid.TEST",
+ "status": "failed",
+ },
+ # failed status without a matching notification
+ {
+ "recipient_id": token,
+ "id": "wamid.UNKNOWN",
+ "status": "failed",
+ },
+ # failed status updating our notification
+ {
+ "recipient_id": token,
+ "id": "wamid.TEST",
+ "status": "failed",
+ "errors": [
+ {
+ "code": 131,
+ "error_data": {"details": "Boom"},
+ }
+ ],
+ },
+ ]
+ },
+ }
+ ]
+ }
+ ]
+ }
+ service._receive_update(self.gateway, update)
+ self.assertEqual(notification.notification_status, "exception")
+ self.assertIn("Boom", notification.failure_reason)
+
+ def test_receive_update_status_delivery(self):
+ service = self.env["mail.gateway.whatsapp"]
+ channel = self.partner._whatsapp_get_channel("phone", self.gateway)
+ token = channel.gateway_channel_token
+ channel_message = channel.with_context(
+ no_gateway_notification=True
+ ).message_post(
+ body="hi", message_type="comment", subtype_xmlid="mail.mt_comment"
+ )
+ document_message = self.partner.message_post(
+ body="hi", message_type="comment", subtype_xmlid="mail.mt_comment"
+ )
+ notifications = self.env["mail.notification"]
+ # The channel and the document notifications share the same wamid
+ for message in channel_message | document_message:
+ notifications |= self.env["mail.notification"].create(
+ {
+ "mail_message_id": message.id,
+ "notification_type": "gateway",
+ "notification_status": "sent",
+ "gateway_channel_id": channel.id,
+ "gateway_message_id": "wamid.TEST",
+ "res_partner_id": self.partner.id,
+ }
+ )
+
+ def receive(status):
+ service._receive_update(
+ self.gateway,
+ {
+ "entry": [
+ {
+ "changes": [
+ {
+ "field": "messages",
+ "value": {
+ "statuses": [
+ {
+ "recipient_id": token,
+ "id": "wamid.TEST",
+ "status": status,
+ }
+ ]
+ },
+ }
+ ]
+ }
+ ]
+ },
+ )
+
+ receive("sent")
+ self.assertEqual(set(notifications.mapped("whatsapp_status")), {"sent"})
+ receive("delivered")
+ self.assertEqual(set(notifications.mapped("whatsapp_status")), {"delivered"})
+ receive("read")
+ self.assertEqual(set(notifications.mapped("whatsapp_status")), {"read"})
+ # Webhooks may arrive out of order: a late status doesn't go back
+ receive("delivered")
+ self.assertEqual(set(notifications.mapped("whatsapp_status")), {"read"})
+ # Unknown statuses are ignored
+ receive("deleted")
+ self.assertEqual(set(notifications.mapped("whatsapp_status")), {"read"})
+ self.assertEqual(set(notifications.mapped("notification_status")), {"sent"})
+
+ def test_receive_update_image_and_location(self):
+ service = self.env["mail.gateway.whatsapp"]
+ token = self.partner.phone.replace("+", "").replace(" ", "")
+
+ def fake_get(url, *args, **kwargs):
+ response = requests.Response()
+ response.status_code = 200
+ if "cdn" in url:
+ response._content = b"IMAGEBYTES"
+ else:
+ response._content = json.dumps(
+ {"url": "https://cdn.example.com/img", "mime_type": "image/png"}
+ ).encode()
+ return response
+
+ value = {
+ "messaging_product": "whatsapp",
+ "contacts": [{"wa_id": token, "profile": {"name": "Ada"}}],
+ "messages": [
+ {
+ "from": token,
+ "id": "wamid.IMG",
+ "timestamp": "1700000000",
+ "type": "image",
+ "image": {"id": "IMG_ID", "caption": "Nice pic"},
+ },
+ {
+ "from": token,
+ "id": "wamid.LOC",
+ "timestamp": "1700000001",
+ "type": "location",
+ "location": {"latitude": "1.23", "longitude": "4.56"},
+ },
+ ],
+ }
+ update = {"entry": [{"changes": [{"field": "messages", "value": value}]}]}
+ # The controller processes inbound updates with ``no_gateway_notification``
+ # so incoming messages are not echoed back to the Meta API.
+ gateway = self.gateway.with_context(no_gateway_notification=True)
+ with patch.object(requests, "get", fake_get):
+ service._receive_update(gateway, update)
+ channel = self.env["discuss.channel"].search(
+ [("gateway_id", "=", self.gateway.id)]
+ )
+ self.assertTrue(channel.message_ids)
+ self.assertTrue(channel.message_ids.attachment_ids)
+
+ def test_receive_update_ignores_other_fields(self):
+ service = self.env["mail.gateway.whatsapp"]
+ token = self.partner.phone.replace("+", "")
+ value = {
+ "messages": [
+ {
+ "from": token,
+ "id": "wamid.OTHER",
+ "timestamp": "1700000000",
+ "text": {"body": "ignored"},
+ }
+ ]
+ }
+ update = {"entry": [{"changes": [{"field": "account_update", "value": value}]}]}
+ service._receive_update(self.gateway, update)
+ self.assertFalse(
+ self.env["discuss.channel"].search([("gateway_id", "=", self.gateway.id)])
+ )
+
+ def test_send_payload_document(self):
+ service = self.env["mail.gateway.whatsapp"]
+ channel = self.partner._whatsapp_get_channel("phone", self.gateway)
+ payload = service._send_payload(
+ channel,
+ media_id="MEDIA_ID",
+ media_type="document",
+ media_name="invoice.pdf",
+ )
+ self.assertEqual(payload["type"], "document")
+ self.assertEqual(
+ payload["document"], {"id": "MEDIA_ID", "filename": "invoice.pdf"}
+ )
+ payload = service._send_payload(
+ channel, media_id="MEDIA_ID", media_type="image"
+ )
+ self.assertEqual(payload["image"], {"id": "MEDIA_ID"})
+
+ # ------------------------------------------------------------------
+ # mail.thread helpers
+ # ------------------------------------------------------------------
+ def test_get_whatsapp_channel_vals(self):
+ Partner = self.env["res.partner"]
+ vals = Partner._get_whatsapp_channel_vals("3412345", self.gateway, self.partner)
+ self.assertEqual(vals["gateway_channel_token"], "3412345")
+ self.assertEqual(vals["partner_id"], self.partner.id)
+ vals_no_partner = Partner._get_whatsapp_channel_vals(
+ "3412345", self.gateway, Partner.browse()
+ )
+ self.assertNotIn("partner_id", vals_no_partner)
+
+ def test_whatsapp_get_channel_creates_gateway_channel(self):
+ channel = self.partner._whatsapp_get_channel("phone", self.gateway)
+ self.assertTrue(channel)
+ gateway_channel = self.env["res.partner.gateway.channel"].search(
+ [
+ ("partner_id", "=", self.partner.id),
+ ("gateway_id", "=", self.gateway.id),
+ ]
+ )
+ self.assertTrue(gateway_channel)
+ # a second call reuses the existing gateway channel
+ self.partner._whatsapp_get_channel("phone", self.gateway)
+ self.assertEqual(
+ self.env["res.partner.gateway.channel"].search_count(
+ [
+ ("partner_id", "=", self.partner.id),
+ ("gateway_id", "=", self.gateway.id),
+ ]
+ ),
+ 1,
+ )
+
+ def test_whatsapp_get_partner_without_partner_field(self):
+ self.assertIsNone(self.env["mail.blacklist"]._whatsapp_get_partner())
+
+ def test_whatsapp_get_channel_no_phone(self):
+ partner = self.env["res.partner"].create({"name": "No Phone"})
+ with self.assertRaisesRegex(UserError, "Phone cannot be sanitized"):
+ partner._whatsapp_get_channel("phone", self.gateway)
+
+ # ------------------------------------------------------------------
+ # ir.actions.server
+ # ------------------------------------------------------------------
+ def test_server_action_model_coherency(self):
+ with self.assertRaisesRegex(ValidationError, "non transient mail.thread"):
+ self.env["ir.actions.server"].create(
+ {
+ "name": "WA transient",
+ "model_id": self.env["ir.model"]._get_id("res.users.settings"),
+ "state": "whatsapp",
+ "whatsapp_gateway_id": self.gateway.id,
+ }
+ )
+
+ def test_server_action_run_whatsapp(self):
+ tmpl = self._create_template(
+ model_id=self.env["ir.model"]._get_id("res.partner"),
+ )
+ action = self.env["ir.actions.server"].create(
+ {
+ "name": "WA action",
+ "model_id": self.env["ir.model"]._get_id("res.partner"),
+ "state": "whatsapp",
+ "whatsapp_gateway_id": self.gateway.id,
+ "whatsapp_partner": "{{ object.id }}",
+ "whatsapp_template_id": tmpl.id,
+ }
+ )
+ self.assertTrue(action.available_model_ids)
+ service_cls = type(self.env["mail.gateway.whatsapp"])
+ with patch.object(service_cls, "_send", return_value=None):
+ action.with_context(
+ active_model="res.partner",
+ active_ids=self.partner.ids,
+ active_id=self.partner.id,
+ ).run()
+ channel = self.env["discuss.channel"].search(
+ [("gateway_id", "=", self.gateway.id)]
+ )
+ self.assertTrue(channel)
+
+ def test_server_action_run_whatsapp_no_active_ids(self):
+ tmpl = self._create_template(
+ model_id=self.env["ir.model"]._get_id("res.partner"),
+ )
+ action = self.env["ir.actions.server"].create(
+ {
+ "name": "WA action noctx",
+ "model_id": self.env["ir.model"]._get_id("res.partner"),
+ "state": "whatsapp",
+ "whatsapp_gateway_id": self.gateway.id,
+ "whatsapp_partner": "{{ object.id }}",
+ "whatsapp_template_id": tmpl.id,
+ }
+ )
+ # No active_ids/active_id -> action does nothing
+ self.assertFalse(action._run_action_whatsapp_multi())
+
+ # ------------------------------------------------------------------
+ # Wizards
+ # ------------------------------------------------------------------
+ def test_whatsapp_composer(self):
+ composer = (
+ self.env["whatsapp.composer"]
+ .with_context(
+ active_model="res.partner",
+ active_id=self.partner.id,
+ )
+ .create(
+ {
+ "res_model": "res.partner",
+ "res_id": self.partner.id,
+ "number_field_name": "phone",
+ "gateway_id": self.gateway.id,
+ }
+ )
+ )
+ # is_required_template computed with no previous message -> True
+ self.assertTrue(composer.is_required_template)
+ composer.onchange_gateway_id()
+ self.assertFalse(composer.template_id)
+ # Sending without body raises
+ with self.assertRaisesRegex(UserError, "Body is required"):
+ composer.action_send_whatsapp()
+ # With body -> posts a message on the channel
+ composer.body = "Hello"
+ service_cls = type(self.env["mail.gateway.whatsapp"])
+ with patch.object(service_cls, "_send", return_value=None):
+ composer.action_send_whatsapp()
+ action = composer.action_view_whatsapp()
+ self.assertEqual(action["tag"], "mail.action_discuss")
+
+ def test_whatsapp_composer_missing_record(self):
+ composer = self.env["whatsapp.composer"].create(
+ {
+ "res_model": "res.partner",
+ "gateway_id": self.gateway.id,
+ "body": "Hello",
+ }
+ )
+ self.assertFalse(composer.action_view_whatsapp())
+ self.assertFalse(composer.action_send_whatsapp())
+ self.assertFalse(
+ self.env["discuss.channel"].search([("gateway_id", "=", self.gateway.id)])
+ )
+
+ def test_whatsapp_composer_not_required_template(self):
+ # Missing number_field_name -> template is not required
+ composer = self.env["whatsapp.composer"].create(
+ {
+ "res_model": "res.partner",
+ "res_id": self.partner.id,
+ "gateway_id": self.gateway.id,
+ }
+ )
+ self.assertFalse(composer.is_required_template)
+
+ def test_whatsapp_composer_default_get_multiple(self):
+ # A second whatsapp gateway -> the wizard cannot auto-pick one
+ self.env["mail.gateway"].create(
+ {
+ "name": "gateway 2",
+ "gateway_type": "whatsapp",
+ "token": "token2",
+ "whatsapp_security_key": "key2",
+ "webhook_secret": "SECRET-2",
+ }
+ )
+ defaults = self.env["whatsapp.composer"].default_get(
+ ["find_gateway", "gateway_id"]
+ )
+ self.assertTrue(defaults["find_gateway"])
+
+ def test_prepare_value_to_send_res_id_context(self):
+ tmpl = self._create_template(
+ body="Hi {{1}}",
+ model_id=self.env["ir.model"]._get_id("res.partner"),
+ variable_ids=[
+ Command.create(
+ {"name": "{{1}}", "line_type": "body", "field_name": "name"}
+ ),
+ ],
+ )
+ # prepare_value_to_send resolves the record from the ``res_id`` context
+ components = tmpl.with_context(res_id=self.partner.id).prepare_value_to_send()
+ body = next(c for c in components if c["type"] == "body")
+ self.assertEqual(body["parameters"][0]["text"], self.partner.name)
+
+ def test_whatsapp_composer_default_get(self):
+ defaults = self.env["whatsapp.composer"].default_get(
+ ["find_gateway", "gateway_id"]
+ )
+ # Only one whatsapp gateway exists -> auto-selected
+ self.assertFalse(defaults["find_gateway"])
+ self.assertEqual(defaults["gateway_id"], self.gateway.id)
+
+ def test_compose_gateway_message_template(self):
+ tmpl = self._create_template(
+ body="Hello world",
+ model_id=self.env["ir.model"]._get_id("res.partner"),
+ )
+ composer = self.env["mail.compose.gateway.message"].create(
+ {
+ "model": "res.partner",
+ "res_ids": f"[{self.partner.id}]",
+ "whatsapp_template_id": tmpl.id,
+ }
+ )
+ composer.onchange_whatsapp_template_id()
+ self.assertTrue(composer.body)
+ # sending applies the whatsapp template context branch
+ service_cls = type(self.env["mail.gateway.whatsapp"])
+ with patch.object(service_cls, "_send", return_value=None):
+ composer._action_send_mail()
+
+ # ------------------------------------------------------------------
+ # Inbound edge cases
+ # ------------------------------------------------------------------
+ def _new_message_value(self, token, **message):
+ message_vals = {
+ "from": token,
+ "id": "wamid.IN",
+ "timestamp": "1700000000",
+ "text": {"body": "Hello"},
+ }
+ message_vals.update(message)
+ return {
+ "messaging_product": "whatsapp",
+ "contacts": [{"wa_id": token, "profile": {"name": "Ada"}}],
+ "messages": [message_vals],
+ }
+
+ def test_receive_update_empty_and_no_channel(self):
+ service = self.env["mail.gateway.whatsapp"]
+ service._receive_update(self.gateway, {})
+ value = self._new_message_value("34900111333")
+ update = {"entry": [{"changes": [{"field": "messages", "value": value}]}]}
+ with patch.object(type(service), "_get_channel", return_value=False):
+ service._receive_update(self.gateway, update)
+ self.assertFalse(
+ self.env["discuss.channel"].search([("gateway_id", "=", self.gateway.id)])
+ )
+
+ def test_receive_update_media_without_url_and_contacts(self):
+ service = self.env["mail.gateway.whatsapp"]
+ value = self._new_message_value(
+ "34900111333",
+ sticker={"mime_type": "image/webp"},
+ contacts=[{"name": {"formatted_name": "Bob"}}],
+ )
+ update = {"entry": [{"changes": [{"field": "messages", "value": value}]}]}
+ gateway = self.gateway.with_context(no_gateway_notification=True)
+ service._receive_update(gateway, update)
+ channel = self.env["discuss.channel"].search(
+ [("gateway_id", "=", self.gateway.id)]
+ )
+ self.assertEqual(len(channel.message_ids), 1)
+ self.assertFalse(channel.message_ids.attachment_ids)
+
+ def test_receive_update_reply_to_record_message(self):
+ service = self.env["mail.gateway.whatsapp"]
+ channel = self.partner._whatsapp_get_channel("phone", self.gateway)
+ token = channel.gateway_channel_token
+ sent = channel.with_context(no_gateway_notification=True).message_post(
+ body="Question", message_type="comment", subtype_xmlid="mail.mt_comment"
+ )
+ record_message = self.partner.message_post(
+ body="Question", message_type="comment", subtype_xmlid="mail.mt_comment"
+ )
+ sent.gateway_message_id = record_message
+ self.env["mail.notification"].create(
+ {
+ "mail_message_id": sent.id,
+ "notification_type": "gateway",
+ "gateway_channel_id": channel.id,
+ "gateway_message_id": "wamid.SENT",
+ "res_partner_id": self.partner.id,
+ }
+ )
+ value = self._new_message_value(
+ token, text={"body": "Answer"}, context={"id": "wamid.SENT"}
+ )
+ update = {"entry": [{"changes": [{"field": "messages", "value": value}]}]}
+ gateway = self.gateway.with_context(no_gateway_notification=True)
+ service._receive_update(gateway, update)
+ reply = channel.message_ids.filtered(lambda m: m.parent_id == sent)
+ self.assertTrue(reply)
+ self.assertEqual(reply.gateway_message_id.model, "res.partner")
+ self.assertEqual(reply.gateway_message_id.res_id, self.partner.id)
+ self.assertIn("Answer", reply.gateway_message_id.body)
+
+ def test_get_author_and_channel_vals_without_contact(self):
+ service = self.env["mail.gateway.whatsapp"]
+ update = {
+ "messages": [{"from": "34900111333"}],
+ "contacts": [{"wa_id": "34900111444", "profile": {"name": "Other"}}],
+ }
+ self.assertFalse(service._get_author(self.gateway, update))
+ self.assertFalse(service._get_author(self.gateway, {"messages": [{}]}))
+ vals = service._get_channel_vals(self.gateway, "34900111333", update)
+ self.assertEqual(vals["name"], "34900111333")
+
+ # ------------------------------------------------------------------
+ # Outbound edge cases
+ # ------------------------------------------------------------------
+ def _new_gateway_notification(self):
+ channel = self.partner._whatsapp_get_channel("phone", self.gateway)
+ message = channel.with_context(no_gateway_notification=True).message_post(
+ body="Hello", message_type="comment", subtype_xmlid="mail.mt_comment"
+ )
+ return self.env["mail.notification"].create(
+ {
+ "mail_message_id": message.id,
+ "notification_type": "gateway",
+ "gateway_channel_id": channel.id,
+ "res_partner_id": self.partner.id,
+ }
+ )
+
+ def test_send_raise_exception(self):
+ service = self.env["mail.gateway.whatsapp"]
+ notification = self._new_gateway_notification()
+ with (
+ patch.object(requests, "post", side_effect=requests.ConnectionError),
+ mute_logger(
+ "odoo.addons.mail_gateway_whatsapp.models.mail_gateway_whatsapp"
+ ),
+ self.assertRaises(MailDeliveryException),
+ ):
+ service._send(self.gateway, notification, raise_exception=True)
+
+ def test_send_auto_commit(self):
+ service = self.env["mail.gateway.whatsapp"]
+ notification = self._new_gateway_notification()
+ response = MagicMock()
+ response.json.return_value = {"messages": [{"id": "wamid.OUT"}]}
+ with (
+ patch.object(requests, "post", return_value=response),
+ patch.object(self.env.cr, "commit") as commit_mock,
+ ):
+ service._send(self.gateway, notification, auto_commit=True)
+ commit_mock.assert_called_once()
+ self.assertEqual(notification.notification_status, "sent")
+ self.assertEqual(notification.gateway_message_id, "wamid.OUT")
+
+ # ------------------------------------------------------------------
+ # Template variables and buttons
+ # ------------------------------------------------------------------
+ def test_header_variable_lifecycle(self):
+ tmpl = self._create_template(header="Hello {{1}}")
+ header_variable = tmpl.variable_ids.filtered(
+ lambda var: var.line_type == "header"
+ )
+ self.assertEqual(header_variable.name, "{{1}}")
+ # Keep the variable while the header still uses it
+ tmpl.header = "Hi {{1}}"
+ self.assertEqual(
+ tmpl.variable_ids.filtered(lambda var: var.line_type == "header"),
+ header_variable,
+ )
+ # Drop it once the header has no variable anymore
+ tmpl.header = "Hi"
+ self.assertFalse(
+ tmpl.variable_ids.filtered(lambda var: var.line_type == "header")
+ )
+
+ def test_prepare_components_to_export_static_and_quick_reply(self):
+ tmpl = self._create_template()
+ self.env["mail.whatsapp.template.button"].create(
+ [
+ {
+ "name": "Site",
+ "button_type": "url",
+ "url_type": "static",
+ "website_url": "https://example.com",
+ "template_id": tmpl.id,
+ },
+ {
+ "name": "Yes",
+ "button_type": "quick_reply",
+ "template_id": tmpl.id,
+ },
+ ]
+ )
+ components = tmpl._prepare_components_to_export()
+ buttons = next(c for c in components if c["type"] == "BUTTONS")["buttons"]
+ self.assertEqual(
+ buttons,
+ [
+ {"type": "URL", "text": "Site", "url": "https://example.com"},
+ {"type": "QUICK_REPLY", "text": "Yes"},
+ ],
+ )
+
+ def test_extract_value_without_field_name(self):
+ tmpl = self._create_template(body="{{1}}")
+ self.assertEqual(
+ tmpl.variable_ids._extract_value_from_field_path(self.partner), ""
+ )
+
+ def test_button_dynamic_variable_update_and_checks(self):
+ tmpl = self._create_template()
+ button = self.env["mail.whatsapp.template.button"].create(
+ {
+ "name": "{{1}}",
+ "button_type": "url",
+ "url_type": "dynamic",
+ "website_url": "https://example.com/",
+ "template_id": tmpl.id,
+ }
+ )
+ variable = button.variable_ids
+ # Changing the url updates the existing placeholder
+ button.website_url = "https://example.org/"
+ self.assertEqual(button.variable_ids, variable)
+ self.assertEqual(variable.sample_value, "https://example.org/")
+ # More than one placeholder is invalid
+ button.variable_ids = [
+ Command.create(
+ {"name": "{{2}}", "line_type": "button", "template_id": tmpl.id}
+ )
+ ]
+ with self.assertRaisesRegex(ValidationError, "only contain one placeholder"):
+ button.check_variable_ids()
+ # A dynamic url without placeholder is invalid
+ button.variable_ids = [Command.clear()]
+ with self.assertRaisesRegex(ValidationError, "must have a placeholder"):
+ button.check_variable_ids()
+
+ def test_receive_update_media_with_url(self):
+ service = self.env["mail.gateway.whatsapp"]
+ value = self._new_message_value(
+ "34900111333",
+ document={
+ "url": "https://cdn.example.com/doc",
+ "mime_type": "application/pdf",
+ "caption": "Invoice",
+ },
+ )
+ update = {"entry": [{"changes": [{"field": "messages", "value": value}]}]}
+ response = requests.Response()
+ response.status_code = 200
+ response._content = b"PDFBYTES"
+ gateway = self.gateway.with_context(no_gateway_notification=True)
+ with patch.object(requests, "get", return_value=response) as get_mock:
+ service._receive_update(gateway, update)
+ get_mock.assert_called_once()
+ channel = self.env["discuss.channel"].search(
+ [("gateway_id", "=", self.gateway.id)]
+ )
+ attachment = channel.message_ids.attachment_ids
+ self.assertEqual(attachment.name, "document.pdf")
+ self.assertEqual(attachment.raw, b"PDFBYTES")
+
+ def test_template_values_without_record(self):
+ tmpl = self._create_template(
+ body="Name {{1}}",
+ model_id=self.env["ir.model"]._get_id("res.partner"),
+ variable_ids=[
+ Command.create(
+ {"name": "{{1}}", "line_type": "body", "field_name": "name"}
+ ),
+ ],
+ )
+ components = tmpl.prepare_value_to_send()
+ self.assertEqual(
+ components,
+ [{"type": "body", "parameters": [{"type": "text", "text": " "}]}],
+ )
+ self.assertEqual(tmpl.render_body_message(), "Name ")
diff --git a/mail_gateway_whatsapp/tests/test_mail_whatsapp_template.py b/mail_gateway_whatsapp/tests/test_mail_whatsapp_template.py
new file mode 100644
index 000000000..87b3a9be0
--- /dev/null
+++ b/mail_gateway_whatsapp/tests/test_mail_whatsapp_template.py
@@ -0,0 +1,240 @@
+# Copyright 2024 Tecnativa - Carlos López
+# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
+
+import json
+from unittest.mock import patch
+
+import requests
+
+from odoo import Command
+from odoo.exceptions import UserError
+from odoo.tests.common import tagged
+
+from odoo.addons.mail_gateway.tests.common import MailGatewayTestCase
+
+
+@tagged("-at_install", "post_install")
+class TestMailWhatsAppTemplate(MailGatewayTestCase):
+ @classmethod
+ def setUpClass(cls):
+ super().setUpClass()
+ cls.gateway = cls.env["mail.gateway"].create(
+ {
+ "name": "gateway",
+ "gateway_type": "whatsapp",
+ "token": "token",
+ "whatsapp_security_key": "key",
+ "webhook_secret": "MY-SECRET",
+ "member_ids": [(4, cls.env.user.id)],
+ }
+ )
+ cls.new_template_response_data = {
+ "id": "018273645",
+ "status": "APPROVED",
+ }
+ cls.new_template_full_response_data = {
+ "name": "new_template",
+ "parameter_format": "POSITIONAL",
+ "components": [
+ {"type": "HEADER", "format": "TEXT", "text": "Header 1"},
+ {"type": "BODY", "text": "Body 1"},
+ {"type": "FOOTER", "text": "Footer changed"},
+ ],
+ "language": "es",
+ "status": "APPROVED",
+ "category": "MARKETING",
+ "id": "018273645",
+ }
+ cls.template_1_data = {
+ "name": "test_odoo_1",
+ "parameter_format": "POSITIONAL",
+ "components": [
+ {"type": "HEADER", "format": "TEXT", "text": "Header 1"},
+ {"type": "BODY", "text": "Body 1"},
+ {"type": "FOOTER", "text": "Footer 1"},
+ ],
+ "language": "es",
+ "status": "APPROVED",
+ "category": "MARKETING",
+ "id": "1234567890",
+ }
+ cls.template_2_data = {
+ "name": "test_with_buttons",
+ "parameter_format": "POSITIONAL",
+ "components": [
+ {"type": "HEADER", "format": "TEXT", "text": "Header 2"},
+ {"type": "BODY", "text": "Body 2"},
+ {
+ "type": "BUTTONS",
+ "buttons": [{"type": "QUICK_REPLY", "text": "Button 1"}],
+ },
+ ],
+ "language": "es",
+ "status": "APPROVED",
+ "category": "MARKETING",
+ "sub_category": "CUSTOM",
+ "id": "0987654321",
+ }
+ cls.templates_download = {
+ "data": [cls.template_1_data, cls.template_2_data],
+ }
+
+ def _make_meta_requests(self, url, json_data, status_code=200):
+ """
+ Simulate a fake request to the Meta API:
+ :param json_data: Dictionary with the json data to return
+ :param status_code: Status code expected
+ :returns requests.Response object
+ """
+ response = requests.Response()
+ response.status_code = status_code
+ response._content = json.dumps(json_data).encode()
+ response.url = url
+ response.headers["Content-Type"] = "application/json"
+ return response
+
+ def test_download_templates(self):
+ def _patch_request_post(url, *args, **kwargs):
+ if "message_templates" in url:
+ return self._make_meta_requests(url, self.templates_download)
+ return original_get(url, *args, **kwargs)
+
+ with self.assertRaisesRegex(
+ UserError, "WhatsApp Account is required to import templates"
+ ):
+ self.gateway.button_import_whatsapp_template()
+ self.gateway.whatsapp_account_id = "123456"
+ original_get = requests.get
+ with patch.object(requests, "get", _patch_request_post):
+ self.gateway.button_import_whatsapp_template()
+ self.assertEqual(self.gateway.whatsapp_template_count, 2)
+ template_1 = self.gateway.whatsapp_template_ids.filtered(
+ lambda t: t.template_uid == "1234567890"
+ )
+ self.assertTrue(template_1.is_supported)
+ self.assertEqual(template_1.template_name, "test_odoo_1")
+ self.assertEqual(template_1.category, "marketing")
+ self.assertEqual(template_1.language, "es")
+ self.assertEqual(template_1.state, "approved")
+ self.assertEqual(template_1.header, "Header 1")
+ self.assertEqual(template_1.body, "Body 1")
+ self.assertEqual(template_1.footer, "Footer 1")
+ template_2 = self.gateway.whatsapp_template_ids.filtered(
+ lambda t: t.template_uid == "0987654321"
+ )
+ self.assertTrue(template_2.is_supported)
+ self.assertEqual(template_2.template_name, "test_with_buttons")
+ self.assertEqual(template_2.category, "marketing")
+ self.assertEqual(template_2.language, "es")
+ self.assertEqual(template_2.state, "approved")
+ self.assertEqual(template_2.header, "Header 2")
+ self.assertEqual(template_2.body, "Body 2")
+ self.assertFalse(template_2.footer)
+
+ def test_export_template(self):
+ def _patch_request_post(url, *args, **kwargs):
+ if "message_templates" in url:
+ return self._make_meta_requests(url, self.new_template_response_data)
+ return original_post(url, *args, **kwargs)
+
+ def _patch_request_get(url, *args, **kwargs):
+ if "018273645" in url:
+ return self._make_meta_requests(
+ url, self.new_template_full_response_data
+ )
+ return original_get(url, *args, **kwargs)
+
+ original_post = requests.post
+ original_get = requests.get
+ self.gateway.whatsapp_account_id = "123456"
+ new_template = self.env["mail.whatsapp.template"].create(
+ {
+ "name": "New template",
+ "category": "marketing",
+ "language": "es",
+ "header": "Header 1",
+ "body": "Body 1",
+ "gateway_id": self.gateway.id,
+ }
+ )
+ self.assertEqual(new_template.template_name, "new_template")
+ with patch.object(requests, "post", _patch_request_post):
+ new_template.button_export_template()
+ self.assertTrue(new_template.template_uid)
+ self.assertTrue(new_template.is_supported)
+ self.assertFalse(new_template.footer)
+ self.assertEqual(new_template.state, "approved")
+ # sync templates, footer should be updated
+ with patch.object(requests, "get", _patch_request_get):
+ new_template.button_sync_template()
+ self.assertEqual(new_template.footer, "Footer changed")
+
+ def test_prepare_values_template_send(self):
+ partner = self.env["res.partner"].create(
+ {
+ "name": "Ada Lovelace",
+ "phone": "+34900111222",
+ }
+ )
+ ctx = {
+ "default_res_model": partner._name,
+ "default_res_id": partner.id,
+ }
+ tmpl = self.env["mail.whatsapp.template"].create(
+ {
+ "name": "Test Render",
+ "category": "utility",
+ "language": "es",
+ "header": "Hi {{1}}",
+ "body": "Name: {{1}} · Tel: {{2}}",
+ "gateway_id": self.gateway.id,
+ "variable_ids": [Command.clear()],
+ "state": "approved",
+ "is_supported": True,
+ "model_id": self.env["ir.model"]._get("res.partner").id,
+ }
+ )
+ self.env["mail.whatsapp.template.variable"].create(
+ {
+ "name": "{{1}}",
+ "line_type": "header",
+ "template_id": tmpl.id,
+ "field_name": "name",
+ }
+ )
+ self.env["mail.whatsapp.template.variable"].create(
+ {
+ "name": "{{1}}",
+ "line_type": "body",
+ "template_id": tmpl.id,
+ "field_name": "name",
+ }
+ )
+ self.env["mail.whatsapp.template.variable"].create(
+ {
+ "name": "{{2}}",
+ "line_type": "body",
+ "template_id": tmpl.id,
+ "field_name": "phone",
+ }
+ )
+ self.env["mail.whatsapp.template.button"].create(
+ {
+ "name": "phone",
+ "button_type": "phone_number",
+ "template_id": tmpl.id,
+ "call_number": "+34666555444",
+ }
+ )
+ components = tmpl.with_context(**ctx).prepare_value_to_send()
+
+ header = next(c for c in components if c["type"].upper() == "HEADER")
+ self.assertEqual([p["type"] for p in header.get("parameters", [])], ["text"])
+ self.assertEqual(header["parameters"][0]["text"], partner.name)
+
+ body = next(c for c in components if c["type"].upper() == "BODY")
+ self.assertEqual(
+ [p["type"] for p in body.get("parameters", [])], ["text", "text"]
+ )
+ self.assertEqual(body["parameters"][0]["text"], partner.name)
+ self.assertEqual(body["parameters"][1]["text"], partner.phone or "")
diff --git a/mail_gateway_whatsapp/tools/__init__.py b/mail_gateway_whatsapp/tools/__init__.py
new file mode 100644
index 000000000..4c73b5fa5
--- /dev/null
+++ b/mail_gateway_whatsapp/tools/__init__.py
@@ -0,0 +1 @@
+from . import const
diff --git a/mail_gateway_whatsapp/tools/const.py b/mail_gateway_whatsapp/tools/const.py
new file mode 100644
index 000000000..b02ee7202
--- /dev/null
+++ b/mail_gateway_whatsapp/tools/const.py
@@ -0,0 +1,77 @@
+# https://developers.facebook.com/docs/whatsapp/business-management-api/message-templates/supported-languages # noqa: B501 E501
+# res.lang not matching with supported languages(iso codes)
+supported_languages = [
+ ("af", "Afrikaans"),
+ ("sq", "Albanian"),
+ ("ar", "Arabic"),
+ ("az", "Azerbaijani"),
+ ("bn", "Bengali"),
+ ("bg", "Bulgarian"),
+ ("ca", "Catalan"),
+ ("zh_CN", "Chinese (CHN)"),
+ ("zh_HK", "Chinese (HKG)"),
+ ("zh_TW", "Chinese (TAI)"),
+ ("hr", "Croatian"),
+ ("cs", "Czech"),
+ ("da", "Danish"),
+ ("nl", "Dutch"),
+ ("en", "English"),
+ ("en_GB", "English (UK)"),
+ ("en_US", "English (US)"),
+ ("et", "Estonian"),
+ ("fil", "Filipino"),
+ ("fi", "Finnish"),
+ ("fr", "French"),
+ ("ka", "Georgian"),
+ ("de", "German"),
+ ("el", "Greek"),
+ ("gu", "Gujarati"),
+ ("ha", "Hausa"),
+ ("he", "Hebrew"),
+ ("hi", "Hindi"),
+ ("hu", "Hungarian"),
+ ("id", "Indonesian"),
+ ("ga", "Irish"),
+ ("it", "Italian"),
+ ("ja", "Japanese"),
+ ("kn", "Kannada"),
+ ("kk", "Kazakh"),
+ ("rw_RW", "Kinyarwanda"),
+ ("ko", "Korean"),
+ ("ky_KG", "Kyrgyz (Kyrgyzstan)"),
+ ("lo", "Lao"),
+ ("lv", "Latvian"),
+ ("lt", "Lithuanian"),
+ ("mk", "Macedonian"),
+ ("ms", "Malay"),
+ ("ml", "Malayalam"),
+ ("mr", "Marathi"),
+ ("nb", "Norwegian"),
+ ("fa", "Persian"),
+ ("pl", "Polish"),
+ ("pt_BR", "Portuguese (BR)"),
+ ("pt_PT", "Portuguese (POR)"),
+ ("pa", "Punjabi"),
+ ("ro", "Romanian"),
+ ("ru", "Russian"),
+ ("sr", "Serbian"),
+ ("sk", "Slovak"),
+ ("sl", "Slovenian"),
+ ("es", "Spanish"),
+ ("es_AR", "Spanish (ARG)"),
+ ("es_ES", "Spanish (SPA)"),
+ ("es_MX", "Spanish (MEX)"),
+ ("sw", "Swahili"),
+ ("sv", "Swedish"),
+ ("ta", "Tamil"),
+ ("te", "Telugu"),
+ ("th", "Thai"),
+ ("tr", "Turkish"),
+ ("uk", "Ukrainian"),
+ ("ur", "Urdu"),
+ ("uz", "Uzbek"),
+ ("vi", "Vietnamese"),
+ ("zu", "Zulu"),
+]
+
+REG_VARIABLE = r"{{[1-9][0-9]*}}"
diff --git a/mail_gateway_whatsapp/views/ir_actions_server_views.xml b/mail_gateway_whatsapp/views/ir_actions_server_views.xml
new file mode 100644
index 000000000..7149a5eae
--- /dev/null
+++ b/mail_gateway_whatsapp/views/ir_actions_server_views.xml
@@ -0,0 +1,33 @@
+
+
+
+ ir.actions.server.view.form.inherit.mail_gateway_whatsapp
+ ir.actions.server
+
+
+
+
+
+
diff --git a/mail_gateway_whatsapp/views/mail_gateway.xml b/mail_gateway_whatsapp/views/mail_gateway.xml
new file mode 100644
index 000000000..bbb820808
--- /dev/null
+++ b/mail_gateway_whatsapp/views/mail_gateway.xml
@@ -0,0 +1,127 @@
+
+
+
+
+ mail.gateway.form (in mail_gateway_telegram)
+ mail.gateway
+
+
+
+
+
+
+
+
+
+
+
+
+
First steps
+
Define the values of the fields Webhook Key and Whatsapp Security Key .
+ You should set some random value of your choice for this fields.
+ Ensure that facebook will be able to comunicate with your server.
+
Creating the Application from meta developer
+
+ Access
+
+ Meta developer platform .
+ Create a new application.
+ Select the Other option, then Business in order to create Whatsapp manager
+ Select a name and create it
+ Select the Whatsapp API on the products of the application
+ Select the business that you will use
+ Go to Whatsapp / API Configuration menú.
+ Add a new number.
+ Copy the phone identification number to the field Whastapp From phone field.
+ Access the menu Configuration / Basic information .
+ Show the secret key of the application and copy it to the Webhook secret field.
+ Access the menu Configuration / Advanced Options .
+ Copy the API Version on the Whastapp Version field.
+
+
Creating a permanent token
+
+ Access your meta business site.
+ Access your business settings menu
+ Go to Users / System Users and create a new one with administrator
+ Once it is created, Generate a new token related to the created app with no expiry and give access to all whatsapp permissions.
+ Copy the token value to token field in this page.
+
+
Setting webhook and version
+
+ Save this record. All the values have been filled
+ Press the button Integrate webhook.
+ On Facebook Develpment, return to the app menu and go to Whatsapp / Configuration .
+ Click on Edit Button on the webhook area.
+ On the wizard, fill the URL field with Webhook URL field of the gateway. For the verification identifier, use the Whatsapp Security Key field.
+ Verify and save the wizard.
+ If no error is raised, refresh this gateway data, and you should see that it is integrated.
+ You should be able to receive and send messages.
+ If an error is raised, check that the fields are filled properly and that facebook server is able to access your server.
+
+
+
+
+
+
diff --git a/mail_gateway_whatsapp/views/mail_whatsapp_template_views.xml b/mail_gateway_whatsapp/views/mail_whatsapp_template_views.xml
new file mode 100644
index 000000000..2f9052a39
--- /dev/null
+++ b/mail_gateway_whatsapp/views/mail_whatsapp_template_views.xml
@@ -0,0 +1,190 @@
+
+
+
+ view.mail.whatsapp.template.tree
+ mail.whatsapp.template
+
+
+
+
+
+
+
+ view.mail.whatsapp.template.form
+ mail.whatsapp.template
+
+
+
+
+
+
+ view.mail.whatsapp.template.search
+ mail.whatsapp.template
+
+
+
+
+
+
+
+ WhatsApp Templates
+ ir.actions.act_window
+ mail.whatsapp.template
+ list,form
+ [('gateway_id', '=', active_id)]
+ {'default_gateway_id': active_id}
+
+
diff --git a/mail_gateway_whatsapp/wizards/__init__.py b/mail_gateway_whatsapp/wizards/__init__.py
new file mode 100644
index 000000000..47359283f
--- /dev/null
+++ b/mail_gateway_whatsapp/wizards/__init__.py
@@ -0,0 +1,2 @@
+from . import mail_compose_gateway_message
+from . import whatsapp_composer
diff --git a/mail_gateway_whatsapp/wizards/mail_compose_gateway_message.py b/mail_gateway_whatsapp/wizards/mail_compose_gateway_message.py
new file mode 100644
index 000000000..cd24a1b09
--- /dev/null
+++ b/mail_gateway_whatsapp/wizards/mail_compose_gateway_message.py
@@ -0,0 +1,34 @@
+# Copyright 2024 Tecnativa - Carlos López
+# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
+
+import markupsafe
+
+from odoo import api, fields, models
+
+
+class MailComposeGatewayMessage(models.TransientModel):
+ _inherit = "mail.compose.gateway.message"
+
+ whatsapp_template_id = fields.Many2one(
+ "mail.whatsapp.template",
+ domain="""[
+ ('state', '=', 'approved'),
+ ('is_supported', '=', True),
+ ('model', '=', model)
+ ]""",
+ )
+
+ @api.onchange("whatsapp_template_id")
+ def onchange_whatsapp_template_id(self):
+ if self.whatsapp_template_id:
+ self.body = markupsafe.Markup(
+ self.whatsapp_template_id.render_body_message()
+ )
+
+ def _action_send_mail(self, auto_commit=False):
+ if self.whatsapp_template_id:
+ self = self.with_context(
+ whatsapp_template_id=self.whatsapp_template_id.id,
+ res_id=int(self.res_ids.strip("[]")),
+ )
+ return super()._action_send_mail(auto_commit=auto_commit)
diff --git a/mail_gateway_whatsapp/wizards/mail_compose_gateway_message.xml b/mail_gateway_whatsapp/wizards/mail_compose_gateway_message.xml
new file mode 100644
index 000000000..17bb3aa23
--- /dev/null
+++ b/mail_gateway_whatsapp/wizards/mail_compose_gateway_message.xml
@@ -0,0 +1,26 @@
+
+
+
+
+ mail.compose.gateway.message
+
+
+
+
+ whatsapp_template_id
+
+
+ whatsapp_template_id
+
+
+
+
diff --git a/mail_gateway_whatsapp/wizards/whatsapp_composer.py b/mail_gateway_whatsapp/wizards/whatsapp_composer.py
new file mode 100644
index 000000000..967c7bb7a
--- /dev/null
+++ b/mail_gateway_whatsapp/wizards/whatsapp_composer.py
@@ -0,0 +1,111 @@
+# Copyright 2022 CreuBlanca
+# Copyright 2024 Tecnativa - Carlos López
+# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
+from datetime import datetime
+
+from odoo import api, fields, models
+from odoo.exceptions import UserError
+
+
+class WhatsappComposer(models.TransientModel):
+ _name = "whatsapp.composer"
+ _description = "Compose a whatsapp message"
+
+ res_model = fields.Char("Document Model Name")
+ res_id = fields.Integer("Document ID")
+ number_field_name = fields.Char()
+ find_gateway = fields.Boolean()
+ gateway_id = fields.Many2one(
+ "mail.gateway", domain=[("gateway_type", "=", "whatsapp")], required=True
+ )
+ template_id = fields.Many2one(
+ "mail.whatsapp.template",
+ domain="""[
+ ('gateway_id', '=', gateway_id),
+ ('state', '=', 'approved'),
+ ('is_supported', '=', True),
+ ('model', '=', res_model)
+ ]""",
+ )
+ body = fields.Text("Message")
+ is_required_template = fields.Boolean(compute="_compute_is_required_template")
+
+ @api.depends("res_model", "res_id", "number_field_name", "gateway_id")
+ def _compute_is_required_template(self):
+ MailMessage = self.env["mail.message"]
+ for wizard in self:
+ if (
+ not wizard.res_model
+ or not wizard.gateway_id
+ or not wizard.number_field_name
+ ):
+ wizard.is_required_template = False
+ continue
+ record = self.env[wizard.res_model].browse(wizard.res_id)
+ is_required_template = True
+ channel = record._whatsapp_get_channel(
+ wizard.number_field_name, wizard.gateway_id
+ )
+ if channel:
+ last_message = MailMessage.search(
+ [
+ ("gateway_type", "=", "whatsapp"),
+ ("model", "=", channel._name),
+ ("res_id", "=", channel.id),
+ ],
+ order="date desc",
+ limit=1,
+ )
+ if last_message:
+ delta = (datetime.now() - last_message.date).total_seconds() / 3600
+ if delta < 24.0:
+ is_required_template = False
+ wizard.is_required_template = is_required_template
+
+ @api.onchange("gateway_id")
+ def onchange_gateway_id(self):
+ self.template_id = False
+
+ @api.onchange("template_id")
+ def onchange_template_id(self):
+ if self.template_id:
+ self.body = self.template_id.render_body_message()
+
+ @api.model
+ def default_get(self, fields):
+ result = super().default_get(fields)
+ gateways = self.env["mail.gateway"].search([("gateway_type", "=", "whatsapp")])
+ result["find_gateway"] = len(gateways) != 1
+ if not result["find_gateway"]:
+ result["gateway_id"] = gateways.id
+ return result
+
+ def _action_send_whatsapp(self):
+ record = self.env[self.res_model].browse(self.res_id)
+ if not record:
+ return
+ channel = record._whatsapp_get_channel(self.number_field_name, self.gateway_id)
+ channel.with_context(whatsapp_template_id=self.template_id.id).message_post(
+ body=self.body, subtype_xmlid="mail.mt_comment", message_type="comment"
+ )
+
+ def action_view_whatsapp(self):
+ self.ensure_one()
+ record = self.env[self.res_model].browse(self.res_id)
+ if not record:
+ return
+ channel = record._whatsapp_get_channel(self.number_field_name, self.gateway_id)
+ if channel:
+ return {
+ "type": "ir.actions.client",
+ "tag": "mail.action_discuss",
+ "params": {"active_id": f"{channel._name}_{channel.id}"},
+ }
+ return False
+
+ def action_send_whatsapp(self):
+ self.ensure_one()
+ if not self.body:
+ raise UserError(self.env._("Body is required"))
+ self._action_send_whatsapp()
+ return False
diff --git a/mail_gateway_whatsapp/wizards/whatsapp_composer.xml b/mail_gateway_whatsapp/wizards/whatsapp_composer.xml
new file mode 100644
index 000000000..03965f23c
--- /dev/null
+++ b/mail_gateway_whatsapp/wizards/whatsapp_composer.xml
@@ -0,0 +1,48 @@
+
+
+
+
+ whatsapp.composer.form (in mail_gateway_whatsapp)
+ whatsapp.composer
+
+
+
+
+
+
+ Send Whatsapp Message
+ whatsapp.composer
+ form
+ {}
+ new
+
+
diff --git a/requirements.txt b/requirements.txt
index 3e01d6c06..154935992 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -2,3 +2,4 @@
cairosvg
lottie
python-telegram-bot
+requests_toolbelt
+
+