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

dhisana/utils/google_workspace_tools.py

@@ -1,12 +1,14 @@
 import base64
 import csv
 import datetime
+import html as html_lib
 import io
 import json
 import logging
 import os
 import re
 import uuid
+from email.mime.multipart import MIMEMultipart
 from email.mime.text import MIMEText
 from typing import Any, Dict, List, Optional
 
@@ -22,6 +24,10 @@ from googleapiclient.http import MediaFileUpload, MediaIoBaseDownload
 from dhisana.schemas.sales import MessageItem
 from dhisana.utils.assistant_tool_tag import assistant_tool
 from dhisana.utils.email_parse_helpers import *
+from dhisana.utils.email_body_utils import body_variants
+import asyncio
+from dhisana.schemas.common import (SendEmailContext, QueryEmailContext, ReplyEmailContext, BodyFormat)
+
 
 ################################################################################
 #                               HELPER FUNCTIONS
@@ -40,7 +46,7 @@ def get_google_workspace_token(tool_config: Optional[List[Dict]] = None) -> str:
         str: The base64-encoded JSON string for the service account credentials.
 
     Raises:
-        ValueError: If the key is not found in the tool configuration or environment variable.
+        ValueError: If the Google Workspace integration has not been configured.
     """
     if tool_config:
         google_workspace_config = next(
@@ -58,12 +64,14 @@ def get_google_workspace_token(tool_config: Optional[List[Dict]] = None) -> str:
     else:
         GOOGLE_SERVICE_KEY = None
 
-    if not GOOGLE_SERVICE_KEY: 
+    if not GOOGLE_SERVICE_KEY:
         env_service_key = os.getenv("GOOGLE_SERVICE_KEY")
-        if  env_service_key: 
+        if  env_service_key:
             GOOGLE_SERVICE_KEY = base64.b64decode(env_service_key).decode("utf-8")
     if not GOOGLE_SERVICE_KEY:
-        raise ValueError("GOOGLE_SERVICE_KEY not found in tool_config or environment variable.")
+        raise ValueError(
+            "Google Workspace integration is not configured. Please configure the connection to Google Workspace in Integrations."
+        )
     return GOOGLE_SERVICE_KEY
 
 
@@ -104,6 +112,197 @@ def get_google_credentials(
     return credentials
 
 
+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()
+
+
+    
+@assistant_tool
+async def send_email_using_service_account_async(
+    send_email_context: SendEmailContext,
+    tool_config: Optional[List[Dict]] = None
+) -> str:
+    """
+    Asynchronously sends an email using the Gmail API with a service account.
+    The service account must have domain-wide delegation to impersonate the sender_email.
+
+    Args:
+        send_email_context (SendEmailContext): The context with recipient, subject,
+                                               body, sender_name, sender_email, 
+                                               and an optional labels list.
+        tool_config (Optional[List[Dict]]): Tool configuration for credentials (if any).
+
+    Returns:
+        str: The ID of the sent message.
+    """
+    if not send_email_context.sender_email:
+        raise ValueError("sender_email is required to impersonate for sending.")
+
+    SCOPES = ['https://mail.google.com/']
+    credentials = get_google_credentials(send_email_context.sender_email, SCOPES, tool_config)
+    access_token = credentials.token
+
+    gmail_api_url = 'https://gmail.googleapis.com/gmail/v1/users/me/messages/send'
+
+    plain_body, html_body, resolved_fmt = body_variants(
+        send_email_context.body,
+        getattr(send_email_context, "body_format", None),
+    )
+
+    if resolved_fmt == "text":
+        message = MIMEText(plain_body, _subtype="plain", _charset="utf-8")
+    else:
+        # Gmail prefers multipart/alternative when HTML is present.
+        message = MIMEMultipart("alternative")
+        message.attach(MIMEText(plain_body, "plain", _charset="utf-8"))
+        message.attach(MIMEText(html_body, "html", _charset="utf-8"))
+
+    message['to'] = send_email_context.recipient
+    message['from'] = f"{send_email_context.sender_name} <{send_email_context.sender_email}>"
+    message['subject'] = send_email_context.subject
+
+    # Base64-encode the message
+    raw_message = base64.urlsafe_b64encode(message.as_bytes()).decode()
+
+    # Build the payload (with optional label IDs)
+    payload = {
+        'raw': raw_message
+    }
+    if send_email_context.labels:
+        payload['labelIds'] = send_email_context.labels
+
+    headers = {
+        'Authorization': f'Bearer {access_token}',
+        'Content-Type': 'application/json'
+    }
+
+    async with httpx.AsyncClient() as client:
+        response = await client.post(gmail_api_url, headers=headers, json=payload)
+        response.raise_for_status()
+        sent_message = response.json()
+    await asyncio.sleep(20)
+
+    return sent_message.get('id', 'No ID returned')
+
+
+
+
+@assistant_tool
+async def list_emails_in_time_range_async(
+    context: QueryEmailContext,
+    tool_config: Optional[List[Dict]] = None
+) -> List[MessageItem]:
+    """
+    Asynchronously lists emails in a given time range using the Gmail API with a service account.
+    Returns a list of MessageItem objects, with iso_datetime, and separate sender/receiver fields.
+    """
+    if context.labels is None:
+        context.labels = []
+
+    if not context.sender_email:
+        raise ValueError("sender_email is required to impersonate for listing emails.")
+
+    SCOPES = ['https://mail.google.com/']
+    credentials = get_google_credentials(context.sender_email, SCOPES, tool_config)
+    access_token = credentials.token
+
+    gmail_api_url = 'https://gmail.googleapis.com/gmail/v1/users/me/messages'
+
+    # Convert RFC 3339 times to Unix epoch timestamps for the search query
+    start_dt = datetime.datetime.fromisoformat(context.start_time.replace('Z', '+00:00'))
+    end_dt = datetime.datetime.fromisoformat(context.end_time.replace('Z', '+00:00'))
+    start_timestamp = int(start_dt.timestamp())
+    end_timestamp = int(end_dt.timestamp())
+
+    # Build the search query
+    query = f'after:{start_timestamp} before:{end_timestamp}'
+    if context.unread_only:
+        query += ' is:unread'
+    if context.labels:
+        label_query = ' '.join([f'label:{lbl}' for lbl in context.labels])
+        query += f' {label_query}'
+
+    headers = {'Authorization': f'Bearer {access_token}'}
+    params = {'q': query, 'maxResults': 100}
+
+    message_items: List[MessageItem] = []
+    max_fetch = 500  # defensive cap
+    async with httpx.AsyncClient() as client:
+        next_page_token = None
+        while True:
+            page_params = dict(params)
+            if next_page_token:
+                page_params["pageToken"] = next_page_token
+
+            response = await client.get(gmail_api_url, headers=headers, params=page_params)
+            response.raise_for_status()
+            resp_json = response.json() or {}
+            messages = resp_json.get('messages', [])
+
+            for msg in messages:
+                if len(message_items) >= max_fetch:
+                    break
+                message_id = msg['id']
+                thread_id = msg.get('threadId', "")
+                message_url = f'{gmail_api_url}/{message_id}'
+                message_response = await client.get(message_url, headers=headers)
+                message_response.raise_for_status()
+                message_data = message_response.json()
+
+                headers_list = message_data['payload']['headers']
+                from_header = find_header(headers_list, 'From') or ""
+                subject_header = find_header(headers_list, 'Subject') or ""
+                date_header = find_header(headers_list, 'Date') or ""
+
+                iso_datetime_str = convert_date_to_iso(date_header)
+
+                # Parse the "From" into (sender_name, sender_email)
+                s_name, s_email = parse_single_address(from_header)
+
+                # Parse the recipients
+                r_name, r_email = find_all_recipients_in_headers(headers_list)
+
+                msg_item = MessageItem(
+                    message_id=message_data['id'],                
+                    thread_id=thread_id,
+                    sender_name=s_name,
+                    sender_email=s_email,
+                    receiver_name=r_name,
+                    receiver_email=r_email,
+                    iso_datetime=iso_datetime_str,
+                    subject=subject_header,
+                    body=extract_email_body_in_plain_text(message_data)
+                )
+                message_items.append(msg_item)
+
+            if len(message_items) >= max_fetch:
+                break
+
+            next_page_token = resp_json.get("nextPageToken")
+            if not next_page_token:
+                break
+
+    return message_items
+
+
 ################################################################################
 #                        GOOGLE DRIVE FILE OPERATIONS
 ################################################################################
@@ -331,6 +530,7 @@ class SendEmailContext(BaseModel):
     sender_name: str
     sender_email: str
     labels: Optional[List[str]]
+    body_format: BodyFormat = BodyFormat.AUTO
     
 @assistant_tool
 async def send_email_using_service_account_async(
@@ -359,8 +559,18 @@ async def send_email_using_service_account_async(
 
     gmail_api_url = 'https://gmail.googleapis.com/gmail/v1/users/me/messages/send'
 
+    plain_body, html_body, resolved_fmt = body_variants(
+        send_email_context.body,
+        getattr(send_email_context, "body_format", None),
+    )
+
     # Construct the MIME text message
-    message = MIMEText(send_email_context.body)
+    if resolved_fmt == "text":
+        message = MIMEText(plain_body, _subtype="plain", _charset="utf-8")
+    else:
+        message = MIMEMultipart("alternative")
+        message.attach(MIMEText(plain_body, "plain", _charset="utf-8"))
+        message.attach(MIMEText(html_body, "html", _charset="utf-8"))
     message['to'] = send_email_context.recipient
     message['from'] = f"{send_email_context.sender_name} <{send_email_context.sender_email}>"
     message['subject'] = send_email_context.subject
@@ -384,6 +594,7 @@ async def send_email_using_service_account_async(
         response = await client.post(gmail_api_url, headers=headers, json=payload)
         response.raise_for_status()
         sent_message = response.json()
+    await asyncio.sleep(20)
 
     return sent_message.get('id', 'No ID returned')
 
@@ -443,6 +654,7 @@ async def list_emails_in_time_range_async(
 
         for msg in messages:
             message_id = msg['id']
+            thread_id = msg['threadId']
             message_url = f'{gmail_api_url}/{message_id}'
             message_response = await client.get(message_url, headers=headers)
             message_response.raise_for_status()
@@ -462,7 +674,8 @@ async def list_emails_in_time_range_async(
             r_name, r_email = find_all_recipients_in_headers(headers_list)
 
             msg_item = MessageItem(
-                message_id=message_data['id'],
+                message_id=message_data['id'],                
+                thread_id=thread_id,
                 sender_name=s_name,
                 sender_email=s_email,
                 receiver_name=r_name,
@@ -526,6 +739,7 @@ async def fetch_last_n_sent_messages(
 
             msg_item = MessageItem(
                 message_id=message_data['id'],
+                thread_id=message_data['threadId'],
                 sender_name=s_name,
                 sender_email=s_email,
                 receiver_name=r_name,
@@ -589,6 +803,7 @@ async def fetch_last_n_received_messages(
 
             msg_item = MessageItem(
                 message_id=message_data['id'],
+                thread_id=message_data['threadId'],
                 sender_name=s_name,
                 sender_email=s_email,
                 receiver_name=r_name,
@@ -641,6 +856,7 @@ async def get_email_details_async(
 
     msg_item = MessageItem(
         message_id=message_data['id'],
+        thread_id=message_data['threadId'],
         sender_name=s_name,
         sender_email=s_email,
         receiver_name=r_name,
@@ -654,14 +870,6 @@ async def get_email_details_async(
 
 
 
-class ReplyEmailContext(BaseModel):
-    message_id: str
-    reply_body: str
-    sender_email: str
-    sender_name: str
-    mark_as_read: str = "True"
-    add_labels: Optional[List[str]] = None
-
 @assistant_tool
 async def reply_to_email_async(
     reply_email_context: ReplyEmailContext,
@@ -704,20 +912,55 @@ async def reply_to_email_async(
         original_message = response.json()
 
     headers_list = original_message.get('payload', {}).get('headers', [])
-    headers_dict = {h['name']: h['value'] for h in headers_list}
-    thread_id = original_message.get('threadId')
-
-    # 2. Prepare reply headers
-    subject = headers_dict.get('Subject', '')
+    # Case-insensitive header lookup and resilient recipient fallback to avoid Gmail 400s.
+    subject = find_header(headers_list, 'Subject') or ''
     if not subject.startswith('Re:'):
         subject = f'Re: {subject}'
+    reply_to_header = find_header(headers_list, 'Reply-To') or ''
+    from_header = find_header(headers_list, 'From') or ''
+    to_header = find_header(headers_list, 'To') or ''
+    cc_header = find_header(headers_list, 'Cc') or ''
+    message_id_header = find_header(headers_list, 'Message-ID') or ''
+    thread_id = original_message.get('threadId')
+
+    sender_email_lc = (reply_email_context.sender_email or '').lower()
+
+    def _is_self(addr: str) -> bool:
+        return bool(sender_email_lc) and sender_email_lc in addr.lower()
 
-    to_addresses = headers_dict.get('From', '')
-    cc_addresses = headers_dict.get('Cc', '')
-    message_id_header = headers_dict.get('Message-ID', '')
+    cc_addresses = cc_header or ''
+    if reply_to_header and not _is_self(reply_to_header):
+        to_addresses = reply_to_header
+    elif from_header and not _is_self(from_header):
+        to_addresses = from_header
+    elif to_header and not _is_self(to_header):
+        to_addresses = to_header
+    else:
+        combined = ", ".join([v for v in (to_header, cc_header, from_header) if v])
+        to_addresses = combined
+        cc_addresses = ''
+
+    if (not to_addresses or _is_self(to_addresses)) and reply_email_context.fallback_recipient:
+        if not _is_self(reply_email_context.fallback_recipient):
+            to_addresses = reply_email_context.fallback_recipient
+            cc_addresses = ''
+
+    if not to_addresses or _is_self(to_addresses):
+        raise ValueError(
+            "No valid recipient found in the original message; refusing to reply to sender."
+        )
 
     # 3. Create the reply email message
-    msg = MIMEText(reply_email_context.reply_body)
+    plain_reply, html_reply, resolved_reply_fmt = body_variants(
+        reply_email_context.reply_body,
+        getattr(reply_email_context, "reply_body_format", None),
+    )
+    if resolved_reply_fmt == "text":
+        msg = MIMEText(plain_reply, _subtype="plain", _charset="utf-8")
+    else:
+        msg = MIMEMultipart("alternative")
+        msg.attach(MIMEText(plain_reply, "plain", _charset="utf-8"))
+        msg.attach(MIMEText(html_reply, "html", _charset="utf-8"))
     msg['To'] = to_addresses
     if cc_addresses:
         msg['Cc'] = cc_addresses
@@ -836,6 +1079,34 @@ async def get_calendar_events_using_service_account_async(
 
     return events
 
+def get_google_sheet_token(tool_config: Optional[List[Dict]] = None) -> str:
+    """
+    Retrieves the Google Sheets API key from the provided tool configuration or
+    the environment variable ``GOOGLE_SHEETS_API_KEY``.
+
+    Raises:
+        ValueError: If the Google Sheets integration has not been configured.
+    """
+    GOOGLE_SHEETS_API_KEY = None
+    if tool_config:
+        google_sheet_config = next(
+            (item for item in tool_config if item.get("name") == "google_sheets"), None
+        )
+        if google_sheet_config:
+            config_map = {
+                item["name"]: item["value"]
+                for item in google_sheet_config.get("configuration", [])
+                if item
+            }
+            GOOGLE_SHEETS_API_KEY = config_map.get("apiKey")
+
+    GOOGLE_SHEETS_API_KEY = GOOGLE_SHEETS_API_KEY or os.getenv("GOOGLE_SHEETS_API_KEY")
+    if not GOOGLE_SHEETS_API_KEY:
+        raise ValueError(
+            "Google Sheets integration is not configured. Please configure the connection to Google Sheets in Integrations."
+        )
+    return GOOGLE_SHEETS_API_KEY
+
 def get_sheet_id_from_url(sheet_url: str) -> str:
     """
     Extract the spreadsheet ID from a typical Google Sheets URL.
@@ -848,6 +1119,53 @@ def get_sheet_id_from_url(sheet_url: str) -> str:
         raise ValueError("Could not extract spreadsheet ID from the provided URL.")
     return match.group(1)
 
+
+def get_document_id_from_url(doc_url: str) -> str:
+    """Extract the document ID from a typical Google Docs URL.
+
+    Example URL format:
+        https://docs.google.com/document/d/<DOCUMENT_ID>/edit
+    """
+    match = re.search(r"/d/([a-zA-Z0-9-_]+)/", doc_url)
+    if not match:
+        raise ValueError("Could not extract document ID from the provided URL.")
+    return match.group(1)
+
+async def read_google_sheet_with_api_token(
+    sheet_url: str,
+    range_name: str,
+    sender_email: str,               # kept for signature compatibility – not used
+    tool_config: Optional[List[Dict]] = None
+) -> List[List[str]]:
+    """
+    Read data from a *public* Google Sheet (shared “Anyone with the link → Viewer”)
+    using an API key instead of OAuth credentials.
+    """
+
+    # 1️⃣ Spreadsheet ID from the URL
+    spreadsheet_id = get_sheet_id_from_url(sheet_url)
+
+    # 2️⃣ Grab the API key (tool_config ➜ googlesheet › apiKey, or env var)
+    api_key = get_google_sheet_token(tool_config)
+
+    # 3️⃣ Build the Sheets service with the key
+    service = build("sheets", "v4", developerKey=api_key)
+    sheet   = service.spreadsheets()
+
+    # 4️⃣ Default range to the first sheet if none supplied
+    if not range_name:
+        metadata  = sheet.get(spreadsheetId=spreadsheet_id).execute()
+        range_name = metadata["sheets"][0]["properties"]["title"]
+
+    # 5️⃣ Fetch the values
+    result = sheet.values().get(
+        spreadsheetId=spreadsheet_id,
+        range=range_name
+    ).execute()
+
+    return result.get("values", [])
+
+
 async def read_google_sheet(
     sheet_url: str,
     range_name: str,
@@ -896,7 +1214,56 @@ async def read_google_sheet(
     except HttpError as e:
         logging.error(f"An error occurred while reading the Google Sheet: {e}")
         raise
-    
+
+
+async def read_google_document(
+    doc_url: str,
+    sender_email: str,
+    tool_config: Optional[List[Dict]] = None,
+) -> str:
+    """Read text content from a Google Doc using a service account.
+
+    Args:
+        doc_url (str): Full URL of the Google Document.
+        sender_email (str): The email address to impersonate.
+        tool_config (Optional[List[Dict]]): Tool configuration for credentials.
+
+    Returns:
+        str: The concatenated text content of the document.
+
+    Raises:
+        HttpError: If there's an error calling the Docs API.
+    """
+
+    # --- 1. Extract Document ID from URL ---
+    document_id = get_document_id_from_url(doc_url)
+
+    # --- 2. Set up credentials ---
+    SCOPES = ['https://www.googleapis.com/auth/documents.readonly']
+    credentials = get_google_credentials(sender_email, SCOPES, tool_config)
+
+    # --- 3. Build the Docs service and fetch the document ---
+    try:
+        service = build('docs', 'v1', credentials=credentials)
+        document = service.documents().get(documentId=document_id).execute()
+
+        content = document.get('body', {}).get('content', [])
+        text_parts: List[str] = []
+        for element in content:
+            paragraph = element.get('paragraph')
+            if not paragraph:
+                continue
+            for elem in paragraph.get('elements', []):
+                text_run = elem.get('textRun')
+                if text_run:
+                    text_parts.append(text_run.get('content', ''))
+
+        return ''.join(text_parts)
+
+    except HttpError as e:
+        logging.error(f"An error occurred while reading the Google Document: {e}")
+        raise
+
 def save_values_to_csv(values: List[List[str]], output_filename: str) -> str:
     """
     Saves a list of row values (list of lists) to a CSV file.
@@ -918,4 +1285,3 @@ def save_values_to_csv(values: List[List[str]], output_filename: str) -> str:
         writer.writerows(values)
 
     return local_file_path
-

dhisana/utils/hubspot_clearbit.py

@@ -27,7 +27,9 @@ async def get_company_domain_from_breeze(company_name: str):
     """
     HUBSPOT_API_KEY = os.environ.get('HUBSPOT_API_KEY')
     if not HUBSPOT_API_KEY:
-        return {'error': "HubSpot API key not found in environment variables"}
+        return {
+            'error': "HubSpot integration is not configured. Please configure the connection to HubSpot in Integrations."
+        }
 
     if not company_name:
         return {'error': "Company name must be provided"}