JiuContinent/company-ai-platform
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

```

Browse Source 
refactor(Dockerfile): 使用requirements.txt替代硬编码依赖

将Dockerfile中的硬编码pip包列表替换为通过requirements.txt文件安装，
提高依赖管理的灵活性和可维护性。

feat(scheduling): 移除内置APScheduler，采用独立调度系统

移除app/core/background/scheduler.py中原来的APScheduler实现，
改为使用新的应用级调度系统app.application.scheduling。

refactor(task_queue): 调整任务队列模块结构和导入路径

将任务队列相关常量从app.core.background.task_queue.constants迁移至
app.tasks.constants，并更新所有相关导入路径和引用。

refactor(events): 将事件服务重构为独立的应用层组件

将事件分发逻辑从核心层迁移到应用层，使用app.application.events.EventDispatchService
替代原有的app.modules.events.services.EventService。

feat(ai_memory): 增强AI记忆自动写入的安全策略

新增ai_memory_blocked_content_terms配置项用于阻止敏感内容，
添加TTL过期机制控制自动写入条目的生命周期。

fix(security): 强化生产环境安全验证机制

增加model_validator确保生产环境中数据库连接、API密钥、CORS设置等
关键安全配置符合要求。

feat(risks): 优化风险事件操作动作的外键约束

为RiskEventAction模型的风险事件ID字段添加外键约束，
防止孤立记录并增强数据完整性。

refactor(audit): 优化审计服务方法命名和事务处理

将AuditService的log方法重命名为record以反映其阶段行为，
并调整事务提交时机以提高性能。

feat(events): 增强领域事件并发处理和响应模型

添加事件锁定机制防止重复处理，更新API响应模型以提供
更准确的数据类型定义。
```
This commit is contained in:
JiuContinent
2026-07-15 16:36:42 +08:00
parent 267b01b9f4
commit db751f03b4
73 changed files with 1615 additions and 933 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
app/modules/events/constants.py
View File

@@ -60,6 +60,7 @@ class EventPayloadKey(StrEnum):
class EventErrorDetail(StrEnum):
EVENT_NOT_FOUND = "Domain event not found"
EVENT_NOT_RETRYABLE = "Domain event is not retryable"
EVENT_LOCKED = "Domain event is already being processed"
EVENT_CODE_PREFIX = "EVT"

2
app/modules/events/models.py
View File

@@ -36,6 +36,6 @@ class DomainEvent(Base):
)
locked_until: Mapped[datetime | None] = mapped_column(DateTime, nullable=True, index=True)
locked_by: Mapped[str | None] = mapped_column(String(128), nullable=True, index=True)
max_attempts: Mapped[int] = mapped_column(Integer, default=3)
max_attempts: Mapped[int] = mapped_column(Integer, default=3, server_default="3")
created_at: Mapped[datetime] = mapped_column(DateTime, default=utc_now, index=True)
processed_at: Mapped[datetime | None] = mapped_column(DateTime, nullable=True, index=True)

22
app/modules/events/routes.py
View File

@@ -1,15 +1,17 @@
from fastapi import APIRouter, Depends, Query
from sqlalchemy.orm import Session
from app.application.events import EventDispatchService
from app.core.database import get_db
from app.core.security import ApiPrincipal, require_api_key
from app.modules.events.constants import EventResponseKey
from app.modules.events.schemas import DomainEventListRead, DomainEventRead
from app.modules.events.services import EventService, _serialize_event
router = APIRouter(dependencies=[Depends(require_api_key)])
@router.get("")
@router.get("", response_model=DomainEventListRead)
def list_events(
status: str | None = None,
event_type: str | None = None,
@@ -25,15 +27,19 @@ def list_events(
}
@router.post("/{event_id}/dispatch")
@router.post("/{event_id}/dispatch", response_model=dict[str, DomainEventRead])
def dispatch_event(
event_id: str,
db: Session = Depends(get_db),
) -> dict:
return {EventResponseKey.EVENT: _serialize_event(EventService(db).dispatch_event(event_id))}
return {
EventResponseKey.EVENT: _serialize_event(
EventDispatchService(db).dispatch_event(event_id)
)
}
@router.post("/{event_id}/retry")
@router.post("/{event_id}/retry", response_model=dict[str, DomainEventRead])
def retry_event(
event_id: str,
db: Session = Depends(get_db),
@@ -41,14 +47,16 @@ def retry_event(
) -> dict:
return {
EventResponseKey.EVENT: _serialize_event(
EventService(db).retry_event(event_id, actor=principal.actor)
EventDispatchService(db).retry_event(event_id, actor=principal.actor)
)
}
@router.post("/dispatch-pending")
@router.post("/dispatch-pending", response_model=DomainEventListRead)
def dispatch_pending(
limit: int = Query(default=100, ge=1, le=500),
db: Session = Depends(get_db),
) -> dict:
return {EventResponseKey.ITEMS: EventService(db).dispatch_pending(limit=limit)}
return {
EventResponseKey.ITEMS: EventDispatchService(db).dispatch_pending(limit=limit)
}

7
app/modules/events/schemas.py
View File

@@ -1,3 +1,4 @@
from datetime import datetime
from typing import Any
from pydantic import BaseModel
@@ -15,9 +16,9 @@ class DomainEventRead(BaseModel):
attempts: int
idempotency_key: str | None
last_error: str | None
created_at: str
processed_at: str | None
created_at: datetime
processed_at: datetime | None
class DomainEventListRead(BaseModel):
items: list[dict[str, Any]]
items: list[DomainEventRead]

145
app/modules/events/services/dispatch.py
View File

@@ -1,145 +0,0 @@
from datetime import timedelta
from typing import Any
from uuid import uuid4
from fastapi import HTTPException, status
from sqlalchemy import or_, select
from app.core.config import get_settings
from app.core.constants import ActorValue
from app.core.http.pagination import bounded_limit
from app.core.utils.time import utc_now
from app.modules.audit.constants import (
AuditAction,
AuditRiskLevel,
AuditSource,
AuditTargetType,
)
from app.modules.audit.schemas import AuditLogCreate
from app.modules.audit.service import AuditService
from app.modules.events.constants import (
EventErrorDetail,
EventPayloadKey,
EventStatus,
)
from app.modules.events.models import DomainEvent
from app.modules.events.services.serialization import _serialize_event
class EventDispatchMixin:
def dispatch_event(self, event_id: str, worker_id: str | None = None) -> DomainEvent:
record = self.get_event(event_id)
if record.status == EventStatus.PROCESSED:
return record
if not self._can_attempt(record):
return record
settings = get_settings()
now = utc_now()
lock_owner = worker_id or f"api:{uuid4().hex}"
record.locked_by = lock_owner
record.locked_until = now + timedelta(seconds=settings.event_dispatch_lock_seconds)
record.status = EventStatus.PENDING
record.attempts += 1
try:
self._handle_event(record)
except Exception as exc:
retryable = record.attempts < self._max_attempts(record)
record.status = EventStatus.PENDING if retryable else EventStatus.FAILED
record.last_error = str(exc)
record.next_attempt_at = (
utc_now() + timedelta(seconds=settings.event_dispatch_retry_delay_seconds)
if retryable
else None
)
record.locked_by = None
record.locked_until = None
self.db.commit()
self.db.refresh(record)
self._audit_dispatch(record)
return record
record.status = EventStatus.PROCESSED
record.last_error = None
record.processed_at = utc_now()
record.next_attempt_at = None
record.locked_by = None
record.locked_until = None
self.db.commit()
self.db.refresh(record)
self._audit_dispatch(record)
return record
def dispatch_pending(
self,
limit: int = 100,
worker_id: str | None = None,
) -> list[dict[str, Any]]:
now = utc_now()
stmt = (
select(DomainEvent)
.where(
DomainEvent.status == EventStatus.PENDING,
or_(
DomainEvent.next_attempt_at.is_(None),
DomainEvent.next_attempt_at <= now,
),
or_(
DomainEvent.locked_until.is_(None),
DomainEvent.locked_until <= now,
),
or_(
DomainEvent.max_attempts.is_(None),
DomainEvent.attempts < DomainEvent.max_attempts,
),
)
.order_by(DomainEvent.id.asc())
.limit(bounded_limit(limit))
)
records = list(self.db.execute(stmt).scalars())
lock_owner = worker_id or f"worker:{uuid4().hex}"
return [
_serialize_event(self.dispatch_event(record.event_id, worker_id=lock_owner))
for record in records
]
def retry_event(self, event_id: str, actor: str = ActorValue.API) -> DomainEvent:
record = self.get_event(event_id)
if record.status == EventStatus.PROCESSED:
raise HTTPException(
status_code=status.HTTP_409_CONFLICT,
detail=EventErrorDetail.EVENT_NOT_RETRYABLE,
)
record.status = EventStatus.PENDING
record.actor = actor
record.attempts = 0
record.max_attempts = record.max_attempts or get_settings().event_dispatch_max_attempts
record.last_error = None
record.locked_by = None
record.locked_until = None
record.next_attempt_at = utc_now()
self.db.commit()
self.db.refresh(record)
return record
def _audit_dispatch(self, record: DomainEvent) -> None:
AuditService(self.db).log(
AuditLogCreate(
actor=record.actor,
source=AuditSource.EVENTS,
action=AuditAction.EVENT_DISPATCH,
target_type=AuditTargetType.DOMAIN_EVENT,
target_id=record.event_id,
risk_level=AuditRiskLevel.LOW,
response_payload={
EventPayloadKey.STATUS: record.status,
EventPayloadKey.ATTEMPTS: record.attempts,
EventPayloadKey.ERROR_MESSAGE: record.last_error,
},
)
)
def _can_attempt(self, record: DomainEvent) -> bool:
return record.attempts < self._max_attempts(record)
@staticmethod
def _max_attempts(record: DomainEvent) -> int:
return record.max_attempts or get_settings().event_dispatch_max_attempts

128
app/modules/events/services/handlers.py
View File

@@ -1,128 +0,0 @@
from app.modules.events.constants import (
EventAggregateType,
EventPayloadKey,
EventType,
)
from app.modules.events.models import DomainEvent
class EventHandlerMixin:
def _handle_event(self, record: DomainEvent) -> None:
if record.event_type == EventType.RISK_ACTION_RECORDED:
self._handle_risk_action(record)
return
if record.event_type in {
EventType.REPORT_PUSH_SUCCEEDED,
EventType.REPORT_PUSH_FAILED,
EventType.REPORT_GENERATED,
}:
self._handle_report_event(record)
return
if record.event_type in {
EventType.LEGACY_SYNC_COMPLETED,
EventType.LEGACY_SYNC_FAILED,
}:
self._handle_legacy_sync_event(record)
return
if record.event_type == EventType.AI_MEMORY_WRITTEN:
self._handle_ai_memory_event(record)
return
if record.event_type == EventType.ENTERPRISE_ANALYTICS_GENERATED:
self._handle_enterprise_analytics_event(record)
return
def _handle_risk_action(self, record: DomainEvent) -> None:
from app.modules.risk.constants import RiskEventActionValue
from app.modules.workflows.service import WorkflowService
from app.modules.workflows.constants import WorkflowStatus, WorkflowType
payload = record.payload or {}
action = str(payload.get(EventPayloadKey.ACTION) or "")
if action == RiskEventActionValue.CLOSE:
workflow_status = WorkflowStatus.COMPLETED
elif action == RiskEventActionValue.RESOLVE:
workflow_status = WorkflowStatus.WAITING_REVIEW
else:
workflow_status = WorkflowStatus.RUNNING
WorkflowService(self.db).start_or_update(
workflow_type=WorkflowType.RISK_EVENT_REVIEW,
aggregate_type=EventAggregateType.RISK_EVENT,
aggregate_id=record.aggregate_id,
status_value=workflow_status,
action=action or record.event_type,
actor=record.actor,
payload=payload,
)
def _handle_report_event(self, record: DomainEvent) -> None:
from app.modules.workflows.constants import WorkflowStatus, WorkflowType
workflow_status = (
WorkflowStatus.FAILED
if record.event_type == EventType.REPORT_PUSH_FAILED
else WorkflowStatus.COMPLETED
)
self._track_operational_workflow(
record,
workflow_type=WorkflowType.REPORT_DELIVERY,
workflow_status=workflow_status,
)
def _handle_legacy_sync_event(self, record: DomainEvent) -> None:
from app.modules.workflows.constants import WorkflowStatus, WorkflowType
workflow_status = (
WorkflowStatus.FAILED
if record.event_type == EventType.LEGACY_SYNC_FAILED
else WorkflowStatus.COMPLETED
)
self._track_operational_workflow(
record,
workflow_type=WorkflowType.LEGACY_SYNC_MONITOR,
workflow_status=workflow_status,
)
def _handle_ai_memory_event(self, record: DomainEvent) -> None:
from app.modules.ai_memory.constants import AIMemoryPayloadKey, AIMemoryStatus
from app.modules.workflows.constants import WorkflowStatus, WorkflowType
payload = record.payload or {}
workflow_status = (
WorkflowStatus.BLOCKED
if payload.get(AIMemoryPayloadKey.STATUS) == AIMemoryStatus.REJECTED
else WorkflowStatus.COMPLETED
)
self._track_operational_workflow(
record,
workflow_type=WorkflowType.AI_MEMORY_CAPTURE,
workflow_status=workflow_status,
)
def _handle_enterprise_analytics_event(self, record: DomainEvent) -> None:
from app.modules.workflows.constants import WorkflowStatus, WorkflowType
self._track_operational_workflow(
record,
workflow_type=WorkflowType.ENTERPRISE_ANALYTICS,
workflow_status=WorkflowStatus.COMPLETED,
)
def _track_operational_workflow(
self,
record: DomainEvent,
workflow_type: str,
workflow_status: str,
) -> None:
from app.modules.workflows.service import WorkflowService
WorkflowService(self.db).start_or_update(
workflow_type=workflow_type,
aggregate_type=record.aggregate_type,
aggregate_id=record.aggregate_id,
status_value=workflow_status,
action=record.event_type,
actor=record.actor,
payload=record.payload or {},
)

52
app/modules/events/services/query.py
View File

@@ -10,14 +10,13 @@ from app.core.utils.time import utc_now
from app.modules.events.constants import (
EVENT_CODE_PREFIX,
EventErrorDetail,
EventStatus,
)
from app.modules.events.models import DomainEvent
from app.modules.events.services.serialization import _serialize_event
class EventQueryMixin:
def emit(
def enqueue(
self,
event_type: str,
source: str,
@@ -26,16 +25,12 @@ class EventQueryMixin:
actor: str = ActorValue.SYSTEM,
payload: dict[str, Any] | None = None,
idempotency_key: str | None = None,
dispatch: bool = False,
) -> DomainEvent:
if idempotency_key:
existing = self.db.execute(
select(DomainEvent).where(DomainEvent.idempotency_key == idempotency_key)
).scalar_one_or_none()
if existing is not None:
if dispatch and existing.status == EventStatus.PENDING:
return self.dispatch_event(existing.event_id)
return existing
"""Stage an outbox event in the caller's transaction."""
existing = self._find_idempotent_event(idempotency_key)
if existing is not None:
return existing
settings = get_settings()
now = utc_now()
@@ -52,12 +47,43 @@ class EventQueryMixin:
max_attempts=settings.event_dispatch_max_attempts,
)
self.db.add(record)
self.db.flush()
return record
def emit(
self,
event_type: str,
source: str,
aggregate_type: str,
aggregate_id: str | int | None,
actor: str = ActorValue.SYSTEM,
payload: dict[str, Any] | None = None,
idempotency_key: str | None = None,
) -> DomainEvent:
existing = self._find_idempotent_event(idempotency_key)
if existing is not None:
return existing
record = self.enqueue(
event_type=event_type,
source=source,
aggregate_type=aggregate_type,
aggregate_id=aggregate_id,
actor=actor,
payload=payload,
idempotency_key=idempotency_key,
)
self.db.commit()
self.db.refresh(record)
if dispatch:
return self.dispatch_event(record.event_id)
return record
def _find_idempotent_event(self, idempotency_key: str | None) -> DomainEvent | None:
if not idempotency_key:
return None
return self.db.execute(
select(DomainEvent).where(DomainEvent.idempotency_key == idempotency_key)
).scalar_one_or_none()
def list_events(
self,
status_filter: str | None = None,

6
app/modules/events/services/service.py
View File

@@ -1,16 +1,12 @@
from sqlalchemy.orm import Session
from app.modules.events.services.dispatch import EventDispatchMixin
from app.modules.events.services.handlers import EventHandlerMixin
from app.modules.events.services.query import EventQueryMixin
class EventService(
EventDispatchMixin,
EventHandlerMixin,
EventQueryMixin,
):
"""Persist outbox events and dispatch the V3 internal handlers."""
"""Persist and query transactional outbox events."""
def __init__(self, db: Session):
self.db = db