update

app.py

@@ -1,14 +1,103 @@
-from flask import Flask, request, jsonify
+# from flask import Flask, request, jsonify
+# from telegram import Bot
+# from telegram.error import TelegramError
+# from dotenv import load_dotenv
+
+# # Change this import
+# from datetime import datetime, timezone  # instead of just datetime
+# import os
+# import asyncio
+
+# app = Flask(__name__)
+# load_dotenv()
+
+# TELEGRAM_BOT_TOKEN = os.getenv("TELEGRAM_BOT_TOKEN")
+# TELEGRAM_CHAT_ID = os.getenv("TELEGRAM_CHAT_ID")
+
+# bot = Bot(token=TELEGRAM_BOT_TOKEN)
+
+# async def send_telegram_message_async(message):
+#     try:
+#         await bot.send_message(
+#             chat_id=TELEGRAM_CHAT_ID,
+#             text=message,
+#             parse_mode="Markdown",
+#             disable_notification=True
+#         )
+#         return {"ok": True}
+#     except TelegramError as e:
+#         return {"ok": False, "error": str(e)}
+
+# def send_telegram_message(message):
+#     # Run async function in Flask's synchronous context
+#     loop = asyncio.new_event_loop()
+#     asyncio.set_event_loop(loop)
+#     result = loop.run_until_complete(send_telegram_message_async(message))
+#     loop.close()
+#     return result
+
+# @app.route('/', methods=['GET'])
+# def health_check():
+#     return jsonify(
+#         {
+#             "status": "healthy", 
+#             "message": "Telegram backend is running", 
+#             "timestamp": datetime.now(timezone.utc).isoformat() + " UTC"
+#             }
+#     )
+
+# @app.route('/send-message', methods=['POST'])
+# def send_message():
+#     try:
+#         data = request.get_json()
+#         required_fields = ['name', 'email', 'message']
+#         if not all(field in data for field in required_fields):
+#             return jsonify({"error": "Missing required fields: name, email, message"}), 400
+
+#         name = data['name'].strip()
+#         email = data['email'].strip()
+#         message = data['message'].strip()
+
+#         if not all([name, email, message]):
+#             return jsonify({"error": "All fields must not be empty"}), 400
+#         if len(message) > 4096:
+#             return jsonify({"error": "Message exceeds 4096 character limit"}), 400
+#         if '@' not in email or '.' not in email.split('@')[1]:
+#             return jsonify({"error": "Invalid email format"}), 400
+
+#         timestamp = datetime.now(timezone.utc).isoformat().split('.')[0] + " UTC"
+#         telegram_message = (
+#             f"*New Message*\n"
+#             f"_Received on: {timestamp}_\n"
+#             f"---\n"
+#             f"*Sender Details:*\n"
+#             f"- *Name:* {name}\n"
+#             f"- *Email:* {email}\n"
+#             f"---\n"
+#             f"*Message:*\n"
+#             f"{message}"
+#         )
+
+#         result = send_telegram_message(telegram_message)
+#         if result.get("ok"):
+#             return jsonify({"success": True, "message": "Message sent to Telegram"}), 200
+#         else:
+#             return jsonify({"error": "Failed to send message", "details": result.get("error", "Unknown error")}), 500
+#     except Exception as e:
+#         return jsonify({"error": f"Server error: {str(e)}"}), 500
+
+# if __name__ == "__main__":
+#     app.run(host="0.0.0.0", port=7860)
+
+from fastapi import FastAPI, HTTPException
 from telegram import Bot
 from telegram.error import TelegramError
-from dotenv import load_dotenv
-
-# Change this import
-from datetime import datetime, timezone  # instead of just datetime
+from pydantic import BaseModel
+from datetime import datetime, timezone
 import os
-import asyncio
+from dotenv import load_dotenv
 
-app = Flask(__name__)
+app = FastAPI()
 load_dotenv()
 
 TELEGRAM_BOT_TOKEN = os.getenv("TELEGRAM_BOT_TOKEN")
@@ -16,54 +105,32 @@ TELEGRAM_CHAT_ID = os.getenv("TELEGRAM_CHAT_ID")
 
 bot = Bot(token=TELEGRAM_BOT_TOKEN)
 
-async def send_telegram_message_async(message):
-    try:
-        await bot.send_message(
-            chat_id=TELEGRAM_CHAT_ID,
-            text=message,
-            parse_mode="Markdown",
-            disable_notification=True
-        )
-        return {"ok": True}
-    except TelegramError as e:
-        return {"ok": False, "error": str(e)}
-
-def send_telegram_message(message):
-    # Run async function in Flask's synchronous context
-    loop = asyncio.new_event_loop()
-    asyncio.set_event_loop(loop)
-    result = loop.run_until_complete(send_telegram_message_async(message))
-    loop.close()
-    return result
-
-@app.route('/', methods=['GET'])
-def health_check():
-    return jsonify(
-        {
-            "status": "healthy", 
-            "message": "Telegram backend is running", 
-            "timestamp": datetime.now(timezone.utc).isoformat() + " UTC"
-            }
-    )
-
-@app.route('/send-message', methods=['POST'])
-def send_message():
-    try:
-        data = request.get_json()
-        required_fields = ['name', 'email', 'message']
-        if not all(field in data for field in required_fields):
-            return jsonify({"error": "Missing required fields: name, email, message"}), 400
+class MessageData(BaseModel):
+    name: str
+    email: str
+    message: str
 
-        name = data['name'].strip()
-        email = data['email'].strip()
-        message = data['message'].strip()
+@app.get("/health")
+async def health_check():
+    return {
+        "status": "healthy",
+        "message": "Telegram backend is running",
+        "timestamp": datetime.now(timezone.utc).isoformat() + " UTC"
+    }
+
+@app.post("/send-message")
+async def send_message(data: MessageData):
+    try:
+        name = data.name.strip()
+        email = data.email.strip()
+        message = data.message.strip()
 
         if not all([name, email, message]):
-            return jsonify({"error": "All fields must not be empty"}), 400
+            raise HTTPException(status_code=400, detail="All fields must not be empty")
         if len(message) > 4096:
-            return jsonify({"error": "Message exceeds 4096 character limit"}), 400
+            raise HTTPException(status_code=400, detail="Message exceeds 4096 character limit")
         if '@' not in email or '.' not in email.split('@')[1]:
-            return jsonify({"error": "Invalid email format"}), 400
+            raise HTTPException(status_code=400, detail="Invalid email format")
 
         timestamp = datetime.now(timezone.utc).isoformat().split('.')[0] + " UTC"
         telegram_message = (
@@ -78,13 +145,19 @@ def send_message():
             f"{message}"
         )
 
-        result = send_telegram_message(telegram_message)
-        if result.get("ok"):
-            return jsonify({"success": True, "message": "Message sent to Telegram"}), 200
-        else:
-            return jsonify({"error": "Failed to send message", "details": result.get("error", "Unknown error")}), 500
+        try:
+            await bot.send_message(
+                chat_id=TELEGRAM_CHAT_ID,
+                text=telegram_message,
+                parse_mode="Markdown",
+                disable_notification=True
+            )
+            return {"success": True, "message": "Message sent to Telegram"}
+        except TelegramError as e:
+            raise HTTPException(status_code=500, detail=f"Failed to send message: {str(e)}")
     except Exception as e:
-        return jsonify({"error": f"Server error: {str(e)}"}), 500
+        raise HTTPException(status_code=500, detail=f"Server error: {str(e)}")
 
 if __name__ == "__main__":
-    app.run(host="0.0.0.0", port=7860)
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=7860)

requirements.txt

@@ -1,4 +1,5 @@
-flask==3.0.3
-requests==2.32.3
-python-dotenv==1.0.1
-python-telegram-bot==21.4
+fastapi==0.115.2
+uvicorn==0.32.0
+python-telegram-bot==21.5
+pydantic==2.9.2
+python-dotenv==1.0.1