dhisana 0.0.1.dev243__py3-none-any.whl

dhisana/utils/email_body_utils.py

@@ -0,0 +1,72 @@
+"""Small helpers for handling e-mail bodies across providers."""
+
+from typing import Optional, Tuple
+import html as html_lib
+import re
+
+
+def looks_like_html(text: str) -> bool:
+    """Heuristically determine whether the body contains HTML markup."""
+    return bool(text and re.search(r"<[a-zA-Z][^>]*>", text))
+
+
+def _normalize_format_hint(format_hint: Optional[str]) -> str:
+    """
+    Normalize a user-supplied format hint into html/text/auto.
+
+    Accepts variations like "plain" or "plaintext" as text.
+    """
+    if not format_hint:
+        return "auto"
+    fmt_raw = getattr(format_hint, "value", format_hint)
+    fmt = str(fmt_raw).strip().lower()
+    if fmt in ("html",):
+        return "html"
+    if fmt in ("text", "plain", "plain_text", "plaintext"):
+        return "text"
+    return "auto"
+
+
+def html_to_plain_text(html: str) -> str:
+    """
+    Produce a very lightweight plain-text version of an HTML fragment.
+    This keeps newlines on block boundaries and strips tags.
+    """
+    if not html:
+        return ""
+    text = re.sub(r"(?is)<(script|style).*?>.*?</\1>", " ", html)
+    text = re.sub(r"(?i)<br\s*/?>", "\n", text)
+    text = re.sub(r"(?i)</(p|div|li|h[1-6])\s*>", "\n", text)
+    text = re.sub(r"(?is)<.*?>", "", text)
+    text = html_lib.unescape(text)
+    text = re.sub(r"\s+\n", "\n", text)
+    text = re.sub(r"\n{3,}", "\n\n", text)
+    return text.strip()
+
+
+def plain_text_to_html(text: str) -> str:
+    """Wrap plain text in a minimal HTML container that preserves newlines."""
+    if text is None:
+        return ""
+    escaped = html_lib.escape(text)
+    return f'<div style="white-space: pre-wrap">{escaped}</div>'
+
+
+def body_variants(body: Optional[str], format_hint: Optional[str]) -> Tuple[str, str, str]:
+    """
+    Return (plain, html, resolved_format) honoring an optional format hint.
+
+    resolved_format is "html" or "text" after applying auto-detection.
+    """
+    content = body or ""
+    fmt = _normalize_format_hint(format_hint)
+
+    if fmt == "html":
+        return html_to_plain_text(content), content, "html"
+    if fmt == "text":
+        return content, plain_text_to_html(content), "text"
+
+    if looks_like_html(content):
+        return html_to_plain_text(content), content, "html"
+
+    return content, plain_text_to_html(content), "text"

dhisana/utils/email_parse_helpers.py

@@ -0,0 +1,132 @@
+import base64
+import email.utils
+from email.utils import parseaddr
+from typing import Any, Dict, List, Optional, Tuple
+from bs4 import BeautifulSoup
+
+def decode_base64_url(data: str) -> str:
+    """
+    Decodes a Base64-url-encoded string (Gmail API uses URL-safe Base64).
+    """
+    data = data.replace('-', '+').replace('_', '/')
+    # Fix padding
+    missing_padding = len(data) % 4
+    if missing_padding:
+        data += '=' * (4 - missing_padding)
+    return base64.b64decode(data).decode('utf-8', errors='ignore')
+
+
+def parse_plain_text_from_parts(parts: List[Dict[str, Any]]) -> str:
+    """
+    Recursively parse payload parts to extract all text (plain or HTML).
+    HTML is converted to plain text.
+    """
+    text_chunks: List[str] = []
+    for part in parts:
+        if 'parts' in part:
+            # Recursively parse nested parts
+            text_chunks.append(parse_plain_text_from_parts(part['parts']))
+        else:
+            mime_type = part.get('mimeType', '')
+            data = part.get('body', {}).get('data', '')
+            if data:
+                decoded_data = decode_base64_url(data)
+                if 'text/plain' in mime_type:
+                    text_chunks.append(decoded_data)
+                elif 'text/html' in mime_type:
+                    soup = BeautifulSoup(decoded_data, 'html.parser')
+                    text_chunks.append(soup.get_text())
+    return "\n".join(chunk for chunk in text_chunks if chunk)
+
+
+def extract_email_body_in_plain_text(message_data: Dict[str, Any]) -> str:
+    """
+    Extract the email body from the Gmail message_data in plain text.
+    Converts any HTML to plain text. 
+    Combines multiple parts if necessary.
+    """
+    payload = message_data.get('payload', {})
+    # If top-level body has data (i.e. single-part message)
+    if payload.get('body', {}).get('data'):
+        raw_data = payload['body']['data']
+        decoded_data = decode_base64_url(raw_data)
+        # Check if it might be HTML
+        mime_type = payload.get('mimeType', '')
+        if 'text/html' in mime_type:
+            soup = BeautifulSoup(decoded_data, 'html.parser')
+            return soup.get_text()
+        return decoded_data
+
+    # If multiple parts exist
+    if 'parts' in payload:
+        return parse_plain_text_from_parts(payload['parts'])
+
+    return ""
+
+
+def convert_date_to_iso(date_str: str) -> str:
+    """
+    Convert a date string (RFC 2822/5322) to an ISO 8601 formatted string.
+    Example: "Wed, 07 Apr 2021 16:30:00 -0700" -> "2021-04-07T16:30:00-07:00"
+    """
+    dt = email.utils.parsedate_to_datetime(date_str)
+    if not dt:
+        return ""
+    return dt.isoformat()
+
+
+def find_header(headers_list: List[Dict[str, str]], header_name: str) -> Optional[str]:
+    """
+    Return the first matching header value for header_name, or None if not found.
+    """
+    for h in headers_list:
+        if h['name'].lower() == header_name.lower():
+            return h['value']
+    return None
+
+
+def parse_single_address(display_str: str) -> (str, str):
+    """
+    Parses a single display string like "Alice <alice@example.com>" 
+    returning (name, email).
+    """
+    name, email = parseaddr(display_str)
+    # If no name is given, might be email only
+    return (name.strip() or "", email.strip() or "")
+
+
+def parse_address_list(display_str: str) -> List[Tuple[str, str]]:
+    """
+    Split a header string with possibly multiple addresses into a list
+    of (name, email) tuples.
+    
+    Example input:
+      "John Doe <john@example.com>, Jane Roe <jane@example.com>"
+    returns:
+      [("John Doe","john@example.com"), ("Jane Roe","jane@example.com")]
+    """
+    # The standard library doesn't have a direct "splitall addresses" 
+    # but we can rely on email.utils.getaddresses
+    # We'll break them into a list of (name, email).
+    addresses = email.utils.getaddresses([display_str])
+    return addresses
+
+
+def find_all_recipients_in_headers(headers_list: List[Dict[str, str]]) -> (str, str):
+    """
+    Collect 'To', 'Cc', 'Bcc' headers, parse each address, and return:
+      (comma-separated receiver names, comma-separated receiver emails)
+    """
+    full_str = []
+    for h in headers_list:
+        if h['name'].lower() in ['to', 'cc', 'bcc']:
+            full_str.append(h['value'])
+    if not full_str:
+        return ("", "")  # No recipients found
+
+    combined_str = ", ".join(full_str)
+    addresses = parse_address_list(combined_str)
+    names = [addr[0] for addr in addresses if addr[0] or addr[1]]
+    emails = [addr[1] for addr in addresses if addr[0] or addr[1]]
+
+    return (", ".join(names), ", ".join(emails))

dhisana/utils/email_provider.py

@@ -0,0 +1,375 @@
+# dhisana/email_providers.py
+#
+# Generic e-mail wrapper helpers for Dhisana.
+# ---------------------------------------------------------------
+
+import logging
+from typing import Any, Dict, List, Optional, Sequence
+
+from dhisana.schemas.common import (
+    SendEmailContext,
+    QueryEmailContext,
+    ReplyEmailContext,
+)
+from dhisana.schemas.sales import MessageItem
+from dhisana.utils.google_workspace_tools import (
+    send_email_using_service_account_async,
+    list_emails_in_time_range_async,
+    reply_to_email_async as gw_reply_to_email_async,
+)
+from dhisana.utils.google_oauth_tools import (
+    send_email_using_google_oauth_async,
+    list_emails_in_time_range_google_oauth_async,
+    reply_to_email_google_oauth_async,
+)
+from dhisana.utils.microsoft365_tools import (
+    send_email_using_microsoft_graph_async,
+    list_emails_in_time_range_m365_async,
+    reply_to_email_m365_async,
+)
+from dhisana.utils.smtp_email_tools import (
+    send_email_via_smtp_async,
+    list_emails_in_time_range_imap_async,
+    reply_to_email_via_smtp_async,
+)
+from dhisana.utils.mailgun_tools import send_email_using_mailgun_async
+from dhisana.utils.sendgrid_tools import send_email_using_sendgrid_async
+
+# --------------------------------------------------------------------------- #
+#  Provider-selection helpers
+# --------------------------------------------------------------------------- #
+
+
+def _find_provider_cfg(
+    tool_cfg: Optional[Sequence[Dict]], provider_name: str
+) -> Optional[Dict]:
+    """
+    Return the *first* config-dict whose ``name`` matches *provider_name*.
+    """
+    if not tool_cfg:
+        return None
+    return next((c for c in tool_cfg if c.get("name") == provider_name), None)
+
+
+def _smtp_creds_for_sender(smtp_cfg: Dict, sender_email: str) -> Optional[Dict[str, str]]:
+    """
+    Given an SMTP provider config and a sender address, return the matching
+    ``username`` / ``password`` plus server settings, or ``None``.
+    """
+    try:
+        usernames = [
+            u.strip()
+            for u in next(f for f in smtp_cfg["configuration"] if f["name"] == "usernames")[
+                "value"
+            ].split(",")
+            if u.strip()
+        ]
+        passwords = [
+            p.strip()
+            for p in next(f for f in smtp_cfg["configuration"] if f["name"] == "passwords")[
+                "value"
+            ].split(",")
+        ]
+        if len(usernames) != len(passwords):
+            logging.warning(
+                "smtpEmail config: usernames/passwords length mismatch – skipping"
+            )
+            return None
+
+        if sender_email not in usernames:
+            return None
+
+        idx = usernames.index(sender_email)
+
+        def _field(name: str, default):
+            try:
+                return next(f for f in smtp_cfg["configuration"] if f["name"] == name)[
+                    "value"
+                ]
+            except StopIteration:
+                return default
+
+        return {
+            "username": usernames[idx],
+            "password": passwords[idx],
+            "smtp_host": _field("smtpEndpoint", "smtp.gmail.com"),
+            "smtp_port": int(_field("smtpPort", 587)),
+            "imap_host": _field("imapEndpoint", "imap.gmail.com"),
+            "imap_port": int(_field("imapPort", 993)),
+        }
+    except Exception:
+        logging.exception("Failed to parse smtpEmail config")
+        return None
+
+
+# --------------------------------------------------------------------------- #
+#  Public wrapper APIs
+# --------------------------------------------------------------------------- #
+
+async def send_email_async(
+    send_email_context: SendEmailContext,
+    tool_config: Optional[List[Dict]] = None,
+    *,
+    provider_order: Sequence[str] = (
+        "mailgun",
+        "sendgrid",
+        "google",          # Google OAuth (per-user token)
+        "smtpEmail",
+        "googleworkspace", # Google Workspace service account (DWD)
+        "microsoft365",
+    ),
+):
+    """
+    Send an e-mail using the first *configured* provider in *provider_order*.
+
+    Returns whatever the underlying provider helper returns:
+
+        * SMTP              → str                (Message-ID)
+        * Microsoft 365     → str                (message-id)
+        * Google Workspace  → str                (message-id)
+    """
+    # ------------------------------------------------------------------ #
+    # 1) Try the preferred providers in order
+    # ------------------------------------------------------------------ #
+    for provider in provider_order:
+        # 1a) SMTP
+        if provider == "smtpEmail":
+            smtp_cfg = _find_provider_cfg(tool_config, "smtpEmail")
+            if not smtp_cfg:
+                continue
+
+            creds = _smtp_creds_for_sender(smtp_cfg, send_email_context.sender_email)
+            if not creds:
+                # No creds for this sender – fall through.
+                continue
+
+            return await send_email_via_smtp_async(
+                send_email_context,
+                smtp_server=creds["smtp_host"],
+                smtp_port=creds["smtp_port"],
+                username=creds["username"],
+                password=creds["password"],
+                use_starttls=(creds["smtp_port"] == 587),
+            )
+
+        # 1b) Mailgun
+        elif provider == "mailgun":
+            mg_cfg = _find_provider_cfg(tool_config, "mailgun")
+            if not mg_cfg:
+                continue
+            return await send_email_using_mailgun_async(send_email_context, tool_config)
+
+        # 1c) SendGrid
+        elif provider == "sendgrid":
+            sg_cfg = _find_provider_cfg(tool_config, "sendgrid")
+            if not sg_cfg:
+                continue
+            return await send_email_using_sendgrid_async(send_email_context, tool_config)
+
+        # 1d) Google (Gmail API via per-user OAuth)
+        elif provider == "google":
+            g_cfg = _find_provider_cfg(tool_config, "google")
+            if not g_cfg:
+                continue
+            return await send_email_using_google_oauth_async(send_email_context, tool_config)
+
+        # 1e) Google Workspace
+        elif provider == "googleworkspace":
+            gw_cfg = _find_provider_cfg(tool_config, "googleworkspace")
+            if not gw_cfg:
+                continue
+
+            return await send_email_using_service_account_async(
+                send_email_context, tool_config
+            )
+
+        # 1f) Microsoft 365 (Graph API)
+        elif provider == "microsoft365":
+            ms_cfg = _find_provider_cfg(tool_config, "microsoft365")
+            if not ms_cfg:
+                continue
+
+            return await send_email_using_microsoft_graph_async(
+                send_email_context, tool_config
+            )
+
+        # -- future providers slot --------------------------------------
+
+    # ------------------------------------------------------------------ #
+    # 2) FINAL FALLBACK — use *first* SMTP credentials if available
+    # ------------------------------------------------------------------ #
+    smtp_cfg = _find_provider_cfg(tool_config, "smtpEmail")
+    if smtp_cfg:
+        try:
+            usernames = [
+                u.strip()
+                for u in next(
+                    f for f in smtp_cfg["configuration"] if f["name"] == "usernames"
+                )["value"].split(",")
+                if u.strip()
+            ]
+            passwords = [
+                p.strip()
+                for p in next(
+                    f for f in smtp_cfg["configuration"] if f["name"] == "passwords"
+                )["value"].split(",")
+            ]
+            if usernames and len(usernames) == len(passwords):
+                # Build a fake SendEmailContext for the fallback user, so that
+                # the underlying SMTP helper still sends the intended message
+                # but authenticates with the first available mailbox.
+                fallback_sender = usernames[0]
+                creds = _smtp_creds_for_sender(smtp_cfg, fallback_sender)
+
+                if creds:
+                    logging.info(
+                        "Fallback: no provider matched – using first SMTP creds (%s).",
+                        creds["username"],
+                    )
+                    return await send_email_via_smtp_async(
+                        send_email_context,
+                        smtp_server=creds["smtp_host"],
+                        smtp_port=creds["smtp_port"],
+                        username=creds["username"],
+                        password=creds["password"],
+                        use_starttls=(creds["smtp_port"] == 587),
+                    )
+        except Exception:
+            logging.exception("SMTP fallback failed")
+
+    # ------------------------------------------------------------------ #
+    # 3) Nothing worked
+    # ------------------------------------------------------------------ #
+    raise RuntimeError("No suitable e-mail provider configured for this sender.")
+
+
+
+
+async def list_emails_async(
+    query_email_context: QueryEmailContext,
+    tool_config: Optional[List[Dict]] = None,
+    *,
+    provider_order: Sequence[str] = ("google", "smtpEmail", "googleworkspace", "microsoft365"),
+) -> List[MessageItem]:
+    """
+    List e-mails (see ``QueryEmailContext``) using the first configured provider.
+
+    Always returns ``List[MessageItem]``.
+    """
+    for provider in provider_order:
+        if provider == "smtpEmail":
+            smtp_cfg = _find_provider_cfg(tool_config, "smtpEmail")
+            if not smtp_cfg:
+                continue
+
+            creds = _smtp_creds_for_sender(smtp_cfg, query_email_context.sender_email)
+            if not creds:
+                continue
+
+            return await list_emails_in_time_range_imap_async(
+                query_email_context,
+                imap_server=creds["imap_host"],
+                imap_port=creds["imap_port"],
+                username=creds["username"],
+                password=creds["password"],
+            )
+
+        elif provider == "google":
+            g_cfg = _find_provider_cfg(tool_config, "google")
+            if not g_cfg:
+                continue
+            return await list_emails_in_time_range_google_oauth_async(query_email_context, tool_config)
+
+        elif provider == "googleworkspace":
+            gw_cfg = _find_provider_cfg(tool_config, "googleworkspace")
+            if not gw_cfg:
+                continue
+            return await list_emails_in_time_range_async(query_email_context, tool_config)
+
+        elif provider == "microsoft365":
+            ms_cfg = _find_provider_cfg(tool_config, "microsoft365")
+            if not ms_cfg:
+                continue
+            return await list_emails_in_time_range_m365_async(query_email_context, tool_config)
+
+        # --- future providers go here ---
+
+    logging.warning(
+        "No suitable inbox provider configured for sender %s; returning empty list.",
+        query_email_context.sender_email,
+    )
+    return []
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# New public helper: reply_email_async
+# ─────────────────────────────────────────────────────────────────────────────
+async def reply_email_async(
+    reply_email_context: ReplyEmailContext,
+    tool_config: Optional[List[Dict]] = None,
+    *,
+    provider_order: Sequence[str] = ("google", "smtpEmail", "googleworkspace", "microsoft365"),
+) -> Dict[str, Any]:
+    """
+    Reply (reply-all) to an e-mail using the first *configured* provider
+    in *provider_order*.
+
+    Returns the provider’s reply-metadata dictionary.
+    """
+    for provider in provider_order:
+        # ------------------------------------------------------------------
+        # 1) SMTP
+        # ------------------------------------------------------------------
+        if provider == "smtpEmail":
+            smtp_cfg = _find_provider_cfg(tool_config, "smtpEmail")
+            if not smtp_cfg:
+                continue
+
+            creds = _smtp_creds_for_sender(smtp_cfg, reply_email_context.sender_email)
+            if not creds:
+                continue
+
+            return await reply_to_email_via_smtp_async(
+                reply_email_context,
+                smtp_server=creds["smtp_host"],
+                smtp_port=creds["smtp_port"],
+                imap_server=creds["imap_host"],
+                imap_port=creds["imap_port"],
+                username=creds["username"],
+                password=creds["password"],
+                use_starttls_smtp=(creds["smtp_port"] == 587),
+            )
+
+        # ------------------------------------------------------------------
+        # 2) Google OAuth (per-user)
+        # ------------------------------------------------------------------
+        elif provider == "google":
+            g_cfg = _find_provider_cfg(tool_config, "google")
+            if not g_cfg:
+                continue
+
+            return await reply_to_email_google_oauth_async(reply_email_context, tool_config)
+
+        # ------------------------------------------------------------------
+        # 3) Google Workspace service-account
+        # ------------------------------------------------------------------
+        elif provider == "googleworkspace":
+            gw_cfg = _find_provider_cfg(tool_config, "googleworkspace")
+            if not gw_cfg:
+                continue
+
+            return await gw_reply_to_email_async(reply_email_context, tool_config)
+
+        # ------------------------------------------------------------------
+        # 4) Microsoft 365 (Graph)
+        # ------------------------------------------------------------------
+        elif provider == "microsoft365":
+            ms_cfg = _find_provider_cfg(tool_config, "microsoft365")
+            if not ms_cfg:
+                continue
+
+            return await reply_to_email_m365_async(reply_email_context, tool_config)
+
+        # -- future providers slot -----------------------------------------
+
+    raise RuntimeError("No suitable reply-capable e-mail provider configured.")