ForcePilot/backend/package/yuxi/channel/extensions/wechat-mp/broadcast.py

import logging

import httpx

logger = logging.getLogger(__name__)

MASS_SEND_ALL_URL = "https://api.weixin.qq.com/cgi-bin/message/mass/sendall"
MASS_SEND_URL = "https://api.weixin.qq.com/cgi-bin/message/mass/send"
MASS_DELETE_URL = "https://api.weixin.qq.com/cgi-bin/message/mass/delete"
MASS_PREVIEW_URL = "https://api.weixin.qq.com/cgi-bin/message/mass/preview"
MASS_GET_URL = "https://api.weixin.qq.com/cgi-bin/message/mass/get"


class WeChatBroadcast:

    def __init__(self, gateway):
        self._gateway = gateway

    async def send_all(
        self,
        msg_type: str,
        content: dict,
        tag_id: int | None = None,
        send_ignore_reprint: int = 0,
    ) -> dict:
        token = self._gateway.access_token if self._gateway else None
        if not token:
            return {"success": False, "error": "no access_token"}

        payload = {
            "filter": {"is_to_all": tag_id is None, "tag_id": tag_id or 0},
            msg_type: content,
            "send_ignore_reprint": send_ignore_reprint,
        }
        try:
            async with httpx.AsyncClient(timeout=15.0) as client:
                resp = await client.post(f"{MASS_SEND_ALL_URL}?access_token={token}", json=payload)
                data = resp.json()
                if data.get("errcode") == 0:
                    return {"success": True, "msg_id": data.get("msg_id"), "msg_data_id": data.get("msg_data_id")}
                return {"success": False, "error": data.get("errmsg", "send failed"), "errcode": data.get("errcode")}
        except Exception as e:
            logger.exception("Broadcast send all exception")
            return {"success": False, "error": str(e)}

    async def send(
        self,
        msg_type: str,
        content: dict,
        openids: list[str],
    ) -> dict:
        token = self._gateway.access_token if self._gateway else None
        if not token:
            return {"success": False, "error": "no access_token"}

        payload = {
            "touser": openids[:10000],
            msg_type: content,
        }
        try:
            async with httpx.AsyncClient(timeout=15.0) as client:
                resp = await client.post(f"{MASS_SEND_URL}?access_token={token}", json=payload)
                data = resp.json()
                if data.get("errcode") == 0:
                    return {"success": True, "msg_id": data.get("msg_id"), "msg_data_id": data.get("msg_data_id")}
                return {"success": False, "error": data.get("errmsg", "send failed"), "errcode": data.get("errcode")}
        except Exception as e:
            logger.exception("Broadcast send exception")
            return {"success": False, "error": str(e)}

    async def delete(self, msg_id: int, article_idx: int = 0) -> bool:
        token = self._gateway.access_token if self._gateway else None
        if not token:
            return False

        payload = {"msg_id": msg_id, "article_idx": article_idx}
        try:
            async with httpx.AsyncClient(timeout=10.0) as client:
                resp = await client.post(f"{MASS_DELETE_URL}?access_token={token}", json=payload)
                data = resp.json()
                return data.get("errcode") == 0
        except Exception:
            logger.exception("Broadcast delete exception")
        return False

    async def preview(
        self,
        to_user: str,
        msg_type: str,
        content: dict,
    ) -> bool:
        token = self._gateway.access_token if self._gateway else None
        if not token:
            return False

        payload = {
            "touser": to_user,
            msg_type: content,
        }
        try:
            async with httpx.AsyncClient(timeout=10.0) as client:
                resp = await client.post(f"{MASS_PREVIEW_URL}?access_token={token}", json=payload)
                data = resp.json()
                return data.get("errcode") == 0
        except Exception:
            logger.exception("Broadcast preview exception")
        return False

    async def get_status(self, msg_id: int) -> dict:
        token = self._gateway.access_token if self._gateway else None
        if not token:
            return {"success": False, "error": "no access_token"}

        try:
            async with httpx.AsyncClient(timeout=10.0) as client:
                resp = await client.post(f"{MASS_GET_URL}?access_token={token}", json={"msg_id": msg_id})
                data = resp.json()
                if data.get("errcode") == 0:
                    return {
                        "success": True,
                        "msg_id": data.get("msg_id"),
                        "msg_status": data.get("msg_status"),
                        "total_count": data.get("total_count", 0),
                        "filter_count": data.get("filter_count", 0),
                        "sent_count": data.get("sent_count", 0),
                        "error_count": data.get("error_count", 0),
                    }
                return {"success": False, "error": data.get("errmsg", "get failed"), "errcode": data.get("errcode")}
        except Exception as e:
            logger.exception("Broadcast get status exception")
            return {"success": False, "error": str(e)}