mirror of
https://github.com/MODSetter/SurfSense.git
synced 2026-06-02 19:55:18 +02:00
118 lines
4.1 KiB
Python
118 lines
4.1 KiB
Python
"""Baileys bridge platform adapter."""
|
|
|
|
from __future__ import annotations
|
|
|
|
from collections.abc import AsyncIterator
|
|
from typing import Any
|
|
|
|
import httpx
|
|
|
|
from app.config import config
|
|
from app.gateway.base.adapter import (
|
|
BasePlatformAdapter,
|
|
ParsedInboundEvent,
|
|
PlatformSendResult,
|
|
)
|
|
|
|
|
|
class WhatsAppBaileysAdapter(BasePlatformAdapter):
|
|
platform = "whatsapp"
|
|
|
|
def __init__(self, bridge_url: str | None = None) -> None:
|
|
self.bridge_url = (bridge_url or config.WHATSAPP_BRIDGE_URL).rstrip("/")
|
|
|
|
def parse_inbound(self, raw_payload: dict[str, Any]) -> ParsedInboundEvent:
|
|
chat_id = str(raw_payload.get("chatId") or "")
|
|
sender_id = str(raw_payload.get("senderId") or chat_id)
|
|
message_id = str(raw_payload.get("messageId") or "")
|
|
body = raw_payload.get("body")
|
|
is_group = bool(raw_payload.get("isGroup"))
|
|
return ParsedInboundEvent(
|
|
platform=self.platform,
|
|
event_kind="message",
|
|
external_peer_id=chat_id or None,
|
|
external_peer_kind="group" if is_group else "direct",
|
|
external_message_id=message_id or None,
|
|
external_user_id=sender_id or None,
|
|
text=str(body) if body is not None else None,
|
|
raw_payload=raw_payload,
|
|
display_name=str(raw_payload.get("chatName") or sender_id or chat_id) or None,
|
|
username=None,
|
|
metadata={
|
|
"sender_id": sender_id,
|
|
"from_me": bool(raw_payload.get("fromMe")),
|
|
"timestamp": raw_payload.get("timestamp"),
|
|
},
|
|
)
|
|
|
|
async def send_message(
|
|
self,
|
|
*,
|
|
external_peer_id: str,
|
|
text: str,
|
|
parse_mode: str | None = None,
|
|
reply_to_message_id: str | None = None,
|
|
) -> PlatformSendResult:
|
|
payload: dict[str, Any] = {"chatId": external_peer_id, "message": text}
|
|
if reply_to_message_id:
|
|
payload["replyTo"] = reply_to_message_id
|
|
data = await self._post("/send", payload)
|
|
return PlatformSendResult(
|
|
external_message_id=str(data.get("messageId") or ""),
|
|
raw_response=data,
|
|
)
|
|
|
|
async def edit_message(
|
|
self,
|
|
*,
|
|
external_peer_id: str,
|
|
external_message_id: str,
|
|
text: str,
|
|
parse_mode: str | None = None,
|
|
) -> PlatformSendResult:
|
|
data = await self._post(
|
|
"/edit",
|
|
{
|
|
"chatId": external_peer_id,
|
|
"messageId": external_message_id,
|
|
"message": text,
|
|
},
|
|
)
|
|
return PlatformSendResult(
|
|
external_message_id=str(data.get("messageId") or external_message_id),
|
|
raw_response=data,
|
|
)
|
|
|
|
async def send_typing_indicator(self, *, external_peer_id: str) -> None:
|
|
await self._post("/typing", {"chatId": external_peer_id}, expect_json=False)
|
|
|
|
async def validate_credentials(self) -> dict[str, Any]:
|
|
async with httpx.AsyncClient(timeout=10) as client:
|
|
response = await client.get(f"{self.bridge_url}/health")
|
|
response.raise_for_status()
|
|
return response.json()
|
|
|
|
async def fetch_updates(self, *, offset: int | None) -> AsyncIterator[dict[str, Any]]:
|
|
async with httpx.AsyncClient(timeout=35) as client:
|
|
response = await client.get(f"{self.bridge_url}/messages")
|
|
response.raise_for_status()
|
|
for message in response.json():
|
|
if isinstance(message, dict):
|
|
yield message
|
|
|
|
async def request_pairing_code(self, *, phone_number: str) -> dict[str, Any]:
|
|
return await self._post("/pair", {"phoneNumber": phone_number})
|
|
|
|
async def _post(
|
|
self,
|
|
path: str,
|
|
payload: dict[str, Any],
|
|
*,
|
|
expect_json: bool = True,
|
|
) -> dict[str, Any]:
|
|
async with httpx.AsyncClient(timeout=30) as client:
|
|
response = await client.post(f"{self.bridge_url}{path}", json=payload)
|
|
response.raise_for_status()
|
|
if not expect_json or response.status_code == 204:
|
|
return {}
|
|
return response.json()
|