odoo-addon-mail-gateway 16.0.1.0.0.2__py3-none-any.whl

odoo/addons/mail_gateway/models/mail_gateway.py

@@ -0,0 +1,149 @@
+# Copyright 2024 Dixmit
+# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
+from odoo import Command, api, fields, models, tools
+
+
+class MailGateway(models.Model):
+    _name = "mail.gateway"
+    _description = "Mail Gateway"
+
+    name = fields.Char(required=True)
+    token = fields.Char(required=True, help="Key used for integration purposes")
+    gateway_type = fields.Selection([], required=True)
+    webhook_key = fields.Char(help="Key used on the connection URL")
+    webhook_secret = fields.Char(
+        help="""Key used to ensure that the connection is secure and
+        comes from the desired source"""
+    )
+    integrated_webhook_state = fields.Selection(
+        [("pending", "Pending"), ("integrated", "Integrated")], readonly=True
+    )
+    can_set_webhook = fields.Boolean(compute="_compute_webhook_checks")
+    webhook_url = fields.Char(compute="_compute_webhook_url")
+    has_new_channel_security = fields.Boolean(
+        help="When checked, channels are not created automatically. Usable on Telegram"
+    )
+    webhook_user_id = fields.Many2one(
+        "res.users",
+        default=lambda self: self.env.user.id,
+        help="User that will create the messages",
+    )
+    member_ids = fields.Many2many(
+        "res.users", default=lambda self: [Command.link(self.env.user.id)]
+    )
+    company_id = fields.Many2one(
+        "res.company", default=lambda self: self.env.company.id
+    )
+
+    _sql_constraints = [
+        ("mail_gateway_token", "unique(token)", "Token must be unique"),
+        (
+            "mail_gateway_webhook_key",
+            "unique(webhook_key)",
+            "Webhook Key must be unique",
+        ),
+    ]
+
+    @api.depends("webhook_key")
+    def _compute_webhook_url(self):
+        for record in self:
+            record.webhook_url = record._get_webhook_url()
+
+    def _get_channel_id(self, chat_token):
+        return (
+            self.env["mail.channel"]
+            .search(
+                [
+                    ("gateway_channel_token", "=", str(chat_token)),
+                    ("gateway_id", "=", self.id),
+                ],
+                limit=1,
+            )
+            .id
+        )
+
+    def _get_webhook_url(self):
+        return "%s/gateway/%s/%s/update" % (
+            self.webhook_url
+            or self.env["ir.config_parameter"].get_param("web.base.url"),
+            self.gateway_type,
+            self.webhook_key,
+        )
+
+    def _can_set_webhook(self):
+        return self.webhook_key and self.webhook_user_id
+
+    @api.depends("gateway_type")
+    def _compute_webhook_checks(self):
+        for record in self:
+            record.can_set_webhook = record._can_set_webhook()
+
+    def set_webhook(self):
+        self.ensure_one()
+        if self.can_set_webhook:
+            self.env["mail.gateway.%s" % self.gateway_type]._set_webhook(self)
+
+    def remove_webhook(self):
+        self.ensure_one()
+        self.env["mail.gateway.%s" % self.gateway_type]._remove_webhook(self)
+
+    def update_webhook(self):
+        self.ensure_one()
+        self.remove_webhook()
+        self.set_webhook()
+
+    def write(self, vals):
+        res = super(MailGateway, self).write(vals)
+        if (
+            "webhook_key" in vals
+            or "integrated_webhook_state" in vals
+            or "webhook_secret" in vals
+            or "webhook_user_id" in vals
+        ):
+            self.clear_caches()
+        return res
+
+    @api.model_create_multi
+    def create(self, mvals):
+        res = super(MailGateway, self).create(mvals)
+        self.clear_caches()
+        return res
+
+    @api.model
+    @tools.ormcache()
+    def _get_gateway_map(self, state="integrated", gateway_type=False):
+        result = {}
+        for record in self.search(
+            [
+                ("integrated_webhook_state", "=", state),
+                ("gateway_type", "=", gateway_type),
+            ]
+        ):
+            result[record.webhook_key] = record._get_gateway_data()
+        return result
+
+    def _get_gateway_data(self):
+        return {
+            "id": self.id,
+            "webhook_secret": self.webhook_secret,
+            "webhook_user_id": self.webhook_user_id.id,
+        }
+
+    @api.model
+    def _get_gateway(self, key, state="integrated", gateway_type=False):
+        # We are using cache in order to avoid an exploit
+        if not key:
+            return False
+        return self._get_gateway_map(state=state, gateway_type=gateway_type).get(
+            key, False
+        )
+
+    def gateway_info(self):
+        return [record._gateway_info() for record in self]
+
+    def _gateway_info(self):
+        return {
+            "id": self.id,
+            "name": self.name,
+            "type": self.gateway_type,
+        }

odoo/addons/mail_gateway/models/mail_gateway_abstract.py

@@ -0,0 +1,82 @@
+# Copyright 2024 Dixmit
+# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
+from odoo import Command, models
+
+
+class MailGatewayAbstract(models.AbstractModel):
+    _name = "mail.gateway.abstract"
+    _description = "Gateway abstract for functions"
+
+    def _verify_update(self, bot_data, kwargs):
+        return True
+
+    def _receive_update(self, gateway, kwargs):
+        pass
+
+    def _post_process_message(self, message, channel):
+        self.env["mail.notification"].search(
+            [("gateway_channel_id", "=", channel.id), ("is_read", "=", False)]
+        )._set_read_gateway()
+
+    def _post_process_reply(self, related_message):
+        pass
+
+    def _update_content_after_hook(self, channel, message):
+        pass
+
+    def _set_webhook(self, gateway):
+        gateway.integrated_webhook_state = "integrated"
+
+    def _remove_webhook(self, gateway):
+        gateway.integrated_webhook_state = False
+
+    def _get_channel(self, gateway, token, update, force_create=False):
+        chat_id = gateway._get_channel_id(token)
+        if chat_id:
+            return gateway.env["mail.channel"].browse(chat_id)
+        if not force_create and gateway.has_new_channel_security:
+            return False
+        channel = gateway.env["mail.channel"].create(
+            self._get_channel_vals(gateway, token, update)
+        )
+        channel._broadcast(channel.channel_member_ids.mapped("partner_id").ids)
+        return channel
+
+    def _get_author(self, gateway, update):
+        return False
+
+    def _get_channel_vals(self, gateway, token, update):
+        author = self._get_author(gateway, update)
+        members = [
+            Command.create({"partner_id": partner.id, "is_pinned": True})
+            for partner in gateway.member_ids.partner_id
+        ]
+        if author:
+            members.append(
+                Command.create(
+                    {
+                        "partner_id": author._name == "res.partner" and author.id,
+                        "guest_id": author._name == "mail.guest" and author.id,
+                    }
+                )
+            )
+        return {
+            "gateway_channel_token": token,
+            "gateway_id": gateway.id,
+            "channel_type": "gateway",
+            "channel_member_ids": members,
+            "company_id": gateway.company_id.id,
+        }
+
+    def _send(
+        self,
+        gateway,
+        record,
+        auto_commit=False,
+        raise_exception=False,
+        parse_mode=False,
+    ):
+        raise NotImplementedError()
+
+    def _get_message_body(self, record):
+        return record.mail_message_id.body

odoo/addons/mail_gateway/models/mail_guest.py

@@ -0,0 +1,18 @@
+# Copyright 2024 Dixmit
+# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
+
+from odoo import fields, models
+
+
+class MailGuest(models.Model):
+    _inherit = "mail.guest"
+
+    gateway_id = fields.Many2one("mail.gateway")
+    gateway_token = fields.Char()
+
+    def _guest_format(self, fields=None):
+        result = super()._guest_format(fields=fields)
+        if not fields or "gateway_id" in fields:
+            for guest in result:
+                result[guest]["gateway"] = {"id": guest.gateway_id.id}
+        return result

odoo/addons/mail_gateway/models/mail_message.py

@@ -0,0 +1,123 @@
+# Copyright 2024 Dixmit
+# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
+
+
+from odoo import api, fields, models
+
+
+class MailMessage(models.Model):
+
+    _inherit = "mail.message"
+
+    gateway_type = fields.Selection(
+        selection=lambda r: r.env["mail.gateway"]._fields["gateway_type"].selection
+    )
+    gateway_notification_ids = fields.One2many(
+        "mail.notification",
+        inverse_name="mail_message_id",
+        domain=[("notification_type", "=", "gateway")],
+    )
+    gateway_channel_ids = fields.Many2many(
+        "res.partner.gateway.channel", compute="_compute_gateway_channel_ids"
+    )
+    gateway_channel_data = fields.Json(compute="_compute_gateway_channel_ids")
+    gateway_message_ids = fields.One2many(
+        "mail.message",
+        inverse_name="gateway_message_id",
+        string="Child gateway messages",
+    )
+    gateway_message_id = fields.Many2one(
+        "mail.message", string="Original gateway message"
+    )
+    gateway_thread_data = fields.Json(compute="_compute_gateway_thread_data")
+
+    @api.depends("gateway_message_id")
+    def _compute_gateway_thread_data(self):
+        for record in self:
+            gateway_thread_data = {}
+            if record.gateway_message_id:
+                gateway_thread_data.update(
+                    {
+                        "name": record.gateway_message_id.record_name,
+                        "id": record.gateway_message_id.res_id,
+                        "model": record.gateway_message_id.model,
+                    }
+                )
+            record.gateway_thread_data = gateway_thread_data
+
+    @api.depends("notification_ids", "gateway_message_ids")
+    def _compute_gateway_channel_ids(self):
+        for record in self:
+            if self.env.user.has_group("mail_gateway.gateway_user"):
+                channels = record.notification_ids.res_partner_id.gateway_channel_ids.filtered(
+                    lambda r: (r.gateway_token, r.gateway_id.id)
+                    not in [
+                        (
+                            notification.gateway_channel_id.gateway_channel_token,
+                            notification.gateway_channel_id.gateway_id.id,
+                        )
+                        for notification in record.gateway_message_ids.gateway_notification_ids
+                    ]
+                )
+            else:
+                channels = self.env["res.partner.gateway.channel"]
+            record.gateway_channel_ids = channels
+            record.gateway_channel_data = {
+                "channels": channels.ids,
+                "partners": channels.partner_id.ids,
+            }
+
+    @api.depends("gateway_notification_ids")
+    def _compute_gateway_channel_id(self):
+        for rec in self:
+            if rec.gateway_notification_ids:
+                rec.gateway_channel_id = rec.gateway_notification_ids[
+                    0
+                ].gateway_channel_id
+
+    def _get_message_format_fields(self):
+        result = super()._get_message_format_fields()
+        result.append("gateway_type")
+        result.append("gateway_channel_data")
+        result.append("gateway_thread_data")
+        return result
+
+    def _send_to_gateway_thread(self, gateway_channel_id):
+        chat_id = gateway_channel_id.gateway_id._get_channel_id(
+            gateway_channel_id.gateway_token
+        )
+        channel = self.env["mail.channel"].browse(chat_id)
+        channel.message_post(**self._get_gateway_thread_message_vals())
+        if not self.gateway_type:
+            self.gateway_type = gateway_channel_id.gateway_id.gateway_type
+        self.env["mail.notification"].create(
+            {
+                "notification_status": "sent",
+                "mail_message_id": self.id,
+                "gateway_channel_id": channel.id,
+                "notification_type": "gateway",
+                "gateway_type": gateway_channel_id.gateway_id.gateway_type,
+            }
+        )
+        self.env["bus.bus"]._sendone(
+            self.env.user.partner_id,
+            "mail.message/insert",
+            {
+                "id": self.id,
+                "gateway_type": self.gateway_type,
+                "notifications": self.sudo()
+                .notification_ids._filtered_for_web_client()
+                ._notification_format(),
+            },
+        )
+        return {}
+
+    def _get_gateway_thread_message_vals(self):
+        return {
+            "body": self.body,
+            "attachment_ids": self.attachment_ids.ids,
+            "subtype_id": self.subtype_id.id,
+            "author_id": self.env.user.partner_id.id,
+            "gateway_message_id": self.id,
+            "message_type": "comment",
+        }

odoo/addons/mail_gateway/models/mail_notification.py

@@ -0,0 +1,43 @@
+# Copyright 2024 Dixmit
+# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
+
+from odoo import fields, models
+
+
+class MailNotification(models.Model):
+    _inherit = "mail.notification"
+
+    gateway_channel_id = fields.Many2one("mail.channel")
+    notification_type = fields.Selection(
+        selection_add=[("gateway", "Gateway")], ondelete={"gateway": "cascade"}
+    )
+    gateway_message_id = fields.Char(readonly=True)
+    gateway_failure_reason = fields.Text(
+        readonly=1,
+        help="Failure reason. This is usually the exception thrown by the"
+        " email server, stored to ease the debugging of mailing issues.",
+    )
+    gateway_type = fields.Selection(
+        selection=lambda r: r.env["mail.gateway"]._fields["gateway_type"].selection
+    )
+
+    def _set_read_gateway(self):
+        self.sudo().write({"is_read": True, "read_date": fields.Datetime.now()})
+
+    def _notification_format(self):
+        result = super()._notification_format()
+        for record, formatted_value in zip(self, result):
+            formatted_value["gateway_type"] = record.gateway_type
+            formatted_value["channel_name"] = record.gateway_channel_id.name
+        return result
+
+    def send_gateway(self, auto_commit=False, raise_exception=False, parse_mode="HTML"):
+        for record in self:
+            gateway = record.gateway_channel_id.gateway_id
+            self.env["mail.gateway.%s" % gateway.gateway_type]._send(
+                gateway,
+                record,
+                auto_commit=auto_commit,
+                raise_exception=raise_exception,
+                parse_mode=parse_mode,
+            )

odoo/addons/mail_gateway/models/mail_thread.py

@@ -0,0 +1,85 @@
+# Copyright 2024 Dixmit
+# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
+from odoo import models
+
+
+class MailThread(models.AbstractModel):
+    _inherit = "mail.thread"
+
+    def _notify_thread_by_email(self, message, recipients_data, **kwargs):
+        partners_data = [r for r in recipients_data if r["notif"] == "gateway"]
+        if partners_data:
+            self._notify_thread_by_gateway(message, partners_data, **kwargs)
+        return super()._notify_thread_by_email(message, recipients_data, **kwargs)
+
+    def _notify_thread_by_gateway(self, message, partners_data, **kwargs):
+        for partner_data in partners_data:
+            if partner_data["notif"] != "gateway" or not partner_data.get(
+                "gateway_channel_id"
+            ):
+                continue
+            message._send_to_gateway_thread(
+                self.env["res.partner.gateway.channel"].browse(
+                    partner_data.get("gateway_channel_id")
+                )
+            )
+
+    def _notify_get_recipients(self, message, msg_vals, **kwargs):
+        if "gateway_notifications" in kwargs:
+            result = []
+            for notification in kwargs["gateway_notifications"]:
+                if not notification.get("channel_type"):
+                    continue
+                partner = self.env["res.partner"].browse(notification["partner_id"])
+                user = partner.user_ids
+                follower_data = {
+                    "active": partner.active,
+                    "id": partner.id,
+                    "is_follower": True,
+                    "lang": partner.lang,
+                    "groups": set(user.groups_id.ids),
+                    "notif": notification.get("channel_type"),
+                    "share": partner.partner_share,
+                    "uid": user[:1].id,
+                    "ushare": user and any(user.mapped("share")),
+                    "gateway_channel_id": notification.get("gateway_channel_id"),
+                }
+                if follower_data["ushare"]:  # any type of share user
+                    follower_data["type"] = "portal"
+                elif follower_data[
+                    "share"
+                ]:  # no user, is share -> customer (partner only)
+                    follower_data["type"] = "customer"
+                else:  # has a user not share -> internal user
+                    follower_data["type"] = "user"
+                result.append(follower_data)
+            return result
+        return super()._notify_get_recipients(message, msg_vals, **kwargs)
+
+    def _check_can_update_message_content(self, messages):
+        # We can delete the messages comming from a gateway on not channels
+        if self._name != "mail.channel":
+            new_messages = messages.filtered(lambda r: not r.gateway_message_ids)
+        else:
+            new_messages = messages
+        return super()._check_can_update_message_content(new_messages)
+
+    def _message_update_content(
+        self, message, body, attachment_ids=None, strict=True, **kwargs
+    ):
+        result = super()._message_update_content(
+            message, body, attachment_ids=attachment_ids, strict=strict, **kwargs
+        )
+        if body == "":
+            # Unlink the message
+            for gateway_message in message.gateway_message_ids:
+                gateway_message.gateway_message_id = False
+                self.env["bus.bus"]._sendone(
+                    self.env.user.partner_id,
+                    "mail.message/insert",
+                    {
+                        "id": gateway_message.id,
+                        "gateway_thread_data": gateway_message.sudo().gateway_thread_data,
+                    },
+                )
+        return result

odoo/addons/mail_gateway/models/res_partner.py

@@ -0,0 +1,89 @@
+# Copyright 2024 Dixmit
+# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
+
+from odoo import fields, models
+
+
+class ResPartner(models.Model):
+    """Update of res.partner class to take into account the gateway."""
+
+    _inherit = "res.partner"
+
+    gateway_channel_ids = fields.One2many(
+        "res.partner.gateway.channel", inverse_name="partner_id"
+    )
+
+    def mail_partner_format(self, fields=None):
+        """Override to add gateway info."""
+        partners_format = super().mail_partner_format(fields=fields)
+        if not fields:
+            fields = {"gateway_channel_ids": True}
+        for partner in self:
+            if "gateway_channel_ids" in fields:
+                partners_format.get(partner).update(
+                    {
+                        "gateway_channels": partner.gateway_channel_ids.mail_format(),
+                    }
+                )
+        return partners_format
+
+    def _get_channels_as_member(self):
+        channels = super()._get_channels_as_member()
+        if self.env.user.has_group("mail_gateway.gateway_user"):
+            channels |= self.env["mail.channel"].search(
+                [
+                    ("channel_type", "=", "gateway"),
+                    (
+                        "channel_member_ids",
+                        "in",
+                        self.env["mail.channel.member"]
+                        .sudo()
+                        ._search(
+                            [
+                                ("partner_id", "=", self.id),
+                                ("is_pinned", "=", True),
+                            ]
+                        ),
+                    ),
+                ]
+            )
+        return channels
+
+
+class ResPartnerGatewayChannel(models.Model):
+    _name = "res.partner.gateway.channel"
+    _description = "Technical data used to get the gateway author"
+
+    name = fields.Char(related="gateway_id.name")
+    partner_id = fields.Many2one(
+        "res.partner", required=True, readonly=True, ondelete="cascade"
+    )
+    gateway_id = fields.Many2one(
+        "mail.gateway", required=True, readonly=True, ondelete="cascade"
+    )
+    gateway_token = fields.Char(readonly=True)
+    company_id = fields.Many2one(
+        "res.company", related="gateway_id.company_id", store=True
+    )
+
+    _sql_constraints = [
+        (
+            "unique_partner_gateway",
+            "UNIQUE(partner_id, gateway_id)",
+            "Partner can only have one configuration for each gateway.",
+        ),
+    ]
+
+    def mail_format(self):
+        return [r._mail_format() for r in self]
+
+    def _mail_format(self):
+        return {
+            "id": self.id,
+            "name": self.name,
+            "gateway": {
+                "id": self.gateway_id.id,
+                "name": self.gateway_id.name,
+                "type": self.gateway_id.gateway_type,
+            },
+        }

odoo/addons/mail_gateway/models/res_users.py

@@ -0,0 +1,16 @@
+# Copyright 2024 Dixmit
+# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
+
+from odoo import fields, models
+
+
+class ResUsers(models.Model):
+
+    _inherit = "res.users"
+
+    gateway_ids = fields.Many2many("mail.gateway")
+
+    def _init_messaging(self):
+        result = super()._init_messaging()
+        result["gateways"] = self.gateway_ids.gateway_info()
+        return result

odoo/addons/mail_gateway/readme/CONFIGURATION.rst

@@ -0,0 +1,4 @@
+- Access in development mode
+- Go to `Settings / Technical / Email / Gateway`
+- Create a gateway. Follow the instruction of the specific tab in order to integrate it.
+- Start receiving notifications

odoo/addons/mail_gateway/readme/CONTRIBUTORS.rst

@@ -0,0 +1,2 @@
+* Enric Tobella
+* Olga Marco

odoo/addons/mail_gateway/readme/CREDITS.rst

@@ -0,0 +1 @@
+This work has been funded by AEOdoo (Asociación Española de Odoo - https://www.aeodoo.org)

odoo/addons/mail_gateway/readme/DESCRIPTION.rst

@@ -0,0 +1,5 @@
+This module will allow you to integrate an external chat system in your Odoo system.
+It requires extra modules with the specific configuration of each chat system, like `mail_gateway_telegram` or `mail_gateway_whatsapp`.
+
+This way, a group of users can respond customers or any other set
+of partners within Odoo, but the messages will be sent through the external chat system.

odoo/addons/mail_gateway/readme/USAGE.rst

@@ -0,0 +1,9 @@
+When external messages are received, they will be directly sent to the discuss menu.
+Answering to these messages will send the answer to the external contact.
+We can assign this messages to any record using the message actions.
+Also, we can assign the sender to a partner using the followers menu and selecting the partner.
+
+On a standard record associated to a partner with external chat, we can send messages to the external contact directly selecting the methods of the partner.
+To use this, we just need to use the
+
+It is recomended to enable chatter notification to all users that will receive messages from gateways.

odoo/addons/mail_gateway/security/ir.model.access.csv

@@ -0,0 +1,9 @@
+id,name,model_id:id,group_id:id,perm_read,perm_write,perm_create,perm_unlink
+access_res_partner_gateway_channel_portal,res.partner.gateway.channel.portal,model_res_partner_gateway_channel,base.group_portal,1,0,0,0
+access_res_partner_gateway_channel_user,res.partner.gateway.channel,model_res_partner_gateway_channel,base.group_user,1,0,0,0
+manage_res_partner_gateway_channel_user,res.partner.gateway.channel,model_res_partner_gateway_channel,gateway_user,1,1,1,1
+access_mail_message_gateway_send_user,mail.message.gateway.send,model_mail_message_gateway_send,base.group_user,1,1,1,0
+access_mail_gateway_all,mail.telegram.bot.all,model_mail_gateway,,1,0,0,0
+access_mail_guest_manage,mail.telegram.bot.all,model_mail_guest_manage,base.group_user,1,1,1,1
+access_mail_message_gateway_link,mail.message.link.all,model_mail_message_gateway_link,base.group_user,1,1,1,1
+access_mail_gateway_system,mail_gateway,model_mail_gateway,base.group_system,1,1,1,1