libervia-backend: libervia/backend/plugins/plugin_comp_email_gateway/__init_

comparison libervia/backend/plugins/plugin_comp_email_gateway/init.py @ 4309:b56b1eae7994

component email gateway: add multicasting: XEP-0033 multicasting is now supported both for incoming and outgoing messages. XEP-0033 metadata are converted to suitable Email headers and vice versa. Email address and JID are both supported, and delivery is done by the gateway when suitable on incoming messages. rel 450

author	Goffi <goffi@goffi.org>
date	Thu, 26 Sep 2024 16:12:01 +0200
parents	a7ec325246fb
children	055930cc81f9

comparison

equal deleted inserted replaced

-:472a938a46e3
+:b56b1eae7994
 # GNU Affero General Public License for more details.
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
-from dataclasses import dataclass
 from email.header import decode_header
 from email.message import EmailMessage
 from email.mime.text import MIMEText
-from email.utils import formataddr, parseaddr
+from email.utils import formataddr, getaddresses, parseaddr
 from functools import partial
 import re
-from typing import Any, cast
+from typing import cast
+from pydantic import BaseModel
 from twisted.internet import defer, reactor
 from twisted.mail import smtp
 from twisted.words.protocols.jabber import jid
+from twisted.words.protocols.jabber import error as jabber_error
 from twisted.words.protocols.jabber.error import StanzaError
 from twisted.words.protocols.jabber.xmlstream import XMPPHandler
 from twisted.words.xish import domish
 from wokkel import data_form, disco, iwokkel
 from zope.interface import implementer
 from libervia.backend.core.log import getLogger
 from libervia.backend.memory.persistent import LazyPersistentBinaryDict
 from libervia.backend.memory.sqla import select
 from libervia.backend.memory.sqla_mapping import PrivateIndBin
 from libervia.backend.models.core import MessageData
+from libervia.backend.plugins.plugin_xep_0033 import (
+RECIPIENT_FIELDS,
+AddressType,
+AddressesData,
+)
 from libervia.backend.plugins.plugin_xep_0077 import XEP_0077
 from libervia.backend.plugins.plugin_xep_0106 import XEP_0106
 from libervia.backend.tools.utils import aio
 from .models import Credentials, UserData
 C.PI_NAME: "Email Gateway Component",
 C.PI_IMPORT_NAME: IMPORT_NAME,
 C.PI_MODES: [C.PLUG_MODE_COMPONENT],
 C.PI_TYPE: C.PLUG_TYPE_ENTRY_POINT,
 C.PI_PROTOCOLS: [],
-C.PI_DEPENDENCIES: ["XEP-0077", "XEP-0106"],
+C.PI_DEPENDENCIES: ["XEP-0033", "XEP-0077", "XEP-0106"],
 C.PI_RECOMMENDATIONS: [],
 C.PI_MAIN: "EmailGatewayComponent",
 C.PI_HANDLER: C.BOOL_TRUE,
 C.PI_DESCRIPTION: D_(
 "Gateway to handle email. Usual emails are handled as message, while mailing "
 CONF_SECTION = f"component {IMPORT_NAME}"
 PREFIX_KEY_CREDENTIALS = "CREDENTIALS_"
 KEY_CREDENTIALS = f"{PREFIX_KEY_CREDENTIALS}{{from_jid}}"
 email_pattern = re.compile(r"[^@]+@[^@]+\.[^@]+")
+class SendMailExtra(BaseModel):
+addresses: AddressesData | None = None
 class EmailGatewayComponent:
 IMPORT_NAME = IMPORT_NAME
 verbose = 0
 @return: Message data.
 """
 if client != self.client:
 return mess_data
 from_jid = mess_data["from"].userhostJID()
+extra = None
 if mess_data["type"] not in ("chat", "normal"):
 log.warning(f"ignoring message with unexpected type: {mess_data}")
 return mess_data
 if not client.is_local(from_jid):
 log.warning(f"ignoring non local message: {mess_data}")
 return mess_data
 if not mess_data["to"].user:
-log.warning(f"ignoring message addressed to gateway itself: {mess_data}")
+addresses = mess_data["extra"].get("addresses")
-return mess_data
+if not addresses:
+log.warning(f"ignoring message addressed to gateway itself: {mess_data}")
-try:
+return mess_data
-to_email = self._e.unescape(mess_data["to"].user)
+else:
-except ValueError:
+to_email = None
-raise exceptions.DataError(
+extra = SendMailExtra(addresses=addresses)
-f'Invalid "to" JID, can\'t send message: {message_elt.toXml()}.'
+else:
-)
+try:
+to_email = self._e.unescape(mess_data["to"].user)
+except ValueError:
+raise exceptions.DataError(
+f'Invalid "to" JID, can\'t send message: {message_elt.toXml()}.'
+)
 try:
 body_lang, body = next(iter(mess_data["message"].items()))
 except (KeyError, StopIteration):
 log.warning(f"No body found: {mess_data}")
 await self.send_email(
 from_jid=from_jid,
 to_email=to_email,
 body=body,
 subject=subject,
+extra=extra,
 )
 except exceptions.UnknownEntityError:
 log.warning(f"Can't send message, user {from_jid} is not registered.")
 message_error_elt = StanzaError(
 "subscription-required",
 text="User need to register to the gateway before sending emails.",
 ).toResponse(message_elt)
 await client.a_send(message_error_elt)
 raise exceptions.CancelError("User not registered.")
+except StanzaError as e:
+log.warning("Can't send message: {e}")
+message_error_elt = e.toResponse(message_elt)
+await client.a_send(message_error_elt)
+raise exceptions.CancelError("Can't send message: {e}")
 return mess_data
+def jid_to_email(
+self, client: SatXMPPEntity, address_jid: jid.JID, credentials: dict[str, str]
+) -> str:
+"""Convert a JID to an email address.
+If JID is from the gateway, email address will be extracted. Otherwise, the
+gateway email will be used, with XMPP address specified in name part.
+@param address_jid: JID of the recipient.
+@param credentials: Sender credentials.
+@return: Email address.
+"""
+if address_jid and address_jid.host.endswith(str(client.jid)):
+return self._e.unescape(address_jid.user)
+else:
+email_address = credentials["user_email"]
+if address_jid:
+email_address = formataddr((f"xmpp:{address_jid}", email_address))
+return email_address
 async def send_email(
 self,
 from_jid: jid.JID,
-to_email: str,
+to_email: str | None,
 body: str,
 subject: str | None,
+extra: SendMailExtra | None = None,
 ) -> None:
 """Send an email using sender credentials.
 Credentials will be retrieve from cache, or database.
 @param from_jid: Bare JID of the sender.
 @param to_email: Email address of the destinee.
 @param body: Body of the email.
 @param subject: Subject of the email.
+@param extra: Extra data.
 @raise exceptions.UnknownEntityError: Credentials for "from_jid" can't be found.
 """
+assert self.client is not None
+if extra is None:
+extra = SendMailExtra()
+if to_email is None and (extra.addresses is None or not extra.addresses.to):
+raise exceptions.InternalError(
+'"to_email" can\'t be None if there is no "to" address!'
+)
 # We need a bare jid.
 assert self.storage is not None
 assert not from_jid.resource
 try:
 user_data = self.users_data[from_jid]
 if subject is not None:
 msg["Subject"] = subject
 msg["From"] = formataddr(
 (credentials["user_name"] or None, credentials["user_email"])
 )
-msg["To"] = to_email
+if extra.addresses:
+assert extra.addresses.to
+main_to_address = extra.addresses.to[0]
+assert main_to_address.jid
+to_email = self.jid_to_email(self.client, main_to_address.jid, credentials)
+for field in RECIPIENT_FIELDS:
+addresses = getattr(extra.addresses, field)
+if not addresses:
+continue
+for address in addresses:
+if not address.delivered and (
+address.jid is None or address.jid.host != str(self.client.jid)
+):
+log.warning(
+"Received undelivered message to external JID, this is not "
+"allowed! Cancelling the message sending."
+)
+stanza_err = jabber_error.StanzaError(
+"forbidden",
+text="Multicasting (XEP-0033 addresses) can only be used "
+"with JID from this gateway, not external ones. "
+f" {address.jid} can't be delivered by this gateway and "
+"should be delivered by server instead.",
+)
+raise stanza_err
+email_addresses = [
+self.jid_to_email(self.client, address.jid, credentials)
+for address in addresses
+if address.jid
+]
+if email_addresses:
+msg[field.upper()] = ", ".join(email_addresses)
+else:
+assert to_email is not None
+msg["To"] = to_email
 sender_domain = credentials["user_email"].split("@", 1)[-1]
 await smtp.sendmail(
 credentials["smtp_host"].encode(),
 submit_form, "smtp_port", "int", min_value=1, max_value=65535, default=587
 )
 self.validate_field(submit_form, "smtp_username", "str")
 self.validate_field(submit_form, "smtp_password", "str")
-async def on_new_email(self, to_jid: jid.JID, email: EmailMessage) -> None:
+def email_to_jid(
+self,
+client: SatXMPPEntity,
+user_email: str,
+user_jid: jid.JID,
+email_name: str,
+email_addr: str,
+) -> tuple[jid.JID, str | None]:
+"""Convert an email address to a JID and extract the name if present.
+@param client: Client session.
+@param user_email: Email address of the gateway user.
+@param user_jid: JID of the gateway user.
+@param email_name: Email associated name.
+@param email_addr: Email address.
+@return: Tuple of JID and name (if present).
+"""
+email_name = email_name.strip()
+if email_name.startswith("xmpp:"):
+return jid.JID(email_name[5:]), None
+elif email_addr == user_email:
+return (user_jid, None)
+else:
+return (
+jid.JID(None, (self._e.escape(email_addr), client.jid.host, None)),
+email_name or None,
+)
+async def on_new_email(
+self, user_data: UserData, user_jid: jid.JID, email: EmailMessage
+) -> None:
 """Called when a new message has been received.
-@param to_jid: JID of the recipient.
+@param user_data: user data, used to map registered user email to corresponding
+jid.
+@param user_jid: JID of the recipient.
 @param email: Parsed email.
 """
 assert self.client is not None
+user_email = user_data.credentials["user_email"]
 name, email_addr = parseaddr(email["from"])
 email_addr = email_addr.lower()
 from_jid = jid.JID(None, (self._e.escape(email_addr), self.client.jid.host, None))
 # Get the email body
 ]
 ).strip()
 else:
 subject = None
+# Parse recipient fields
+kwargs = {}
+for field in RECIPIENT_FIELDS:
+email_addresses = email.get_all(field)
+if email_addresses:
+jids_and_names = [
+self.email_to_jid(self.client, user_email, user_jid, name, addr)
+for name, addr in getaddresses(email_addresses)
+]
+kwargs[field] = [
+AddressType(jid=jid, desc=name) for jid, name in jids_and_names
+]
+# At least "to" header should be set, so kwargs should never be empty
+assert kwargs
+addresses_data = AddressesData(**kwargs)
+# Parse reply-to field
+reply_to_addresses = email.get_all("reply-to")
+if reply_to_addresses:
+jids_with_names = [
+self.email_to_jid(self.client, user_email, user_jid, name, addr)
+for name, addr in getaddresses(reply_to_addresses)
+]
+addresses_data.replyto = [
+AddressType(jid=jid, desc=name) for jid, name in jids_with_names
+]
+# Set noreply flag
+# The is no flag to indicate a no-reply message, so we check common user parts in
+# from and reply-to headers.
+from_addresses = [email_addr]
+if reply_to_addresses:
+from_addresses.extend(
+addr for a in reply_to_addresses if (addr := parseaddr(a)[1])
+)
+for from_address in from_addresses:
+from_user_part = from_address.split("@", 1)[0].lower()
+if from_user_part in (
+"no-reply",
+"noreply",
+"do-not-reply",
+"donotreply",
+"notification",
+"notifications",
+):
+addresses_data.noreply = True
+break
+if (
+not addresses_data.replyto
+and not addresses_data.noreply
+and not addresses_data.cc
+and not addresses_data.bcc
+and addresses_data.to == [AddressType(jid=user_jid)]
+):
+# The main recipient is the only one, and there is no other metadata: there is
+# no need to add addresses metadata.
+extra = None
+else:
+for address in addresses_data.addresses:
+if address.jid and (
+address.jid == user_jid or address.jid.host == str(self.client.jid)
+):
+# Those are email address, and have been delivered by the sender,
+# other JID addresses will have to be delivered by us.
+address.delivered = True
+extra = {
+"addresses": addresses_data.model_dump(mode="json", exclude_none=True)
+}
 client = self.client.get_virtual_client(from_jid)
-await client.sendMessage(to_jid, {"": body}, {"": subject} if subject else None)
+await client.sendMessage(
+user_jid,
+{"": body},
+{"": subject} if subject else None,
+extra=extra,
+)
 async def connect_imap(self, from_jid: jid.JID, user_data: UserData) -> None:
 """Connect to IMAP service.
 [self.on_new_email] will be used as callback on new messages.
 credentials = user_data.credentials
 connected = defer.Deferred()
 factory = IMAPClientFactory(
 user_data,
-partial(self.on_new_email, from_jid.userhostJID()),
+partial(self.on_new_email, user_data, from_jid.userhostJID()),
 connected,
 )
 reactor.connectTCP(
 credentials["imap_host"], int(credentials["imap_port"]), factory
 )

Mercurial > libervia-backend

comparison libervia/backend/plugins/plugin_comp_email_gateway/__init__.py @ 4309:b56b1eae7994

comparison libervia/backend/plugins/plugin_comp_email_gateway/init.py @ 4309:b56b1eae7994