Spaces:

Samfredoly
/

SMTP

Paused

App Files Files Community

Samfredoly commited on Feb 20, 2025

Commit

04dab42

verified ·

1 Parent(s): acba745

Update app.py

Browse files

Files changed (1) hide show

app.py +164 -65

app.py CHANGED Viewed

@@ -1,6 +1,7 @@
 import logging
 import ssl
 import smtplib
 from email.mime.text import MIMEText
 from flask import Flask, request, jsonify
 from aiosmtpd.controller import Controller
@@ -8,7 +9,8 @@ from aiosmtpd.handlers import Sink
 from aiosmtpd.smtp import SMTP, AuthResult, LoginPassword
 from dotenv import load_dotenv
 import os
-from typing import Optional  # Add this import
 # Load environment variables
 load_dotenv()
@@ -18,15 +20,19 @@ logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger("app")
 # SMTP Server Configuration
-SMTP_HOST = "0.0.0.0"
-SMTP_PORT = 587
-SMTP_USER = os.getenv("SMTP_USER", "noreply@yourdomain.com")  # Use a valid domain
 SMTP_PASSWORD = os.getenv("SMTP_PASSWORD", "password")
-# WhatsApp webhook verification token
 WHATSAPP_WEBHOOK_TOKEN = os.getenv("WHATSAPP_WEBHOOK_TOKEN", "your_webhook_token")
-# Authentication Credentials
 VALID_USERS = {
     SMTP_USER: SMTP_PASSWORD,
 }
@@ -34,8 +40,45 @@ VALID_USERS = {
 # Flask app for WhatsApp bot
 app = Flask(__name__)
-# SMTP Server Handler
 class AuthenticatedSMTPHandler(Sink):
     async def handle_AUTH(self, server: SMTP, args: str, mechanism: str) -> Optional[AuthResult]:
         if mechanism.upper() != "LOGIN":
             return AuthResult(success=False, handled=False)
@@ -43,26 +86,44 @@ class AuthenticatedSMTPHandler(Sink):
     async def handle_AUTH_LOGIN(self, server: SMTP, args: str) -> Optional[AuthResult]:
         try:
-            username, password = args.split()
             if username in VALID_USERS and VALID_USERS[username] == password:
                 return AuthResult(success=True, auth_data=LoginPassword(username, password))
             else:
                 return AuthResult(success=False, message="Invalid credentials")
         except Exception as e:
             logger.error(f"Authentication error: {e}")
             return AuthResult(success=False, message="Authentication failed")
     async def handle_DATA(self, server: SMTP, session, envelope):
-        logger.info(f"Received email from: {envelope.mail_from}")
-        logger.info(f"Recipients: {envelope.rcpt_tos}")
-        logger.info(f"Message data:\n{envelope.content.decode('utf-8')}")
-        return "250 Message accepted for delivery"
-# Start SMTP Server
-def start_smtp_server():
-    # Enable SSL/TLS
-    ssl_context = ssl.create_default_context(ssl.Purpose.CLIENT_AUTH)
-    ssl_context.load_cert_chain("cert.pem", "key.pem")  # Load your certificate and key
     handler = AuthenticatedSMTPHandler()
     controller = Controller(
@@ -70,82 +131,120 @@ def start_smtp_server():
         hostname=SMTP_HOST,
         port=SMTP_PORT,
         enable_SMTPUTF8=True,
-        ssl_context=ssl_context,  # Enable SSL/TLS
         auth_required=True,
     )
-    logger.info(f"Starting SMTP server on {SMTP_HOST}:{SMTP_PORT} with SSL/TLS...")
-    controller.start()
     return controller
-# WhatsApp Webhook
 @app.route("/webhook", methods=["GET", "POST"])
 def webhook():
     if request.method == "GET":
-        # Verify webhook
         mode = request.args.get("hub.mode")
         token = request.args.get("hub.verify_token")
         challenge = request.args.get("hub.challenge")
         if mode == "subscribe" and token == WHATSAPP_WEBHOOK_TOKEN:
-            logger.info("Webhook verified successfully")
             return challenge, 200
         else:
-            logger.error("Webhook verification failed")
             return "Verification failed", 403
     elif request.method == "POST":
-        # Handle incoming messages
         data = request.json
         logger.info(f"Incoming webhook data: {data}")
         try:
-            # Extract message details
-            message = data["entry"][0]["changes"][0]["value"]["messages"][0]
-            sender_number = message["from"]
-            message_body = message["text"]["body"]
-            # Parse the message (format: "send email to <recipient> subject <subject> body <body>")
-            parts = message_body.split("subject")
-            recipient_part = parts[0].replace("send email to", "").strip()
-            subject_part = parts[1].split("body")[0].strip()
-            body_part = parts[1].split("body")[1].strip()
-            recipient = recipient_part
-            subject = subject_part
-            body = body_part
-            # Send email
-            send_email(recipient, subject, body)
-            response_msg = f"Email sent to {recipient} with subject '{subject}'."
         except Exception as e:
             logger.error(f"Error processing message: {e}")
-            response_msg = "Invalid format. Use: 'send email to <recipient> subject <subject> body <body>'."
-        # Send response back to WhatsApp
         return jsonify({"status": "success", "message": response_msg}), 200
-# Send Email Function
-def send_email(recipient, subject, body):
-    msg = MIMEText(body)
-    msg['Subject'] = subject
-    msg['From'] = SMTP_USER  # Use a valid "From" address
-    msg['To'] = recipient
-    with smtplib.SMTP(SMTP_HOST, SMTP_PORT) as server:
-        server.starttls()  # Enable TLS
-        server.login(SMTP_USER, SMTP_PASSWORD)
-        server.sendmail(SMTP_USER, [recipient], msg.as_string())
-    logger.info(f"Email sent to {recipient}")
-# Main Function
-if __name__ == "__main__":
-    # Start SMTP server
-    smtp_controller = start_smtp_server()
-    # Start Flask app for WhatsApp bot
     try:
-        app.run(host="0.0.0.0", port=5000)
     except KeyboardInterrupt:
-        logger.info("Shutting down SMTP server...")
-        smtp_controller.stop()

 import logging
 import ssl
 import smtplib
+import re
 from email.mime.text import MIMEText
 from flask import Flask, request, jsonify
 from aiosmtpd.controller import Controller
 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()
 logger = logging.getLogger("app")
 # SMTP Server Configuration
+SMTP_HOST = os.getenv("SMTP_HOST", "0.0.0.0")
+SMTP_PORT = int(os.getenv("SMTP_PORT", "587"))
+CLIENT_SMTP_HOST = os.getenv("CLIENT_SMTP_HOST", "localhost")
+CLIENT_SMTP_PORT = SMTP_PORT
+SMTP_USER = os.getenv("SMTP_USER", "noreply@yourdomain.com")
 SMTP_PASSWORD = os.getenv("SMTP_PASSWORD", "password")
+# WhatsApp webhook configuration
 WHATSAPP_WEBHOOK_TOKEN = os.getenv("WHATSAPP_WEBHOOK_TOKEN", "your_webhook_token")
+# Add a default phone number ID from the environment
+WHATSAPP_PHONE_NUMBER_ID = os.getenv("WHATSAPP_PHONE_NUMBER_ID", "default_phone_number_id")
+# Authentication Credentials for SMTP server
 VALID_USERS = {
     SMTP_USER: SMTP_PASSWORD,
 }
 # 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":
             return AuthResult(success=False, handled=False)
     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")
+            username, password = parts
             if username in VALID_USERS and VALID_USERS[username] == password:
+                logger.info(f"Authenticated user: {username}")
                 return AuthResult(success=True, auth_data=LoginPassword(username, password))
             else:
+                logger.warning(f"Authentication failed for user: {username}")
                 return AuthResult(success=False, message="Invalid credentials")
         except Exception as e:
             logger.error(f"Authentication error: {e}")
             return AuthResult(success=False, message="Authentication failed")
     async def handle_DATA(self, server: SMTP, session, envelope):
+        try:
+            message_content = envelope.content.decode('utf-8', errors='replace')
+            logger.info(f"Received email from: {envelope.mail_from}")
+            logger.info(f"Recipients: {envelope.rcpt_tos}")
+            logger.info(f"Message data:\n{message_content}")
+            return "250 Message accepted for delivery"
+        except Exception as e:
+            logger.error(f"Error processing email data: {e}")
+            return "451 Internal server error"
+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}")
+        raise
     handler = AuthenticatedSMTPHandler()
     controller = Controller(
         hostname=SMTP_HOST,
         port=SMTP_PORT,
         enable_SMTPUTF8=True,
+        ssl_context=ssl_context,
         auth_required=True,
     )
+    try:
+        logger.info(f"Starting SMTP server on {SMTP_HOST}:{SMTP_PORT} with SSL/TLS...")
+        controller.start()
+    except Exception as e:
+        logger.error(f"Failed to start SMTP server: {e}")
+        raise
     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")
         token = request.args.get("hub.verify_token")
         challenge = request.args.get("hub.challenge")
         if mode == "subscribe" and token == WHATSAPP_WEBHOOK_TOKEN:
+            logger.info("Webhook verified successfully.")
             return challenge, 200
         else:
+            logger.error("Webhook verification failed.")
             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>'.")
         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()
     try:
+        flask_thread.join()
     except KeyboardInterrupt:
+        logger.info("Keyboard interrupt received. Shutting down servers...")
+    finally:
+        smtp_controller.stop()
+        logger.info("SMTP server stopped.")
+if __name__ == "__main__":
+    main()