Spaces:

Samfredoly
/

SMTP

Paused

App Files Files Community

Samfredoly commited on Feb 20, 2025

Commit

20fe538

verified ·

1 Parent(s): fa11f14

Update app.py

Browse files

Files changed (1) hide show

app.py +79 -80

app.py CHANGED Viewed

@@ -10,7 +10,7 @@ from aiosmtpd.smtp import SMTP, AuthResult, LoginPassword
 from dotenv import load_dotenv
 import os
 import threading
-from typing import Optional, Tuple
 # Load environment variables
 load_dotenv()
@@ -30,7 +30,10 @@ SMTP_PASSWORD = os.getenv("SMTP_PASSWORD", "password")
 # WhatsApp webhook configuration
 WHATSAPP_WEBHOOK_TOKEN = os.getenv("WHATSAPP_WEBHOOK_TOKEN", "your_webhook_token")
 WHATSAPP_PHONE_NUMBER_ID = os.getenv("WHATSAPP_PHONE_NUMBER_ID", "default_phone_number_id")
-META_ACCESS_TOKEN = os.getenv("META_ACCESS_TOKEN", "default_meta_access_token")  # For outgoing WhatsApp API calls
 # Authentication Credentials for SMTP server
 VALID_USERS = {
@@ -40,44 +43,16 @@ VALID_USERS = {
 # Flask app for WhatsApp bot
 app = Flask(__name__)
-# Regular expression for parsing the WhatsApp email command.
-# Expected format: "send email to <recipient> subject <subject> body <body>"
-EMAIL_COMMAND_PATTERN = re.compile(
-    r"send email to\s+(?P<recipient>\S+)\s+subject\s+(?P<subject>.+?)\s+body\s+(?P<body>.+)$",
-    re.IGNORECASE,
-)
 def validate_email(email: str) -> bool:
-    """Basic email validation using a simple regex."""
-    pattern = r"^[^@]+@[^@]+\.[^@]+$"
-    return re.match(pattern, email) is not None
-def parse_message(message: str) -> Tuple[Optional[str], Optional[str], Optional[str], Optional[str]]:
-    """
-    Parse the incoming WhatsApp message.
-    Returns a tuple: (recipient, subject, body, error_message)
-    If parsing is successful, error_message will be None.
-    """
-    match = EMAIL_COMMAND_PATTERN.match(message)
-    if not match:
-        return None, None, None, ("Invalid format. Use: 'send email to <recipient> subject <subject> body <body>'.")
-    recipient = match.group("recipient").strip()
-    subject = match.group("subject").strip()
-    body = match.group("body").strip()
-    if not validate_email(recipient):
-        return None, None, None, f"Invalid email address: {recipient}"
-    if not subject:
-        return None, None, None, "Subject cannot be empty."
-    if not body:
-        return None, None, None, "Email body cannot be empty."
-    return recipient, subject, body, None
 class AuthenticatedSMTPHandler(Sink):
     """
-    Custom SMTP handler for processing incoming emails with authentication.
     """
     async def handle_AUTH(self, server: SMTP, args: str, mechanism: str) -> Optional[AuthResult]:
         if mechanism.upper() != "LOGIN":
@@ -86,7 +61,6 @@ class AuthenticatedSMTPHandler(Sink):
     async def handle_AUTH_LOGIN(self, server: SMTP, args: str) -> Optional[AuthResult]:
         try:
-            # Expecting args in the form "username password"
             parts = args.split()
             if len(parts) != 2:
                 return AuthResult(success=False, message="Invalid authentication format")
@@ -114,12 +88,11 @@ class AuthenticatedSMTPHandler(Sink):
 def start_smtp_server() -> Controller:
     """
-    Start the SMTP server with SSL/TLS and authentication.
-    Returns the controller instance.
     """
     try:
         ssl_context = ssl.create_default_context(ssl.Purpose.CLIENT_AUTH)
-        ssl_context.load_cert_chain("cert.pem", "key.pem")  # Load your certificate and key
         logger.info("SSL context created successfully.")
     except Exception as e:
         logger.error(f"Failed to load SSL certificate and key: {e}")
@@ -144,33 +117,37 @@ def start_smtp_server() -> Controller:
     return controller
-def send_email(recipient: str, subject: str, body: str) -> bool:
     """
-    Send an email using the SMTP client.
-    Returns True if the email is sent successfully, otherwise False.
     """
     msg = MIMEText(body)
     msg['Subject'] = subject
-    msg['From'] = SMTP_USER
-    msg['To'] = recipient
     try:
         with smtplib.SMTP(CLIENT_SMTP_HOST, CLIENT_SMTP_PORT) as server:
-            server.starttls()  # Upgrade connection to TLS
             server.login(SMTP_USER, SMTP_PASSWORD)
-            server.sendmail(SMTP_USER, [recipient], msg.as_string())
-        logger.info(f"Email sent to {recipient}")
         return True
     except Exception as e:
-        logger.error(f"Error sending email to {recipient}: {e}")
         return False
 @app.route("/webhook", methods=["GET", "POST"])
 def webhook():
     """
-    Handle WhatsApp webhook verification and incoming messages.
-    GET: Verify the webhook.
-    POST: Process incoming messages and trigger email sending.
     """
     if request.method == "GET":
         mode = request.args.get("hub.mode")
@@ -185,57 +162,79 @@ def webhook():
             return "Verification failed", 403
     elif request.method == "POST":
-        data = request.json
-        logger.info(f"Incoming webhook data: {data}")
         try:
             value = data["entry"][0]["changes"][0]["value"]
             message = value["messages"][0]
-            # Extract sender's WhatsApp number and phone number ID (fallback to env variable)
             sender_number = message.get("from", "unknown")
             phone_number_id = value.get("metadata", {}).get("phone_number_id", WHATSAPP_PHONE_NUMBER_ID)
-            logger.info(f"Received message from {sender_number} using phone number ID: {phone_number_id}")
-            message_body = message.get("text", {}).get("body", "")
-            recipient, subject, body, error = parse_message(message_body)
-            if error:
-                response_msg = error
-                logger.error(f"Message parsing error from {sender_number}: {error}")
-            else:
-                if send_email(recipient, subject, body):
-                    response_msg = f"Email sent to {recipient} with subject '{subject}'."
-                else:
-                    response_msg = f"Failed to send email to {recipient}."
         except Exception as e:
-            logger.error(f"Error processing message: {e}")
-            response_msg = ("Error processing message. Please ensure the format is: "
-                            "'send email to <recipient> subject <subject> body <body>'.")
-        # If you need to send a response back to WhatsApp via the API, use META_ACCESS_TOKEN in the request header.
         return jsonify({"status": "success", "message": response_msg}), 200
 def run_flask_app():
-    """
-    Run the Flask app.
-    """
     try:
         app.run(host="0.0.0.0", port=5000)
     except Exception as e:
         logger.error(f"Error starting Flask app: {e}")
 def main():
-    """
-    Main function to start the SMTP server and Flask app concurrently.
-    """
     try:
         smtp_controller = start_smtp_server()
     except Exception as e:
         logger.critical("Failed to start SMTP server. Exiting.")
         return
-    # Run Flask app in a separate thread
     flask_thread = threading.Thread(target=run_flask_app)
     flask_thread.start()

 from dotenv import load_dotenv
 import os
 import threading
+from typing import Optional
 # Load environment variables
 load_dotenv()
 # WhatsApp webhook configuration
 WHATSAPP_WEBHOOK_TOKEN = os.getenv("WHATSAPP_WEBHOOK_TOKEN", "your_webhook_token")
 WHATSAPP_PHONE_NUMBER_ID = os.getenv("WHATSAPP_PHONE_NUMBER_ID", "default_phone_number_id")
+META_ACCESS_TOKEN = os.getenv("META_ACCESS_TOKEN", "default_meta_access_token")
+# Global conversation state mapping sender's WhatsApp number to their conversation details.
+conversations = {}
 # Authentication Credentials for SMTP server
 VALID_USERS = {
 # Flask app for WhatsApp bot
 app = Flask(__name__)
+# Regular expression for validating email addresses
+EMAIL_REGEX = re.compile(r"^[^@]+@[^@]+\.[^@]+$")
 def validate_email(email: str) -> bool:
+    """Simple email validation using a regex."""
+    return re.match(EMAIL_REGEX, email) is not None
 class AuthenticatedSMTPHandler(Sink):
     """
+    Custom SMTP handler that logs incoming emails and enforces simple LOGIN authentication.
     """
     async def handle_AUTH(self, server: SMTP, args: str, mechanism: str) -> Optional[AuthResult]:
         if mechanism.upper() != "LOGIN":
     async def handle_AUTH_LOGIN(self, server: SMTP, args: str) -> Optional[AuthResult]:
         try:
             parts = args.split()
             if len(parts) != 2:
                 return AuthResult(success=False, message="Invalid authentication format")
 def start_smtp_server() -> Controller:
     """
+    Starts the SMTP server with SSL/TLS and authentication.
     """
     try:
         ssl_context = ssl.create_default_context(ssl.Purpose.CLIENT_AUTH)
+        ssl_context.load_cert_chain("cert.pem", "key.pem")
         logger.info("SSL context created successfully.")
     except Exception as e:
         logger.error(f"Failed to load SSL certificate and key: {e}")
     return controller
+def send_email(from_addr: str, to_addr: str, subject: str, body: str) -> bool:
     """
+    Sends an email using the SMTP client. The 'from_addr' is provided by the user.
+    Note: Some SMTP servers restrict the 'From' address to the authenticated user.
     """
     msg = MIMEText(body)
     msg['Subject'] = subject
+    msg['From'] = from_addr
+    msg['To'] = to_addr
     try:
         with smtplib.SMTP(CLIENT_SMTP_HOST, CLIENT_SMTP_PORT) as server:
+            server.starttls()  # Upgrade to TLS
             server.login(SMTP_USER, SMTP_PASSWORD)
+            server.sendmail(from_addr, [to_addr], msg.as_string())
+        logger.info(f"Email sent from {from_addr} to {to_addr}")
         return True
     except Exception as e:
+        logger.error(f"Error sending email from {from_addr} to {to_addr}: {e}")
         return False
 @app.route("/webhook", methods=["GET", "POST"])
 def webhook():
     """
+    Handles WhatsApp webhook verification and processes incoming messages.
+    This bot acts as an SMTP assistant guiding the user to provide:
+      1. 'From' email address
+      2. Recipient ('To') email address
+      3. Email subject
+      4. Email body
+    Once all details are provided, the email is sent.
     """
     if request.method == "GET":
         mode = request.args.get("hub.mode")
             return "Verification failed", 403
     elif request.method == "POST":
         try:
+            data = request.json
+            logger.info(f"Incoming webhook data: {data}")
             value = data["entry"][0]["changes"][0]["value"]
             message = value["messages"][0]
             sender_number = message.get("from", "unknown")
             phone_number_id = value.get("metadata", {}).get("phone_number_id", WHATSAPP_PHONE_NUMBER_ID)
+            message_body = message.get("text", {}).get("body", "").strip()
         except Exception as e:
+            logger.error(f"Error parsing webhook data: {e}")
+            return jsonify({"status": "error", "message": "Invalid webhook payload"}), 400
+        # Retrieve or initialize the conversation state for this sender.
+        state = conversations.get(sender_number, {})
+        # If no conversation exists, start a new one.
+        if not state:
+            conversations[sender_number] = {"step": "from"}
+            response_msg = "Welcome to SMTP Assistant! Please provide your 'From' email address."
+        else:
+            step = state.get("step")
+            if step == "from":
+                if validate_email(message_body):
+                    state["from"] = message_body
+                    state["step"] = "to"
+                    response_msg = "Thanks! Now, please provide the recipient's email address."
+                else:
+                    response_msg = "Invalid email format. Please provide a valid 'From' email address."
+            elif step == "to":
+                if validate_email(message_body):
+                    state["to"] = message_body
+                    state["step"] = "subject"
+                    response_msg = "Great! Please provide the email subject."
+                else:
+                    response_msg = "Invalid email format. Please provide a valid recipient email address."
+            elif step == "subject":
+                state["subject"] = message_body
+                state["step"] = "body"
+                response_msg = "Almost done! Please provide the email body."
+            elif step == "body":
+                state["body"] = message_body
+                # All details collected; send the email.
+                from_addr = state.get("from")
+                to_addr = state.get("to")
+                subject = state.get("subject")
+                body = state.get("body")
+                if send_email(from_addr, to_addr, subject, body):
+                    response_msg = f"Email sent successfully from {from_addr} to {to_addr}."
+                else:
+                    response_msg = "Failed to send email. Please try again later."
+                # Clear conversation state.
+                del conversations[sender_number]
+            else:
+                response_msg = "Unrecognized step. Let's start over. Please provide your 'From' email address."
+                conversations[sender_number] = {"step": "from"}
+        # Optionally, if you wish to send a follow-up message via the WhatsApp Business API,
+        # you can use META_ACCESS_TOKEN in the HTTP request headers.
         return jsonify({"status": "success", "message": response_msg}), 200
 def run_flask_app():
     try:
         app.run(host="0.0.0.0", port=5000)
     except Exception as e:
         logger.error(f"Error starting Flask app: {e}")
 def main():
     try:
         smtp_controller = start_smtp_server()
     except Exception as e:
         logger.critical("Failed to start SMTP server. Exiting.")
         return
     flask_thread = threading.Thread(target=run_flask_app)
     flask_thread.start()