PWF/CoreRouters/callback.py

"""Callback路由处理"""
from ..Convention.Runtime.GlobalConfig import *
from ..Convention.Runtime.Architecture import Architecture

from fastapi import APIRouter, Request
from fastapi.responses import JSONResponse
import re

from ..CoreModules.models import CallbackRequest
from ..CoreModules.plugin_interface import PluginInterface


logger: ProjectConfig = Architecture.Get(ProjectConfig)
ALWAYS_RETURN_OK = logger.FindItem("always_return_ok", True) # 返回ok，可以避免重试
logger.SaveProperties()

router = APIRouter()

@router.get("/callback")
async def callback_verify():
    """Callback可用性校验"""
    logger.Log("Info", "收到Callback验证请求")
    return JSONResponse({"result": "ok"})

# 机器人名称模式（用于从@消息中提取，兼容半角/全角空格）
AT_PATTERN = re.compile(r'@[^\s]+[\s\u3000]+(.+)', re.DOTALL)

def parse_message_after_at(message: str) -> str:
    # 去除首尾空格
    message = message.strip()
    
    # 尝试提取@后的内容
    at_match = AT_PATTERN.search(message)
    if at_match:
        return at_match.group(1).strip()
    return message

@router.post("/callback/construct")
async def callback_receive_construct(callback_data: CallbackRequest):
    """以构造好的Callback消息进行处理, 已知方式"""
    try:
        # 解析指令
        content = parse_message_after_at(callback_data.content)
        command = content.split(" ")[0]
        message = content[len(command):].strip()
        logger.Log("Info", f"识别指令: command={command}")
        
        # 处理指令
        result = await handle_command(command, message, callback_data.chatid, callback_data.creator)
        if result:
            return JSONResponse({"result": "ok", "message": result})
        else:
            return JSONResponse({"result": "ok"})
        
    except Exception as e:
        logger.Log("Error", f"处理Callback异常: {e}")
        if ALWAYS_RETURN_OK:
            return JSONResponse({"result": "ok"})
        else:
            return JSONResponse({"result": "error", "message": str(e)})

@router.post("/callback")
async def callback_receive(request: Request):
    """接受未知的Callback消息并进行处理, 默认方式"""
    try:
        # 解析请求数据
        data = await request.json()
        logger.Log("Info", f"完整callback数据: {data}")
        
        # 验证请求
        try:
            callback_data = CallbackRequest(**data)
        except Exception as e:
            logger.Log("Error", f"请求数据验证失败: {e}")
            if ALWAYS_RETURN_OK:
                return JSONResponse({"result": "ok"})
            else:
                return JSONResponse({"result": "error", "message": str(e)})
        
        # 解析指令
        content = parse_message_after_at(callback_data.content)
        command = content.split(" ")[0]
        message = content[len(command):].strip()
        logger.Log("Info", f"识别指令: command={command}")
        
        # 处理指令
        result = await handle_command(command, message, callback_data.chatid, callback_data.creator)
        if result:
            return JSONResponse({"result": "ok", "message": result})
        else:
            return JSONResponse({"result": "ok"})
        
    except Exception as e:
        logger.Log("Error", f"处理Callback异常: {e}")
        if ALWAYS_RETURN_OK:
            return JSONResponse({"result": "ok"})
        else:
            return JSONResponse({"result": "error", "message": str(e)})


async def handle_command(command: str, message: str,
                        chat_id: int, user_id: int) -> str|None:
    """处理指令
    
    Args:
        command: 指令
        message: 消息内容
        chat_id: 会话ID
        user_id: 用户ID
        
    Returns:
        回复文本或None
    """
    try:
        plugin = PluginInterface.plugin_instances.get(command, None)
        if plugin:
            logger.Log("Info", f"已找到插件注册指令: {command}, class: {plugin.__class__.__name__}")
            return await plugin.callback(message, chat_id, user_id)
        else:
            return f"❌ 未识别指令: {command}"
    except Exception as e:
        logger.Log("Error", f"{ConsoleFrontColor.RED}处理指令异常: {e}{ConsoleFrontColor.RESET}")
        return f"❌ 处理指令时出错: {str(e)}"