company-ai-platform/app/application/feishu/events.py

from typing import Any

from sqlalchemy.exc import IntegrityError
from sqlalchemy.orm import Session

from app.application.feishu.commands import FeishuCommandService
from app.core.constants import ActorValue
from app.modules.audit.constants import AuditAction, AuditSource
from app.modules.audit.schemas import AuditLogCreate
from app.modules.feishu.constants import (
    FeishuCommandKey,
    FeishuEventReceiptKey,
    FeishuEventSource,
    FeishuPayloadKey,
    FeishuResponseKey,
)
from app.modules.feishu.models import FeishuEventReceipt
from app.modules.feishu.service import FeishuService

FEISHU_EVENT_ACTIONS = {
    FeishuEventSource.WEBHOOK: AuditAction.FEISHU_WEBHOOK_EVENT,
    FeishuEventSource.LONG_CONNECTION: AuditAction.FEISHU_LONG_CONNECTION_EVENT,
}


class FeishuEventService:
    """Handle Feishu message events from webhook or long connection."""

    def __init__(self, db: Session):
        self.db = db
        self.feishu = FeishuService(db)
        self.commands = FeishuCommandService(db)

    def handle_event(
        self,
        payload: dict[str, Any],
        source: str | FeishuEventSource,
        auto_reply: bool = True,
    ) -> dict[str, Any]:
        self.feishu.verify_event(payload)
        challenge = payload.get(FeishuPayloadKey.CHALLENGE)
        if challenge:
            return {FeishuResponseKey.CHALLENGE: challenge}
        source_value = _normalize_source(source)
        event_identity = _event_identity(payload, source)
        if event_identity and not self._register_event(event_identity):
            return {
                FeishuResponseKey.OK: True,
                FeishuResponseKey.HANDLED: False,
                FeishuResponseKey.DUPLICATE: True,
            }
        self.feishu.audit.log(
            AuditLogCreate(
                actor=ActorValue.FEISHU,
                source=AuditSource.FEISHU,
                action=FEISHU_EVENT_ACTIONS[source_value],
                target_type=source_value,
                target_id=(
                    event_identity.get(FeishuEventReceiptKey.EVENT_KEY)
                    if event_identity
                    else None
                ),
                request_payload=_audit_event_metadata(payload),
                response_payload={FeishuResponseKey.ACCEPTED: True},
            )
        )
        command = self.commands.extract_event_command(payload)
        if not command:
            return {FeishuResponseKey.OK: True, FeishuResponseKey.HANDLED: False}
        result = self.commands.handle_text(
            command[FeishuCommandKey.TEXT],
            chat_id=command[FeishuCommandKey.CHAT_ID],
            actor=command[FeishuCommandKey.ACTOR],
            auto_reply=auto_reply,
        )
        return {
            FeishuResponseKey.OK: True,
            FeishuResponseKey.HANDLED: True,
            FeishuResponseKey.RESULT: result,
        }

    def _register_event(self, event_identity: dict[str, str | None]) -> bool:
        receipt = FeishuEventReceipt(
            event_key=str(event_identity[FeishuEventReceiptKey.EVENT_KEY]),
            source=str(event_identity[FeishuEventReceiptKey.SOURCE]),
            event_id=event_identity.get(FeishuEventReceiptKey.EVENT_ID),
            message_id=event_identity.get(FeishuEventReceiptKey.MESSAGE_ID),
        )
        self.db.add(receipt)
        try:
            self.db.flush()
        except IntegrityError:
            self.db.rollback()
            return False
        return True


def _audit_event_metadata(payload: dict[str, Any]) -> dict[str, Any]:
    """Keep webhook audit evidence without storing message content or tokens."""

    header = payload.get(FeishuPayloadKey.HEADER) or {}
    event = payload.get(FeishuPayloadKey.EVENT) or {}
    message = event.get(FeishuPayloadKey.MESSAGE) or {}
    sender = event.get(FeishuPayloadKey.SENDER) or {}
    sender_id = sender.get(FeishuPayloadKey.SENDER_ID) or {}
    return {
        "schema": payload.get("schema"),
        FeishuPayloadKey.EVENT_ID: header.get(FeishuPayloadKey.EVENT_ID),
        FeishuPayloadKey.EVENT_TYPE: header.get(FeishuPayloadKey.EVENT_TYPE),
        FeishuPayloadKey.MESSAGE_ID: message.get(FeishuPayloadKey.MESSAGE_ID),
        FeishuCommandKey.CHAT_ID: message.get(FeishuCommandKey.CHAT_ID),
        FeishuPayloadKey.MESSAGE_TYPE: message.get(FeishuPayloadKey.MESSAGE_TYPE),
        FeishuPayloadKey.OPEN_ID: sender_id.get(FeishuPayloadKey.OPEN_ID),
    }


def _normalize_source(source: str | FeishuEventSource) -> FeishuEventSource:
    return FeishuEventSource(source)


def _event_identity(
    payload: dict[str, Any],
    source: str | FeishuEventSource,
) -> dict[str, str | None] | None:
    source_value = _normalize_source(source)
    header = payload.get(FeishuPayloadKey.HEADER) or {}
    event = payload.get(FeishuPayloadKey.EVENT) or {}
    message = event.get(FeishuPayloadKey.MESSAGE) or {}
    event_id = header.get(FeishuPayloadKey.EVENT_ID)
    message_id = message.get(FeishuPayloadKey.MESSAGE_ID)
    stable_id = event_id or message_id
    if not stable_id:
        return None
    event_type = header.get(FeishuPayloadKey.EVENT_TYPE)
    event_key = ":".join(
        str(part)
        for part in (source_value, event_type or FeishuPayloadKey.EVENT, stable_id)
    )
    return {
        FeishuEventReceiptKey.EVENT_KEY: event_key,
        FeishuEventReceiptKey.SOURCE: source_value,
        FeishuEventReceiptKey.EVENT_ID: str(event_id) if event_id else None,
        FeishuEventReceiptKey.MESSAGE_ID: str(message_id) if message_id else None,
    }