Upload 6 files

config.py

@@ -0,0 +1,28 @@
+import os
+from dotenv import load_dotenv
+
+load_dotenv()
+
+BOTS = {
+    "device_01": {
+        "instance_id": os.getenv("GREENAPI_INSTANCE_ID_1", "7105210836"),
+        "token": os.getenv("GREENAPI_TOKEN_1", "TOKEN1"),
+        "label": "ADK Bot 1",
+    },
+    "device_02": {
+        "instance_id": os.getenv("GREENAPI_INSTANCE_ID_2", "7105222222"),
+        "token": os.getenv("GREENAPI_TOKEN_2", "TOKEN2"),
+        "label": "ADK Bot 2",
+    }
+}
+
+COMPLAINT_FORM_URL = os.getenv(
+    "COMPLAINT_FORM_URL",
+    "https://mrhelp92.github.io/Complaint-form/"
+)
+
+SUPABASE_URL = os.getenv("SUPABASE_URL", "")
+SUPABASE_SERVICE_ROLE_KEY = os.getenv("SUPABASE_SERVICE_ROLE_KEY", "")
+
+TIMEOUT_SEC = int(os.getenv("TIMEOUT_SEC", "60"))
+APP_BASE_URL = os.getenv("APP_BASE_URL", "")  # optional

db.py

@@ -0,0 +1,7 @@
+from supabase import create_client
+from config import SUPABASE_URL, SUPABASE_SERVICE_ROLE_KEY
+
+if not SUPABASE_URL or not SUPABASE_SERVICE_ROLE_KEY:
+    raise ValueError("Missing SUPABASE_URL or SUPABASE_SERVICE_ROLE_KEY")
+
+supabase = create_client(SUPABASE_URL, SUPABASE_SERVICE_ROLE_KEY)

greenapi.py

@@ -0,0 +1,135 @@
+import requests
+from config import BOTS, TIMEOUT_SEC
+
+
+def get_bot_config(device_key: str):
+    bot = BOTS.get(device_key)
+    if not bot:
+        raise ValueError(f"Unknown device_key: {device_key}")
+    return bot
+
+
+def get_device_key_by_instance_id(instance_id: str):
+    for device_key, bot in BOTS.items():
+        if str(bot.get("instance_id")) == str(instance_id):
+            return device_key
+    return None
+
+
+def build_greenapi_base(instance_id: str) -> str:
+    return f"https://7105.api.greenapi.com/waInstance{instance_id}"
+
+
+def get_greenapi_urls(device_key: str):
+    bot = get_bot_config(device_key)
+
+    instance_id = bot["instance_id"]
+    token = bot["token"]
+
+    base = build_greenapi_base(instance_id)
+
+    return {
+        "text": f"{base}/sendMessage/{token}",
+        "reply_buttons": f"{base}/sendInteractiveButtonsReply/{token}",
+        "url_buttons": f"{base}/sendInteractiveButtons/{token}",
+    }
+
+
+def send_text_message(device_key: str, chat_id: str, message: str):
+    urls = get_greenapi_urls(device_key)
+
+    payload = {
+        "chatId": chat_id,
+        "message": message
+    }
+
+    headers = {"Content-Type": "application/json"}
+
+    resp = requests.post(
+        urls["text"],
+        json=payload,
+        headers=headers,
+        timeout=TIMEOUT_SEC
+    )
+    return resp.status_code, (resp.text or "")[:1500]
+
+
+def send_reply_buttons(device_key: str, chat_id: str, header: str, body: str, footer: str, buttons: list):
+    urls = get_greenapi_urls(device_key)
+
+    payload = {
+        "chatId": chat_id,
+        "header": header,
+        "body": body,
+        "footer": footer,
+        "buttons": buttons
+    }
+
+    resp = requests.post(
+        urls["reply_buttons"],
+        json=payload,
+        timeout=TIMEOUT_SEC
+    )
+    return resp.status_code, (resp.text or "")[:1500]
+
+
+def send_url_button(device_key: str, chat_id: str, header: str, body: str, footer: str, url: str, button_text: str = "فتح الرابط"):
+    urls = get_greenapi_urls(device_key)
+
+    payload = {
+        "chatId": chat_id,
+        "header": header,
+        "body": body,
+        "footer": footer,
+        "buttons": [
+            {
+                "type": "url",
+                "buttonId": "1",
+                "buttonText": button_text,
+                "url": url
+            }
+        ]
+    }
+
+    resp = requests.post(
+        urls["url_buttons"],
+        json=payload,
+        timeout=TIMEOUT_SEC
+    )
+    return resp.status_code, (resp.text or "")[:1500]
+
+
+def extract_text_message(msg_data: dict) -> str:
+    if not isinstance(msg_data, dict):
+        return ""
+
+    t = (msg_data.get("typeMessage") or "").strip()
+
+    if t == "textMessage":
+        return ((msg_data.get("textMessageData") or {}).get("textMessage") or "").strip()
+
+    if t == "extendedTextMessage":
+        return ((msg_data.get("extendedTextMessageData") or {}).get("text") or "").strip()
+
+    if t == "interactiveButtonsResponse":
+        r = msg_data.get("interactiveButtonsResponse") or {}
+        txt = (r.get("selectedDisplayText") or "").strip()
+        if txt:
+            return txt
+        return (r.get("selectedId") or "").strip()
+
+    for path in [
+        ("textMessageData", "textMessage"),
+        ("extendedTextMessageData", "text"),
+        ("interactiveButtonsResponse", "selectedDisplayText"),
+        ("interactiveButtonsResponse", "selectedId"),
+        ("text",),
+        ("message",),
+    ]:
+        cur = msg_data
+        for k in path:
+            cur = cur.get(k) if isinstance(cur, dict) else None
+        if isinstance(cur, str) and cur.strip():
+            return cur.strip()
+
+    return ""

main.py

@@ -0,0 +1,225 @@
+import json
+from fastapi import FastAPI, Request
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import JSONResponse
+
+from greenapi import (
+    extract_text_message,
+    get_device_key_by_instance_id,
+    send_text_message,
+    send_url_button,
+)
+
+from engine.conversation_engine import process_message
+from messages import log_message
+
+from handoff.sales import create_sales_handoff
+from handoff.support import create_support_handoff
+
+app = FastAPI()
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=False,
+    allow_methods=["POST", "OPTIONS"],
+    allow_headers=["*"],
+)
+
+
+@app.get("/health")
+async def health():
+    return {"ok": True, "service": "up"}
+
+
+@app.post("/receive")
+async def webhook_receiver(req: Request):
+    try:
+        body = await req.json()
+    except Exception:
+        raw = await req.body()
+        print("===== RECEIVED RAW =====")
+        print(raw)
+        print("========================")
+        return {"ok": True}
+
+    print("===== RECEIVED JSON =====")
+    print(json.dumps(body, ensure_ascii=False, indent=2))
+    print("=========================")
+
+    # نتعامل فقط مع الرسائل الواردة
+    if body.get("typeWebhook") != "incomingMessageReceived":
+        return {"ok": True, "ignored": True}
+
+    instance_data = body.get("instanceData") or {}
+    sender_data = body.get("senderData") or {}
+    msg_data = body.get("messageData") or {}
+
+    # مهم: ده اللي هنستخدمه لتحديد أي bot/device استقبل الرسالة
+    instance_id = str(instance_data.get("idInstance") or "")
+    chat_id = sender_data.get("chatId")
+    text_message = extract_text_message(msg_data)
+
+    print(">>> instance_id:", instance_id)
+    print(">>> chat_id:", chat_id)
+    print(">>> text_message:", text_message)
+
+    if not instance_id or not chat_id or not text_message:
+        return {"ok": True, "skipped": True}
+
+    device_key = get_device_key_by_instance_id(instance_id)
+    if not device_key:
+        print(">>> Unknown instance_id:", instance_id)
+        return {
+            "ok": True,
+            "skipped": True,
+            "reason": "unknown_instance_id"
+        }
+
+    customer_phone = chat_id.replace("@c.us", "")
+    bot_number = device_key
+
+    # سجل الرسالة الواردة
+    try:
+        log_message(customer_phone, bot_number, "in", text_message)
+    except Exception as e:
+        print(">>> failed to log incoming message:", str(e))
+
+    # شغّل الـ engine
+    try:
+        result = process_message(
+            bot_number=bot_number,
+            customer_phone=customer_phone,
+            text=text_message
+        )
+    except Exception as e:
+        print(">>> engine error:", str(e))
+
+        fallback_reply = "تمام، حصلت مشكلة بسيطة. ممكن تعيد إرسال رسالتك مرة تانية؟"
+        try:
+            send_text_message(device_key, chat_id, fallback_reply)
+            log_message(customer_phone, bot_number, "out", fallback_reply)
+        except Exception as send_err:
+            print(">>> failed to send fallback:", str(send_err))
+
+        return JSONResponse(
+            status_code=200,
+            content={"ok": True, "error": str(e), "fallback_sent": True}
+        )
+
+    reply = (result.get("reply") or "").strip()
+    action = result.get("action")
+
+    # 1) لو فيه URL button
+    if action and action.get("type") == "url_button":
+        try:
+            status, txt = send_url_button(
+                device_key=device_key,
+                chat_id=chat_id,
+                header=action.get("header", "مرحباً بك"),
+                body=action.get("body", reply),
+                footer=action.get("footer", ""),
+                url=action.get("url"),
+                button_text=action.get("button_text", "فتح الرابط")
+            )
+            print(">>> sent url button:", status, txt)
+
+            try:
+                log_message(customer_phone, bot_number, "out", action.get("body", reply))
+            except Exception as e:
+                print(">>> failed to log outgoing url button body:", str(e))
+
+        except Exception as e:
+            print(">>> failed to send url button:", str(e))
+            # fallback text
+            fallback_reply = action.get("body", reply) or "تمام، افتح الرابط من فضلك."
+            try:
+                send_text_message(device_key, chat_id, fallback_reply)
+                log_message(customer_phone, bot_number, "out", fallback_reply)
+            except Exception as send_err:
+                print(">>> failed to send url fallback:", str(send_err))
+
+    # 2) غير كده ابعت text
+    else:
+        try:
+            status, txt = send_text_message(device_key, chat_id, reply)
+            print(">>> sent text:", status, txt)
+
+            try:
+                log_message(customer_phone, bot_number, "out", reply)
+            except Exception as e:
+                print(">>> failed to log outgoing text:", str(e))
+
+        except Exception as e:
+            print(">>> failed to send text:", str(e))
+
+    # 3) لو فيه handoff action
+    if action and action.get("type") == "handoff":
+        department = action.get("department")
+        summary = action.get("summary", "")
+        metadata = result.get("flow_data", {})
+
+        try:
+            if department == "sales":
+                create_sales_handoff(
+                    customer_phone=customer_phone,
+                    bot_number=bot_number,
+                    summary=summary,
+                    metadata=metadata
+                )
+
+            elif department == "support":
+                create_support_handoff(
+                    customer_phone=customer_phone,
+                    bot_number=bot_number,
+                    summary=summary,
+                    metadata=metadata
+                )
+
+        except Exception as e:
+            print(">>> failed to create handoff:", str(e))
+
+    return {
+        "ok": True,
+        "device_key": device_key,
+        "customer_phone": customer_phone,
+        "state": result.get("next_state"),
+        "has_action": bool(action),
+    }
+
+
+@app.post("/complaints/callback")
+async def complaints_callback(req: Request):
+    """
+    متوقع أن خدمة الشكاوى تبعت:
+    {
+      "uid": "device_01__2010xxxxxxx",
+      "complaint_number": "CMP-1001",
+      "status": "submitted"
+    }
+    """
+    try:
+        payload = await req.json()
+    except Exception:
+        return JSONResponse(status_code=400, content={"ok": False, "error": "invalid json"})
+
+    print("===== COMPLAINT CALLBACK =====")
+    print(json.dumps(payload, ensure_ascii=False, indent=2))
+    print("==============================")
+
+    uid = payload.get("uid", "")
+    complaint_number = payload.get("complaint_number", "")
+    status = payload.get("status", "")
+
+    # دي حالياً مجرد نقطة استقبال
+    # لاحقاً هنستخدم uid عشان:
+    # - نحدد customer_phone + bot_number
+    # - نبعث للعميل رسالة تأكيد فيها رقم الشكوى
+    # - نسجل الشكوى في جدول complaints أو handoff_requests
+
+    return {
+        "ok": True,
+        "uid": uid,
+        "complaint_number": complaint_number,
+        "status": status
+    }

messages.py

@@ -0,0 +1,11 @@
+from db import supabase
+
+
+def log_message(customer_phone: str, bot_number: str, direction: str, message: str):
+    payload = {
+        "customer_phone": customer_phone,
+        "bot_number": bot_number,
+        "direction": direction,
+        "message": message,
+    }
+    return supabase.table("chat_messages").insert(payload).execute()

sessions.py

@@ -0,0 +1,58 @@
+from datetime import datetime, timezone
+from db import supabase
+
+
+def utc_now():
+    return datetime.now(timezone.utc).isoformat()
+
+
+def get_session(customer_phone: str, bot_number: str):
+    res = (
+        supabase.table("chat_sessions")
+        .select("*")
+        .eq("customer_phone", customer_phone)
+        .eq("bot_number", bot_number)
+        .limit(1)
+        .execute()
+    )
+
+    rows = res.data or []
+    if not rows:
+        return None
+    return rows[0]
+
+
+def upsert_session(customer_phone: str, bot_number: str, current_state: str, flow_type=None, flow_data=None, last_message=None):
+    payload = {
+        "customer_phone": customer_phone,
+        "bot_number": bot_number,
+        "current_state": current_state,
+        "flow_type": flow_type,
+        "flow_data": flow_data or {},
+        "last_message": last_message,
+        "updated_at": utc_now(),
+    }
+
+    return (
+        supabase.table("chat_sessions")
+        .upsert(payload, on_conflict="customer_phone,bot_number")
+        .execute()
+    )
+
+
+def clear_session(customer_phone: str, bot_number: str):
+    payload = {
+        "customer_phone": customer_phone,
+        "bot_number": bot_number,
+        "current_state": "START",
+        "flow_type": None,
+        "flow_data": {},
+        "last_message": None,
+        "updated_at": utc_now(),
+    }
+
+    return (
+        supabase.table("chat_sessions")
+        .upsert(payload, on_conflict="customer_phone,bot_number")
+        .execute()
+    )