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

dhisana/utils/email_provider.py

@@ -6,24 +6,37 @@
 import logging
 from typing import Any, Dict, List, Optional, Sequence
 
-from pydantic import BaseModel
-from dhisana.schemas.common import (SendEmailContext, QueryEmailContext, ReplyEmailContext)
-
+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,   
+    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,                     
+    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
+#  Provider-selection helpers
 # --------------------------------------------------------------------------- #
 
 
@@ -31,35 +44,35 @@ def _find_provider_cfg(
     tool_cfg: Optional[Sequence[Dict]], provider_name: str
 ) -> Optional[Dict]:
     """
-    Return the *first* config dict whose ``name`` matches *provider_name*.
+    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]]:
+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`` and ``password`` plus server settings, or ``None``.
+    ``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(",")
+            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(",")
+            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"
+                "smtpEmail config: usernames/passwords length mismatch – skipping"
             )
             return None
 
@@ -97,17 +110,29 @@ async def send_email_async(
     send_email_context: SendEmailContext,
     tool_config: Optional[List[Dict]] = None,
     *,
-    provider_order: Sequence[str] = ("smtpEmail", "googleworkspace"),
+    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  –  ``Tuple[int, bytes]``  (status-code, server-msg)
-        * Google Workspace  –  ``str`` (message id)
+        * 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:
@@ -115,7 +140,7 @@ async def send_email_async(
 
             creds = _smtp_creds_for_sender(smtp_cfg, send_email_context.sender_email)
             if not creds:
-                # No credentials for this sender; fall through to next provider.
+                # No creds for this sender – fall through.
                 continue
 
             return await send_email_via_smtp_async(
@@ -127,22 +152,104 @@ async def send_email_async(
                 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)
 
-        # --- future providers can be added here ---
+            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] = ("smtpEmail", "googleworkspace"),
+    provider_order: Sequence[str] = ("google", "smtpEmail", "googleworkspace", "microsoft365"),
 ) -> List[MessageItem]:
     """
     List e-mails (see ``QueryEmailContext``) using the first configured provider.
@@ -167,17 +274,31 @@ async def list_emails_async(
                 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)
 
-        # --- future providers go here ---
-
-    raise RuntimeError("No suitable inbox provider configured for this sender.")
+        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 []
 
 
 # ─────────────────────────────────────────────────────────────────────────────
@@ -187,7 +308,7 @@ async def reply_email_async(
     reply_email_context: ReplyEmailContext,
     tool_config: Optional[List[Dict]] = None,
     *,
-    provider_order: Sequence[str] = ("smtpEmail", "googleworkspace"),
+    provider_order: Sequence[str] = ("google", "smtpEmail", "googleworkspace", "microsoft365"),
 ) -> Dict[str, Any]:
     """
     Reply (reply-all) to an e-mail using the first *configured* provider
@@ -197,16 +318,14 @@ async def reply_email_async(
     """
     for provider in provider_order:
         # ------------------------------------------------------------------
-        # 1) SMTP / IMAP
+        # 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
-            )
+            creds = _smtp_creds_for_sender(smtp_cfg, reply_email_context.sender_email)
             if not creds:
                 continue
 
@@ -222,7 +341,17 @@ async def reply_email_async(
             )
 
         # ------------------------------------------------------------------
-        # 2) Google Workspace service-account
+        # 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")
@@ -231,6 +360,16 @@ async def reply_email_async(
 
             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.")