JiuContinent
d7db84571d
feat: 添加飞书用户模块和订阅功能支持 - 新增feishu_users模块用于处理飞书用户身份验证和权限管理 - 新增subscriptions模块用于处理订阅相关功能 - 新增personalization模块用于个性化服务 - 在alembic迁移配置中注册新的模型模块 - 在API路由器中添加feishu_users和subscriptions路由 - 实现事件调度服务的改进，包括错误处理和状态更新优化 - 添加飞书命令处理的权限检查机制 - 实现飞书应用票据事件处理 - 改进审计日志记录功能 ```
463 lines
16 KiB
Python
463 lines
16 KiB
Python
import json
|
|
import re
|
|
from typing import Any
|
|
|
|
from sqlalchemy.orm import Session
|
|
|
|
from app.application.feishu.delivery import send_card_if_configured, send_text_if_configured
|
|
from app.application.feishu.handlers import (
|
|
handle_admin_command,
|
|
handle_finance_command,
|
|
handle_market_command,
|
|
handle_personal_data_command,
|
|
handle_personalization_command,
|
|
handle_rule_command,
|
|
handle_subscription_command,
|
|
is_admin_command,
|
|
is_company_rule_command,
|
|
)
|
|
from app.application.feishu.results import command_result
|
|
from app.core.config import get_settings
|
|
from app.core.constants import ActorValue
|
|
from app.modules.ai_agent.constants import AIResponseKey
|
|
from app.modules.ai_agent.service import AIService
|
|
from app.modules.audit.constants import AuditRiskLevel, AuditSource
|
|
from app.modules.audit.schemas import AuditLogCreate
|
|
from app.modules.feishu.constants import (
|
|
FEISHU_AI_REPLY_TITLE,
|
|
FEISHU_MENTION_PATTERN,
|
|
FEISHU_ZERO_WIDTH_SPACE,
|
|
FeishuCommandKey,
|
|
FeishuCommandName,
|
|
FeishuPayloadKey,
|
|
FeishuReplyType,
|
|
)
|
|
from app.modules.feishu.service import FeishuService
|
|
from app.modules.feishu_users.constants import (
|
|
FEISHU_USER_TARGET_TYPE,
|
|
FeishuCapability,
|
|
FeishuUserAuditAction,
|
|
)
|
|
from app.modules.feishu_users.principal import FeishuMention, FeishuPrincipal
|
|
from app.modules.reports.constants import ReportResponseKey
|
|
from app.modules.reports.services import ReportService
|
|
|
|
DAILY_REPORT_KEYWORDS = ("日报", "晨报", "经营日报", "经营晨报")
|
|
PROJECT_WEEKLY_KEYWORDS = ("周报", "项目周报")
|
|
ATTENDANCE_KEYWORDS = ("打卡", "考勤", "attendance")
|
|
RISK_KEYWORDS = ("风险", "预警", "risk")
|
|
AI_COMMAND_PREFIXES = ("问 ", "ai ", "AI ", "/ask ")
|
|
DEFAULT_AI_PROMPT = "请说明你能做什么。"
|
|
PERMISSION_DENIED_TITLE = "权限不足"
|
|
COMPANY_RULE_COMMAND_PREFIXES = (
|
|
"学习公司规则",
|
|
"查看公司规则",
|
|
"修改公司规则",
|
|
"启用公司规则",
|
|
"停用公司规则",
|
|
"删除公司规则",
|
|
"学习公司市场规则",
|
|
"查看公司市场规则",
|
|
)
|
|
FINANCE_COMMAND_PREFIXES = ("资金需求", "未来30天资金需求", "项目资金 ")
|
|
|
|
|
|
def _parse_content_text(content: Any) -> str:
|
|
"""Extract plain command text from a Feishu message content payload."""
|
|
|
|
if isinstance(content, dict):
|
|
return str(
|
|
content.get(FeishuPayloadKey.TEXT) or content.get(FeishuPayloadKey.CONTENT) or ""
|
|
)
|
|
if not isinstance(content, str):
|
|
return ""
|
|
try:
|
|
data = json.loads(content)
|
|
except json.JSONDecodeError:
|
|
return content
|
|
if isinstance(data, dict):
|
|
return str(data.get(FeishuPayloadKey.TEXT) or data.get(FeishuPayloadKey.CONTENT) or "")
|
|
return content
|
|
|
|
|
|
def _clean_command_text(text: str) -> str:
|
|
"""Remove mentions and invisible characters from Feishu command text."""
|
|
|
|
text = re.sub(FEISHU_MENTION_PATTERN, "", text or "")
|
|
text = text.replace(FEISHU_ZERO_WIDTH_SPACE, "")
|
|
return text.strip()
|
|
|
|
|
|
class FeishuCommandService:
|
|
"""Route Feishu text commands to focused application handlers."""
|
|
|
|
def __init__(self, db: Session):
|
|
self.db = db
|
|
self.feishu = FeishuService(db)
|
|
|
|
def extract_event_command(self, payload: dict[str, Any]) -> dict[str, Any] | None:
|
|
header = payload.get(FeishuPayloadKey.HEADER) or {}
|
|
event = payload.get(FeishuPayloadKey.EVENT) or {}
|
|
message = event.get(FeishuPayloadKey.MESSAGE) or {}
|
|
if not message:
|
|
return None
|
|
raw_text = _parse_content_text(message.get(FeishuPayloadKey.CONTENT))
|
|
command_text = _clean_command_text(raw_text)
|
|
if not command_text:
|
|
return None
|
|
sender = event.get(FeishuPayloadKey.SENDER) or {}
|
|
sender_id = sender.get(FeishuPayloadKey.SENDER_ID) or {}
|
|
actor = (
|
|
sender_id.get(FeishuPayloadKey.OPEN_ID)
|
|
or sender_id.get(FeishuPayloadKey.USER_ID)
|
|
or ActorValue.FEISHU
|
|
)
|
|
return {
|
|
FeishuCommandKey.TEXT: (
|
|
raw_text
|
|
if get_settings().feishu_user_features_enabled
|
|
else command_text
|
|
),
|
|
FeishuCommandKey.CHAT_ID: message.get(FeishuCommandKey.CHAT_ID),
|
|
FeishuCommandKey.CHAT_TYPE: message.get(FeishuPayloadKey.CHAT_TYPE),
|
|
FeishuCommandKey.ACTOR: actor,
|
|
FeishuCommandKey.MENTIONS: _parse_mentions(
|
|
message.get(FeishuPayloadKey.MENTIONS),
|
|
str(header.get(FeishuPayloadKey.TENANT_KEY) or ""),
|
|
),
|
|
}
|
|
|
|
def handle_text(
|
|
self,
|
|
text: str,
|
|
chat_id: str | None = None,
|
|
actor: str = ActorValue.FEISHU,
|
|
auto_reply: bool = True,
|
|
principal: FeishuPrincipal | None = None,
|
|
tenant_key: str | None = None,
|
|
) -> dict[str, Any]:
|
|
if tenant_key is not None:
|
|
self.feishu.set_tenant_key(tenant_key)
|
|
raw_text = text or ""
|
|
command_text = _clean_command_text(text)
|
|
lowered = command_text.lower()
|
|
if get_settings().feishu_user_features_enabled:
|
|
if principal is None:
|
|
return self._permission_denied(
|
|
chat_id=chat_id,
|
|
actor=actor,
|
|
auto_reply=False,
|
|
principal=None,
|
|
reason="missing_verified_identity",
|
|
content="无法确认飞书账号身份，已拒绝执行该命令。",
|
|
)
|
|
self.feishu.set_tenant_key(principal.tenant_key)
|
|
chat_id = principal.chat_id or chat_id
|
|
actor = principal.user_code
|
|
if not principal.is_active:
|
|
return self._permission_denied(
|
|
chat_id=chat_id,
|
|
actor=actor,
|
|
auto_reply=auto_reply,
|
|
principal=principal,
|
|
reason="disabled_user",
|
|
content="当前飞书账号已停用，请联系管理员。",
|
|
)
|
|
required_capability = _required_capability(command_text)
|
|
if (
|
|
required_capability is not None
|
|
and not principal.has_capability(required_capability)
|
|
):
|
|
return self._permission_denied(
|
|
chat_id=chat_id,
|
|
actor=actor,
|
|
auto_reply=auto_reply,
|
|
principal=principal,
|
|
reason=f"missing_capability:{required_capability}",
|
|
content="当前飞书账号无权使用该公司级功能。",
|
|
)
|
|
admin_result = handle_admin_command(
|
|
self.db,
|
|
self.feishu,
|
|
raw_text=raw_text,
|
|
command_text=command_text,
|
|
principal=principal,
|
|
auto_reply=auto_reply,
|
|
)
|
|
if admin_result is not None:
|
|
return admin_result
|
|
for handler in (
|
|
handle_subscription_command,
|
|
handle_personal_data_command,
|
|
handle_personalization_command,
|
|
):
|
|
result = handler(
|
|
self.db,
|
|
self.feishu,
|
|
command_text,
|
|
principal,
|
|
auto_reply,
|
|
)
|
|
if result is not None:
|
|
return result
|
|
|
|
rule_result = handle_rule_command(
|
|
self.db,
|
|
self.feishu,
|
|
command_text,
|
|
chat_id,
|
|
actor,
|
|
auto_reply,
|
|
principal=principal,
|
|
)
|
|
if rule_result is not None:
|
|
return rule_result
|
|
market_result = handle_market_command(
|
|
self.db,
|
|
self.feishu,
|
|
command_text,
|
|
chat_id,
|
|
actor,
|
|
auto_reply,
|
|
principal=principal,
|
|
)
|
|
if market_result is not None:
|
|
return market_result
|
|
|
|
for handler in (
|
|
handle_finance_command,
|
|
):
|
|
result = handler(
|
|
self.db,
|
|
self.feishu,
|
|
command_text,
|
|
chat_id,
|
|
actor,
|
|
auto_reply,
|
|
)
|
|
if result is not None:
|
|
return result
|
|
if not get_settings().feishu_user_features_enabled:
|
|
for handler in (handle_rule_command, handle_market_command):
|
|
result = handler(
|
|
self.db,
|
|
self.feishu,
|
|
command_text,
|
|
chat_id,
|
|
actor,
|
|
auto_reply,
|
|
)
|
|
if result is not None:
|
|
return result
|
|
|
|
report_result = self._handle_report_command(command_text, chat_id, actor, auto_reply)
|
|
if report_result is not None:
|
|
return report_result
|
|
return self._handle_ai_command(
|
|
command_text,
|
|
lowered,
|
|
chat_id,
|
|
actor,
|
|
auto_reply,
|
|
principal=principal,
|
|
)
|
|
|
|
def _permission_denied(
|
|
self,
|
|
*,
|
|
chat_id: str | None,
|
|
actor: str,
|
|
auto_reply: bool,
|
|
principal: FeishuPrincipal | None,
|
|
reason: str,
|
|
content: str,
|
|
) -> dict[str, Any]:
|
|
self.feishu.audit.log(
|
|
AuditLogCreate(
|
|
actor=actor,
|
|
source=AuditSource.FEISHU,
|
|
action=FeishuUserAuditAction.PERMISSION_DENIED,
|
|
target_type=FEISHU_USER_TARGET_TYPE,
|
|
target_id=principal.user_code if principal else None,
|
|
risk_level=AuditRiskLevel.MEDIUM,
|
|
response_payload={"result": "denied", "reason": reason},
|
|
status="denied",
|
|
)
|
|
)
|
|
response = (
|
|
send_text_if_configured(self.feishu, chat_id, content, actor)
|
|
if auto_reply
|
|
else None
|
|
)
|
|
return command_result(
|
|
FeishuCommandName.PERMISSION_DENIED,
|
|
FeishuReplyType.TEXT,
|
|
PERMISSION_DENIED_TITLE,
|
|
content,
|
|
response,
|
|
)
|
|
|
|
def _handle_report_command(
|
|
self,
|
|
command_text: str,
|
|
chat_id: str | None,
|
|
actor: str,
|
|
auto_reply: bool,
|
|
) -> dict[str, Any] | None:
|
|
service = ReportService(self.db)
|
|
if any(keyword in command_text for keyword in DAILY_REPORT_KEYWORDS):
|
|
command = FeishuCommandName.DAILY_BRIEF
|
|
report = service.daily_brief()
|
|
elif any(keyword in command_text for keyword in PROJECT_WEEKLY_KEYWORDS):
|
|
command = FeishuCommandName.PROJECT_WEEKLY
|
|
report = service.project_weekly()
|
|
elif any(keyword in command_text for keyword in ATTENDANCE_KEYWORDS):
|
|
command = FeishuCommandName.ATTENDANCE_SUMMARY
|
|
report = service.attendance_summary()
|
|
elif any(keyword in command_text for keyword in RISK_KEYWORDS):
|
|
command = FeishuCommandName.RISK_SUMMARY
|
|
report = service.risk_progress()
|
|
else:
|
|
return None
|
|
response = (
|
|
send_card_if_configured(
|
|
self.feishu,
|
|
chat_id,
|
|
report[ReportResponseKey.TITLE],
|
|
report[ReportResponseKey.LINES],
|
|
actor,
|
|
)
|
|
if auto_reply
|
|
else None
|
|
)
|
|
return command_result(
|
|
command,
|
|
FeishuReplyType.CARD,
|
|
report[ReportResponseKey.TITLE],
|
|
report[ReportResponseKey.CONTENT],
|
|
response,
|
|
report[ReportResponseKey.LINES],
|
|
)
|
|
|
|
def _handle_ai_command(
|
|
self,
|
|
command_text: str,
|
|
lowered: str,
|
|
chat_id: str | None,
|
|
actor: str,
|
|
auto_reply: bool,
|
|
principal: FeishuPrincipal | None = None,
|
|
) -> dict[str, Any]:
|
|
prompt = command_text
|
|
for prefix in AI_COMMAND_PREFIXES:
|
|
if command_text.startswith(prefix):
|
|
prompt = command_text[len(prefix) :].strip()
|
|
break
|
|
if not prompt:
|
|
prompt = DEFAULT_AI_PROMPT
|
|
if get_settings().feishu_user_features_enabled and principal is not None:
|
|
chat_type, chat_key = _principal_chat_context(principal)
|
|
ai_result = AIService(self.db).ask_personalized(
|
|
principal.owner_id,
|
|
chat_type,
|
|
chat_key,
|
|
prompt,
|
|
actor=actor,
|
|
source=AuditSource.FEISHU,
|
|
)
|
|
else:
|
|
ai_result = AIService(self.db).ask(
|
|
prompt,
|
|
context={},
|
|
actor=actor,
|
|
source=AuditSource.FEISHU,
|
|
)
|
|
content = ai_result[AIResponseKey.ANSWER]
|
|
is_explicit_ai = any(
|
|
command_text.startswith(prefix) or lowered.startswith(prefix)
|
|
for prefix in AI_COMMAND_PREFIXES
|
|
)
|
|
response = (
|
|
send_text_if_configured(self.feishu, chat_id, content, actor) if auto_reply else None
|
|
)
|
|
return command_result(
|
|
FeishuCommandName.AI_ASK if is_explicit_ai else FeishuCommandName.FALLBACK_AI,
|
|
FeishuReplyType.TEXT,
|
|
FEISHU_AI_REPLY_TITLE,
|
|
content,
|
|
response,
|
|
)
|
|
|
|
|
|
def _parse_mentions(value: Any, tenant_key: str) -> tuple[FeishuMention, ...]:
|
|
if not isinstance(value, list):
|
|
return ()
|
|
mentions: list[FeishuMention] = []
|
|
for item in value:
|
|
if not isinstance(item, dict):
|
|
continue
|
|
mention_id = item.get(FeishuPayloadKey.ID) or {}
|
|
if not isinstance(mention_id, dict):
|
|
mention_id = {}
|
|
mentions.append(
|
|
FeishuMention(
|
|
key=_optional_text(item.get(FeishuPayloadKey.KEY)),
|
|
name=_optional_text(item.get(FeishuPayloadKey.NAME)),
|
|
tenant_key=(
|
|
_optional_text(item.get(FeishuPayloadKey.TENANT_KEY))
|
|
or tenant_key
|
|
or None
|
|
),
|
|
open_id=_optional_text(
|
|
mention_id.get(FeishuPayloadKey.OPEN_ID)
|
|
or item.get(FeishuPayloadKey.OPEN_ID)
|
|
),
|
|
union_id=_optional_text(
|
|
mention_id.get(FeishuPayloadKey.UNION_ID)
|
|
or item.get(FeishuPayloadKey.UNION_ID)
|
|
),
|
|
user_id=_optional_text(
|
|
mention_id.get(FeishuPayloadKey.USER_ID)
|
|
or item.get(FeishuPayloadKey.USER_ID)
|
|
),
|
|
)
|
|
)
|
|
return tuple(mentions)
|
|
|
|
|
|
def _optional_text(value: Any) -> str | None:
|
|
text = str(value or "").strip()
|
|
return text or None
|
|
|
|
|
|
def _required_capability(command_text: str) -> FeishuCapability | None:
|
|
if is_admin_command(command_text):
|
|
return FeishuCapability.USER_ADMINISTRATION
|
|
if (
|
|
command_text.startswith(COMPANY_RULE_COMMAND_PREFIXES)
|
|
or is_company_rule_command(command_text)
|
|
):
|
|
return FeishuCapability.COMPANY_RULES
|
|
if command_text.startswith(FINANCE_COMMAND_PREFIXES):
|
|
return FeishuCapability.COMPANY_REPORTS
|
|
if any(
|
|
keyword in command_text
|
|
for keyword in (
|
|
*DAILY_REPORT_KEYWORDS,
|
|
*PROJECT_WEEKLY_KEYWORDS,
|
|
*ATTENDANCE_KEYWORDS,
|
|
*RISK_KEYWORDS,
|
|
)
|
|
):
|
|
return FeishuCapability.COMPANY_REPORTS
|
|
return None
|
|
|
|
|
|
def _principal_chat_context(principal: FeishuPrincipal) -> tuple[str, str]:
|
|
chat_type = principal.chat_type or "p2p"
|
|
if chat_type in {"group", "group_chat"}:
|
|
if not principal.chat_id:
|
|
raise ValueError("Verified group chat is missing chat_id")
|
|
return chat_type, principal.chat_id
|
|
return chat_type, principal.chat_id or principal.open_id
|