iatoolkit 0.3.9__py3-none-any.whl → 0.107.4__py3-none-any.whl

iatoolkit/services/mail_service.py

@@ -0,0 +1,213 @@
+# Copyright (c) 2024 Fernando Libedinsky
+# Product: IAToolkit
+#
+# IAToolkit is open source software.
+
+from iatoolkit.services.configuration_service import ConfigurationService
+from iatoolkit.services.i18n_service import I18nService
+from iatoolkit.infra.brevo_mail_app import BrevoMailApp
+from injector import inject
+from pathlib import Path
+import base64
+import os
+import smtplib
+from email.message import EmailMessage
+from iatoolkit.common.exceptions import IAToolkitException
+
+
+TEMP_DIR = Path("static/temp")
+
+class MailService:
+    @inject
+    def __init__(self,
+                 config_service: ConfigurationService,
+                 mail_app: BrevoMailApp,
+                 i18n_service: I18nService,
+                 brevo_mail_app: BrevoMailApp):
+        self.mail_app = mail_app
+        self.config_service = config_service
+        self.i18n_service = i18n_service
+        self.brevo_mail_app = brevo_mail_app
+
+
+    def send_mail(self, company_short_name: str, **kwargs):
+        recipient = kwargs.get('recipient')
+        subject = kwargs.get('subject')
+        body = kwargs.get('body')
+        attachments = kwargs.get('attachments')
+
+        # Normalizar a payload de BrevoMailApp (name + base64 content)
+        norm_attachments = []
+        for a in attachments or []:
+            if a.get("attachment_token"):
+                raw = self._read_token_bytes(a["attachment_token"])
+                norm_attachments.append({
+                    "filename": a["filename"],
+                    "content": base64.b64encode(raw).decode("utf-8"),
+                })
+            else:
+                # asumo que ya viene un base64
+                norm_attachments.append({
+                    "filename": a["filename"],
+                    "content": a["content"]
+                })
+
+        # build provider configuration from company.yaml
+        provider, provider_config = self._build_provider_config(company_short_name)
+
+        # define the email sender
+        sender = {
+            "email": provider_config.get("sender_email"),
+            "name": provider_config.get("sender_name"),
+        }
+
+        # select provider and send the email through it
+        if provider == "brevo_mail":
+            response = self.brevo_mail_app.send_email(
+                provider_config=provider_config,
+                sender=sender,
+                to=recipient,
+                subject=subject,
+                body=body,
+                attachments=norm_attachments
+            )
+        elif provider == "smtplib":
+            response = self._send_with_smtplib(
+                provider_config=provider_config,
+                sender=sender,
+                recipient=recipient,
+                subject=subject,
+                body=body,
+                attachments=norm_attachments,
+            )
+            response = None
+        else:
+            raise IAToolkitException(
+                IAToolkitException.ErrorType.MAIL_ERROR,
+                f"Unknown mail provider '{provider}'"
+            )
+
+        return self.i18n_service.t('services.mail_sent')
+
+    def _build_provider_config(self, company_short_name: str) -> tuple[str, dict]:
+        """
+        Determina el provider activo (brevo_mail / smtplib) y construye
+        el diccionario de configuración a partir de las variables de entorno
+        cuyos nombres están en company.yaml (mail_provider).
+        """
+        # get company mail configuration and provider
+        mail_config = self.config_service.get_configuration(company_short_name, "mail_provider")
+        provider = mail_config.get("provider", "brevo_mail")
+
+        # get mail common parameteres
+        sender_email = mail_config.get("sender_email")
+        sender_name = mail_config.get("sender_name")
+
+        # get parameters depending on provider
+        if provider == "brevo_mail":
+            brevo_cfg = mail_config.get("brevo_mail", {})
+            api_key_env = brevo_cfg.get("brevo_api", "BREVO_API_KEY")
+            return provider, {
+                "api_key": os.getenv(api_key_env),
+                "sender_name": sender_name,
+                "sender_email": sender_email,
+            }
+
+        if provider == "smtplib":
+            smtp_cfg = mail_config.get("smtplib", {})
+            host = os.getenv(smtp_cfg.get("host_env", "SMTP_HOST"))
+            port = os.getenv(smtp_cfg.get("port_env", "SMTP_PORT"))
+            username = os.getenv(smtp_cfg.get("username_env", "SMTP_USERNAME"))
+            password = os.getenv(smtp_cfg.get("password_env", "SMTP_PASSWORD"))
+            use_tls = os.getenv(smtp_cfg.get("use_tls_env", "SMTP_USE_TLS"))
+            use_ssl = os.getenv(smtp_cfg.get("use_ssl_env", "SMTP_USE_SSL"))
+
+            return provider, {
+                "host": host,
+                "port": int(port) if port is not None else None,
+                "username": username,
+                "password": password,
+                "use_tls": str(use_tls).lower() == "true",
+                "use_ssl": str(use_ssl).lower() == "true",
+                "sender_name": sender_name,
+                "sender_email": sender_email,
+            }
+
+        # Fallback simple si el provider no es reconocido
+        raise IAToolkitException(IAToolkitException.ErrorType.MAIL_ERROR,
+                                 f"missing mail provider in mail configuration for company '{company_short_name}'")
+
+    def _send_with_smtplib(self,
+                           provider_config: dict,
+                           sender: dict,
+                           recipient: str,
+                           subject: str,
+                           body: str,
+                           attachments: list[dict] | None):
+        """
+        Envía correo usando smtplib, utilizando la configuración normalizada
+        en provider_config.
+        """
+        host = provider_config.get("host")
+        port = provider_config.get("port")
+        username = provider_config.get("username")
+        password = provider_config.get("password")
+        use_tls = provider_config.get("use_tls")
+        use_ssl = provider_config.get("use_ssl")
+
+        if not host or not port:
+            raise IAToolkitException(
+                IAToolkitException.ErrorType.MAIL_ERROR,
+                "smtplib configuration is incomplete (host/port missing)"
+            )
+
+        msg = EmailMessage()
+        msg["From"] = f"{sender.get('name', '')} <{sender.get('email')}>"
+        msg["To"] = recipient
+        msg["Subject"] = subject
+        msg.set_content(body, subtype="html")
+
+        # Adjuntos: ya vienen como filename + base64 content
+        for a in attachments or []:
+            filename = a.get("filename")
+            content_b64 = a.get("content")
+            if not filename or not content_b64:
+                continue
+            try:
+                raw = base64.b64decode(content_b64, validate=True)
+            except Exception:
+                raise IAToolkitException(
+                    IAToolkitException.ErrorType.MAIL_ERROR,
+                    f"Invalid base64 for attachment '{filename}'"
+                )
+            msg.add_attachment(
+                raw,
+                maintype="application",
+                subtype="octet-stream",
+                filename=filename,
+            )
+
+        if use_ssl:
+            with smtplib.SMTP_SSL(host, port) as server:
+                if username and password:
+                    server.login(username, password)
+                server.send_message(msg)
+        else:
+            with smtplib.SMTP(host, port) as server:
+                if use_tls:
+                    server.starttls()
+                if username and password:
+                    server.login(username, password)
+                server.send_message(msg)
+
+
+    def _read_token_bytes(self, token: str) -> bytes:
+        # Defensa simple contra path traversal
+        if not token or "/" in token or "\\" in token or token.startswith("."):
+            raise IAToolkitException(IAToolkitException.ErrorType.MAIL_ERROR,
+                               "attachment_token invalid")
+        path = TEMP_DIR / token
+        if not path.is_file():
+            raise IAToolkitException(IAToolkitException.ErrorType.MAIL_ERROR,
+                               f"attach file not found: {token}")
+        return path.read_bytes()