dhisana 0.0.1.dev116__py3-none-any.whl → 0.0.1.dev236__py3-none-any.whl

dhisana/utils/smtp_email_tools.py

@@ -3,19 +3,21 @@
 # Standard library
 # ─────────────────────────────────────────────────────────────────────────────
 import asyncio
-import base64
 import datetime
 import email
 import email.utils
 import hashlib
+import html as html_lib
 import imaplib
 import logging
-import os
 import re
 import uuid
+from email.errors import HeaderParseError
+from email.header import Header, decode_header, make_header
+from email.mime.multipart import MIMEMultipart
 from email.mime.text import MIMEText
 from datetime import datetime, timedelta, timezone
-from typing import Any, Dict, List, Optional, Tuple, Union
+from typing import Any, Dict, List, Optional, Union
 
 # ─────────────────────────────────────────────────────────────────────────────
 # Third-party libraries
@@ -31,12 +33,39 @@ from dhisana.utils.google_workspace_tools import (
     QueryEmailContext,
     SendEmailContext,
 )
+from dhisana.utils.email_body_utils import body_variants
 
 
 # --------------------------------------------------------------------------- #
 #  Helper / Utility
 # --------------------------------------------------------------------------- #
 
+
+def _decode_header_value(value: Any) -> str:
+    """Return a unicode string for an e-mail header field."""
+
+    if value is None:
+        return ""
+
+    if isinstance(value, Header):
+        value = str(value)
+
+    if isinstance(value, bytes):
+        try:
+            return value.decode("utf-8")
+        except UnicodeDecodeError:
+            return value.decode("latin-1", errors="replace")
+
+    if isinstance(value, str):
+        try:
+            decoded = make_header(decode_header(value))
+            return str(decoded)
+        except (HeaderParseError, UnicodeDecodeError, LookupError):
+            return value
+
+    return str(value)
+
+
 def _imap_date(iso_dt: Union[str, datetime]) -> str:
     """
     Convert an ISO 8601 datetime or datetime object into IMAP date format: DD-Mmm-YYYY.
@@ -76,6 +105,28 @@ def _to_datetime(val: Union[datetime, str]) -> datetime:
         ) from exc
 
 
+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 _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()
+
+
 # --------------------------------------------------------------------------- #
 #  Outbound -- SMTP
 # --------------------------------------------------------------------------- #
@@ -101,7 +152,19 @@ async def send_email_via_smtp_async(
     str
         The Message-ID of the sent message (e.g., "<uuid@yourdomain.com>").
     """
-    msg = MIMEText(ctx.body, _charset="utf-8")
+    plain_body, html_body, resolved_fmt = body_variants(
+        ctx.body,
+        getattr(ctx, "body_format", None),
+    )
+
+    if resolved_fmt == "text":
+        msg = MIMEText(plain_body, _subtype="plain", _charset="utf-8")
+    else:
+        # Build multipart/alternative so HTML-capable clients see rich content.
+        msg = MIMEMultipart("alternative")
+        msg.attach(MIMEText(plain_body, "plain", _charset="utf-8"))
+        msg.attach(MIMEText(html_body, "html", _charset="utf-8"))
+
     msg["From"] = f"{ctx.sender_name} <{ctx.sender_email}>"
     msg["To"] = ctx.recipient
     msg["Subject"] = ctx.subject
@@ -152,7 +215,7 @@ def _parse_email_msg(raw_bytes: bytes) -> MessageItem:
     msg = email.message_from_bytes(raw_bytes)
 
     # Helper for reading headers
-    hdr = lambda h: msg.get(h, "")
+    hdr = lambda h: _decode_header_value(msg.get(h))
 
     sender_name, sender_email = email.utils.parseaddr(hdr("From"))
     receiver_name, receiver_email = email.utils.parseaddr(hdr("To"))
@@ -165,10 +228,14 @@ def _parse_email_msg(raw_bytes: bytes) -> MessageItem:
                 part.get_content_type() == "text/plain"
                 and "attachment" not in str(part.get("Content-Disposition", ""))
             ):
-                body = part.get_payload(decode=True).decode(errors="ignore")
-                break
+                payload = part.get_payload(decode=True)
+                if payload is not None:
+                    body = payload.decode(errors="ignore")
+                    break
     else:
-        body = msg.get_payload(decode=True).decode(errors="ignore")
+        payload = msg.get_payload(decode=True)
+        if payload is not None:
+            body = payload.decode(errors="ignore")
 
     # Parse the Date header to get a timezone-aware datetime
     try:
@@ -327,17 +394,99 @@ async def reply_to_email_via_smtp_async(
         )
         try:
             conn.login(username, password)
-            conn.select(mailbox, readonly=False)  # can set flags if needed
-            # Search for the exact Message-ID header
-            status, nums = conn.search(None, "HEADER", "Message-ID", ctx.message_id)
-            if status != "OK" or not nums[0]:
-                logging.warning("IMAP search for %r returned %s", ctx.message_id, nums)
+            # Sent messages usually live outside INBOX; build a candidate list
+            # from the provided mailbox, common sent folders, and any LISTed
+            # mailboxes containing "sent" (case-insensitive).
+            candidate_mailboxes = []
+            if mailbox:
+                candidate_mailboxes.append(mailbox)
+            candidate_mailboxes.extend([
+                "Sent",
+                "Sent Items",
+                "Sent Mail",
+                "[Gmail]/Sent Mail",
+                "[Gmail]/Sent Items",
+                "INBOX.Sent",
+                "INBOX/Sent",
+            ])
+            try:
+                status, mailboxes = conn.list()
+                if status == "OK" and mailboxes:
+                    for mbox in mailboxes:
+                        try:
+                            decoded = mbox.decode(errors="ignore")
+                        except Exception:
+                            decoded = str(mbox)
+                        # Parse flags + name from LIST response:
+                        # e.g., (\\HasNoChildren \\Sent) "/" "Sent Items"
+                        flags = set()
+                        name_part = decoded
+                        if ") " in decoded:
+                            flags_raw, _, remainder = decoded.partition(") ")
+                            flags = {f.lower() for f in flags_raw.strip("(").split() if f}
+                            # remainder is like '"/" "Sent Items"' or '"/" Sent'
+                            pieces = remainder.split(" ", 1)
+                            if len(pieces) == 2:
+                                name_part = pieces[1].strip()
+                            else:
+                                name_part = remainder.strip()
+                        name_part = name_part.strip()
+                        if name_part.startswith('"') and name_part.endswith('"'):
+                            name_part = name_part[1:-1]
+
+                        # Prefer provider-marked \Sent flag; otherwise fall back to substring match.
+                        is_sent_flag = "\\sent" in flags
+                        is_sent_name = "sent" in name_part.lower()
+                        if is_sent_flag or is_sent_name:
+                            candidate_mailboxes.append(name_part)
+            except Exception:
+                logging.exception("IMAP LIST failed; continuing with default sent folders")
+            # Deduplicate while preserving order
+            seen = set()
+            candidate_mailboxes = [m for m in candidate_mailboxes if not (m in seen or seen.add(m))]
+
+            msg_data = None
+            for mb in candidate_mailboxes:
+                def _try_select(name: str) -> bool:
+                    # Quote mailbox names with spaces or special chars; fall back to raw.
+                    for candidate in (f'"{name}"', name):
+                        try:
+                            status, _ = conn.select(candidate, readonly=False)
+                        except imaplib.IMAP4.error as exc:
+                            logging.warning("IMAP select %r failed: %s", candidate, exc)
+                            continue
+                        except Exception as exc:
+                            logging.warning("IMAP select %r failed: %s", candidate, exc)
+                            continue
+                        if status == "OK":
+                            return True
+                    return False
+
+                if not _try_select(mb):
+                    continue
+                # Search for the Message-ID header. Some servers store IDs without angle
+                # brackets or require quoted search terms, so try a few variants.
+                candidates = [ctx.message_id]
+                trimmed = ctx.message_id.strip()
+                if trimmed.startswith("<") and trimmed.endswith(">"):
+                    candidates.append(trimmed[1:-1])
+                for mid in candidates:
+                    status, nums = conn.search(None, "HEADER", "Message-ID", f'"{mid}"')
+                    if status == "OK" and nums and nums[0]:
+                        num = nums[0].split()[0]
+                        _, data = conn.fetch(num, "(RFC822)")
+                        if ctx.mark_as_read.lower() == "true":
+                            conn.store(num, "+FLAGS", "\\Seen")
+                        msg_data = data[0][1] if data and data[0] else None
+                        break
+                if msg_data:
+                    break
+
+            if not msg_data:
+                logging.warning("IMAP search for %r returned no matches in any mailbox", ctx.message_id)
                 return None
-            num = nums[0].split()[0]
-            _, data = conn.fetch(num, "(RFC822)")
-            if ctx.mark_as_read.lower() == "true":
-                conn.store(num, "+FLAGS", "\\Seen")
-            return data[0][1] if data and data[0] else None
+
+            return msg_data
         finally:
             try:
                 conn.close()
@@ -355,6 +504,17 @@ async def reply_to_email_via_smtp_async(
     # 2. Derive reply headers
     to_addrs = hdr("Reply-To") or hdr("From")
     cc_addrs = hdr("Cc")
+    # If the derived recipient points back to the sender or is missing, fall back to provided recipient.
+    sender_email_lc = (ctx.sender_email or "").lower()
+    def _is_self(addr: str) -> bool:
+        return bool(sender_email_lc) and sender_email_lc in addr.lower()
+    if (not to_addrs or _is_self(to_addrs)) and getattr(ctx, "fallback_recipient", None):
+        fr = ctx.fallback_recipient
+        if fr and not _is_self(fr):
+            to_addrs = fr
+            cc_addrs = ""
+    if not to_addrs or _is_self(to_addrs):
+        raise RuntimeError("No valid recipient found in original message; refusing to reply to sender.")
     subject = hdr("Subject")
     if not subject.lower().startswith("re:"):
         subject = f"Re: {subject}"