diff --git a/tests/test_account_protection_service.py b/tests/test_account_protection_service.py index 9ca9cfb..014a3c2 100644 --- a/tests/test_account_protection_service.py +++ b/tests/test_account_protection_service.py @@ -161,6 +161,22 @@ def test_protection_target_reports_ck_health_and_shortage(db): } +def test_protection_target_counts_missing_cookie_without_full_account_load(db): + account = _account("protection-no-cookie") + account.cookie = "" + db.add(account) + db.flush() + db.add(_presale_task(account)) + db.add(_health_job()) + db.commit() + + rows = evaluate_protection_targets(db, now=NOW) + presale = next(row for row in rows if row["group_key"] == "presale_bound") + + assert presale["bound_count"] == 1 + assert presale["without_cookie"] == 1 + + def test_ck_health_probes_protected_account_at_its_shorter_interval_first(db): protected = _account( "protection-due", diff --git a/tests/test_account_supply_service.py b/tests/test_account_supply_service.py index 52974a1..6d6b3ed 100644 --- a/tests/test_account_supply_service.py +++ b/tests/test_account_supply_service.py @@ -19,9 +19,16 @@ from web.backend.models import ( LoginAttempt, User, ) -from web.backend.routers.douyu import create_supply_target, list_supply_targets +from web.backend.routers.douyu import ( + create_supply_target, + list_supply_target_configs, + list_supply_targets, +) from web.backend.schemas import DouyuSupplyTargetUpsert -from web.backend.services.account_observability import account_platform_status +from web.backend.services.account_observability import ( + account_platform_status, + account_platform_trends, +) from web.backend.services.account_supply_service import ( VALUE_HIGH, _global_inventory_totals, @@ -349,6 +356,9 @@ def test_supply_target_configuration_route_returns_inventory(db): assert listed[0].id == created.id assert listed[0].target_id == created.id assert listed[0].needs_replenishment is True + configs = list_supply_target_configs(db=db, current=user) + assert configs[0].target_id == created.target_id + assert configs[0].target_covered == 10 def test_account_platform_status_aggregates_queue_sync_and_supply(db): @@ -400,6 +410,21 @@ def test_account_platform_status_aggregates_queue_sync_and_supply(db): } +def test_account_platform_status_can_defer_trends(db): + account = _account("platform-no-trends", points=400) + db.add(account) + db.flush() + db.add(_state(account)) + db.commit() + + status = account_platform_status(db, now=NOW, include_trends=False) + trends = account_platform_trends(db, now=NOW) + + assert status["trends"] is None + assert len(trends["trends"]["query"]) == 7 + assert isinstance(trends["alerts"], list) + + def test_account_platform_status_builds_seven_day_trends(db): account = _account("platform-trends", points=400) db.add(account) diff --git a/web/backend/routers/douyu.py b/web/backend/routers/douyu.py index be78f45..ddbe80b 100644 --- a/web/backend/routers/douyu.py +++ b/web/backend/routers/douyu.py @@ -54,6 +54,7 @@ from ..schemas import ( DouyuConfigUpdate, DouyuExchangeResultImageOut, DouyuGoodsOut, + DouyuSupplyTargetConfigOut, DouyuSupplyTargetOut, DouyuSupplyTargetUpdate, DouyuSupplyTargetUpsert, @@ -64,7 +65,10 @@ from ..schemas import ( DouyuXpdGoodsOut, ) from ..services.account_binding import bind_payload -from ..services.account_observability import account_platform_status +from ..services.account_observability import ( + account_platform_status, + account_platform_trends, +) from ..services.account_protection_service import ( evaluate_protection_targets, update_protection_group, @@ -739,11 +743,21 @@ def task_types(current: User = Depends(require_permission("douyu:task"))): @router.get("/account-platform-status") def get_account_platform_status( + include_trends: bool = Query(True), db: Session = Depends(get_db), current: User = Depends(require_permission("douyu:task")), ): """账号同步、CK 周期、商品覆盖和供给缺口的统一观测快照。""" - return account_platform_status(db) + return account_platform_status(db, include_trends=include_trends) + + +@router.get("/account-platform-trends") +def get_account_platform_trends( + db: Session = Depends(get_db), + current: User = Depends(require_permission("douyu:task")), +): + """延迟加载账号平台 7 天趋势,避免阻塞账号检测首屏。""" + return account_platform_trends(db) @router.put( @@ -1071,6 +1085,46 @@ def list_supply_targets( ] +@router.get( + "/supply-targets/config", + response_model=list[DouyuSupplyTargetConfigOut], +) +def list_supply_target_configs( + db: Session = Depends(get_db), + current: User = Depends(require_permission("douyu:config")), +): + """只返回供给目标配置,库存由 account-platform-status 统一提供。""" + rows = ( + db.query(AccountSupplyTarget) + .order_by( + AccountSupplyTarget.enabled.desc(), + AccountSupplyTarget.scope.asc(), + AccountSupplyTarget.value_class.asc(), + AccountSupplyTarget.commodity_id.asc(), + AccountSupplyTarget.id.asc(), + ) + .all() + ) + return [ + DouyuSupplyTargetConfigOut( + id=int(row.id), + target_id=int(row.id), + platform=row.platform, + scope=row.scope, + commodity_id=row.commodity_id, + value_class=row.value_class, + target_covered=int(row.target_covered or 0), + target_available=int(row.target_available or 0), + target_allocatable=int(row.target_allocatable or 0), + safety_buffer=int(row.safety_buffer or 0), + enabled=bool(row.enabled), + updated_by=row.updated_by, + updated_at=row.updated_at, + ) + for row in rows + ] + + @router.post("/supply-targets", response_model=DouyuSupplyTargetOut) def create_supply_target( req: DouyuSupplyTargetUpsert, diff --git a/web/backend/schemas.py b/web/backend/schemas.py index 0459ebf..9b8dac0 100644 --- a/web/backend/schemas.py +++ b/web/backend/schemas.py @@ -1630,6 +1630,22 @@ class DouyuSupplyTargetOut(BaseModel): updated_at: datetime | None = None +class DouyuSupplyTargetConfigOut(BaseModel): + id: int + target_id: int + platform: str + scope: str + commodity_id: str + value_class: str + target_covered: int + target_available: int + target_allocatable: int + safety_buffer: int + enabled: bool + updated_by: int | None = None + updated_at: datetime | None = None + + class DouyuAccountProtectionTargetUpdate(BaseModel): enabled: bool = True target_count: int = Field(0, ge=0, le=100_000) diff --git a/web/backend/services/account_observability.py b/web/backend/services/account_observability.py index 6ed17a3..fbb7e78 100644 --- a/web/backend/services/account_observability.py +++ b/web/backend/services/account_observability.py @@ -193,10 +193,79 @@ def _platform_trends(db: Session, moment: datetime) -> dict[str, Any]: } +def _trend_alerts(trends: dict[str, Any]) -> list[dict[str, Any]]: + alerts: list[dict[str, Any]] = [] + query_sample = sum( + int(row["success"]) + int(row["failed"]) for row in trends["query"] + ) + query_success = sum(int(row["success"]) for row in trends["query"]) + query_rate = _rate(query_success, query_sample) + if query_sample >= 20 and query_rate < 80: + alerts.append( + { + "code": "query_success_rate_low", + "severity": "critical" if query_rate < 50 else "warning", + "count": query_sample, + "message": ( + f"近 {TREND_DAYS} 天查询成功率 {query_rate:.1f}%" + f"({query_sample} 次已完成查询)" + ), + } + ) + + login_sample = sum( + int(row["success"]) + int(row["failed"]) for row in trends["login"] + ) + login_success = sum(int(row["success"]) for row in trends["login"]) + login_rate = _rate(login_success, login_sample) + if login_sample >= 10 and login_rate < 60: + alerts.append( + { + "code": "login_success_rate_low", + "severity": "critical" if login_rate < 40 else "warning", + "count": login_sample, + "message": ( + f"近 {TREND_DAYS} 天登录成功率 {login_rate:.1f}%" + f"({login_sample} 次已完成尝试)" + ), + } + ) + + relogin_ok = sum(int(row["relogin_ok"]) for row in trends["lifecycle"]) + relogin_failed = sum(int(row["relogin_failed"]) for row in trends["lifecycle"]) + if relogin_failed >= 5 and relogin_failed > relogin_ok: + alerts.append( + { + "code": "relogin_failure_trend_high", + "severity": "warning", + "count": relogin_failed, + "message": ( + f"近 {TREND_DAYS} 天重登失败 {relogin_failed} 次," + f"成功 {relogin_ok} 次" + ), + } + ) + return alerts + + +def account_platform_trends( + db: Session, + *, + now: datetime | None = None, +) -> dict[str, Any]: + """返回可延迟加载的趋势和趋势告警,避免阻塞账号检测首屏。""" + trends = _platform_trends(db, now or datetime.now(UTC)) + return { + "trends": trends, + "alerts": _trend_alerts(trends), + } + + def account_platform_status( db: Session, *, now: datetime | None = None, + include_trends: bool = True, ) -> dict[str, Any]: moment = now or datetime.now(UTC) in_24h = moment + timedelta(hours=24) @@ -349,9 +418,8 @@ def account_platform_status( ) if not item.needs_replenishment: continue - critical = ( - (item.target_available > 0 and item.available <= 0) - or (item.target_allocatable > 0 and item.allocatable <= 0) + critical = (item.target_available > 0 and item.available <= 0) or ( + item.target_allocatable > 0 and item.allocatable <= 0 ) alerts.append( { @@ -440,61 +508,9 @@ def account_platform_status( } ) - trends = _platform_trends(db, moment) - query_sample = sum( - int(row["success"]) + int(row["failed"]) - for row in trends["query"] - ) - query_success = sum(int(row["success"]) for row in trends["query"]) - query_rate = _rate(query_success, query_sample) - if query_sample >= 20 and query_rate < 80: - alerts.append( - { - "code": "query_success_rate_low", - "severity": "critical" if query_rate < 50 else "warning", - "count": query_sample, - "message": ( - f"近 {TREND_DAYS} 天查询成功率 {query_rate:.1f}%" - f"({query_sample} 次已完成查询)" - ), - } - ) - - login_sample = sum( - int(row["success"]) + int(row["failed"]) - for row in trends["login"] - ) - login_success = sum(int(row["success"]) for row in trends["login"]) - login_rate = _rate(login_success, login_sample) - if login_sample >= 10 and login_rate < 60: - alerts.append( - { - "code": "login_success_rate_low", - "severity": "critical" if login_rate < 40 else "warning", - "count": login_sample, - "message": ( - f"近 {TREND_DAYS} 天登录成功率 {login_rate:.1f}%" - f"({login_sample} 次已完成尝试)" - ), - } - ) - - relogin_ok = sum(int(row["relogin_ok"]) for row in trends["lifecycle"]) - relogin_failed = sum( - int(row["relogin_failed"]) for row in trends["lifecycle"] - ) - if relogin_failed >= 5 and relogin_failed > relogin_ok: - alerts.append( - { - "code": "relogin_failure_trend_high", - "severity": "warning", - "count": relogin_failed, - "message": ( - f"近 {TREND_DAYS} 天重登失败 {relogin_failed} 次," - f"成功 {relogin_ok} 次" - ), - } - ) + trends = _platform_trends(db, moment) if include_trends else None + if trends is not None: + alerts.extend(_trend_alerts(trends)) return { "checked_at": moment, @@ -523,4 +539,4 @@ def account_platform_status( } -__all__ = ["account_platform_status"] +__all__ = ["account_platform_status", "account_platform_trends"] diff --git a/web/backend/services/account_protection_service.py b/web/backend/services/account_protection_service.py index dde6689..275620c 100644 --- a/web/backend/services/account_protection_service.py +++ b/web/backend/services/account_protection_service.py @@ -14,9 +14,10 @@ from __future__ import annotations from dataclasses import dataclass -from datetime import UTC, datetime +from datetime import UTC, datetime, timedelta from typing import Any +from sqlalchemy import and_, case, func, or_ from sqlalchemy.orm import Session from ..models import ( @@ -97,9 +98,7 @@ def normalize_group_config( MIN_PROBE_INTERVAL_MINUTES, MAX_PROBE_INTERVAL_MINUTES, ), - "auto_relogin": bool( - value.get("auto_relogin", definition["auto_relogin"]) - ), + "auto_relogin": bool(value.get("auto_relogin", definition["auto_relogin"])), } @@ -124,9 +123,7 @@ def _presale_account_ids(db: Session) -> set[int]: .filter( PlatformFulfillmentTask.sale_mode == "presale", PlatformFulfillmentTask.account_id.isnot(None), - PlatformFulfillmentTask.execution_status.notin_( - ("completed", "cancelled") - ), + PlatformFulfillmentTask.execution_status.notin_(("completed", "cancelled")), ) .distinct() .all() @@ -246,59 +243,109 @@ def evaluate_protection_targets( ) -> list[dict[str, Any]]: moment = now or datetime.now(UTC) snapshot = load_protection_snapshot(db, job_config=job_config) - all_ids = { - account_id - for ids in snapshot.group_account_ids.values() - for account_id in ids - } - accounts = ( - db.query(Account).filter(Account.id.in_(all_ids)).all() if all_ids else [] - ) - account_map = {int(account.id): account for account in accounts} rows: list[dict[str, Any]] = [] for key, group in snapshot.groups.items(): account_ids = snapshot.group_account_ids.get(key, frozenset()) - group_accounts = [ - account_map[account_id] - for account_id in account_ids - if account_id in account_map - ] + probe_cutoff = moment - timedelta(minutes=int(group["probe_interval_minutes"])) + if account_ids: + # 只做数据库条件聚合,不加载 Account ORM。完整账号行包含加密密码、 + # 邮箱/Cookie 和大型 JSON 快照,2174 行实测可占 2 秒以上。 + totals = ( + db.query( + func.count(Account.id), + func.coalesce( + func.sum( + case((Account.ck_check_status == "valid", 1), else_=0) + ), + 0, + ), + func.coalesce( + func.sum( + case((Account.ck_check_status == "invalid", 1), else_=0) + ), + 0, + ), + func.coalesce( + func.sum( + case((Account.ck_check_status == "error", 1), else_=0) + ), + 0, + ), + func.coalesce( + func.sum( + case( + ( + func.coalesce(Account.ck_check_status, "").notin_( + ("valid", "invalid", "error") + ), + 1, + ), + else_=0, + ) + ), + 0, + ), + func.coalesce( + func.sum( + case( + ( + or_( + Account.cookie.is_(None), + func.length(Account.cookie) == 0, + ), + 1, + ), + else_=0, + ) + ), + 0, + ), + func.coalesce( + func.sum( + case( + ( + or_( + Account.ck_checked_at.is_(None), + and_( + Account.ck_checked_at.isnot(None), + Account.ck_checked_at < probe_cutoff, + ), + ), + 1, + ), + else_=0, + ) + ), + 0, + ), + ) + .filter(Account.id.in_(account_ids)) + .one() + ) + ( + bound_count, + ck_valid, + ck_invalid, + ck_error, + ck_unchecked, + without_cookie, + probe_due_count, + ) = (int(value or 0) for value in totals) + else: + bound_count = ck_valid = ck_invalid = ck_error = 0 + ck_unchecked = without_cookie = probe_due_count = 0 + status_counts = { - "ck_valid": 0, - "ck_invalid": 0, - "ck_error": 0, - "ck_unchecked": 0, - "without_cookie": 0, + "ck_valid": ck_valid, + "ck_invalid": ck_invalid, + "ck_error": ck_error, + "ck_unchecked": ck_unchecked, + "without_cookie": without_cookie, } - for account in group_accounts: - status = str(account.ck_check_status or "") - if status == "valid": - status_counts["ck_valid"] += 1 - elif status == "invalid": - status_counts["ck_invalid"] += 1 - elif status == "error": - status_counts["ck_error"] += 1 - else: - status_counts["ck_unchecked"] += 1 - if not account.cookie: - status_counts["without_cookie"] += 1 target = int(group["target_count"]) shortage = max(target - status_counts["ck_valid"], 0) - probe_seconds = int(group["probe_interval_minutes"]) * 60 - due_at = moment.timestamp() - probe_seconds - due_count = sum( - 1 - for account in group_accounts - if account.ck_checked_at is None - or ( - account.ck_checked_at.replace(tzinfo=UTC) - if account.ck_checked_at.tzinfo is None - else account.ck_checked_at - ).timestamp() - <= due_at - ) needs_attention = bool( group["enabled"] and ( @@ -317,10 +364,10 @@ def evaluate_protection_targets( "target_count": target, "probe_interval_minutes": int(group["probe_interval_minutes"]), "auto_relogin": bool(group["auto_relogin"]), - "bound_count": len(group_accounts), + "bound_count": bound_count, **status_counts, "target_shortage": shortage, - "probe_due_count": due_count, + "probe_due_count": probe_due_count, "needs_attention": needs_attention, } ) diff --git a/web/frontend/src/api/douyu.ts b/web/frontend/src/api/douyu.ts index 29957b3..eac3df4 100644 --- a/web/frontend/src/api/douyu.ts +++ b/web/frontend/src/api/douyu.ts @@ -3,11 +3,13 @@ import type { DouyuAccountProtectionTarget, DouyuAccountProtectionTargetUpdate, DouyuAccountPlatformStatus, + DouyuPlatformTrendsResponse, DouyuConfig, DouyuExchangeResultImage, DouyuGoodsItem, DouyuRechargeChannel, DouyuSupplyTarget, + DouyuSupplyTargetConfig, DouyuSupplyTargetUpdate, DouyuSupplyTargetUpsert, DouyuTaskAccountItem, @@ -22,8 +24,12 @@ import type { export const douyuApi = { taskTypes: () => api.get, Record>('/douyu/task-types'), - getAccountPlatformStatus: () => - api.get('/douyu/account-platform-status'), + getAccountPlatformStatus: (includeTrends = true) => + api.get('/douyu/account-platform-status', { + params: { include_trends: includeTrends }, + }), + getAccountPlatformTrends: () => + api.get('/douyu/account-platform-trends'), updateAccountProtectionTarget: ( groupKey: DouyuAccountProtectionTarget['group_key'], data: DouyuAccountProtectionTargetUpdate, @@ -34,6 +40,8 @@ export const douyuApi = { ), listSupplyTargets: () => api.get('/douyu/supply-targets'), + listSupplyTargetConfigs: () => + api.get('/douyu/supply-targets/config'), createSupplyTarget: (data: DouyuSupplyTargetUpsert) => api.post('/douyu/supply-targets', data), updateSupplyTarget: (targetId: number, data: DouyuSupplyTargetUpdate) => diff --git a/web/frontend/src/api/types.ts b/web/frontend/src/api/types.ts index d44298e..3fbcbe9 100644 --- a/web/frontend/src/api/types.ts +++ b/web/frontend/src/api/types.ts @@ -745,6 +745,22 @@ export interface DouyuSupplyTargetStatus { needs_replenishment: boolean; } +export interface DouyuSupplyTargetConfig { + id: number; + target_id: number; + platform: string; + scope: string; + commodity_id: string; + value_class: 'high_value' | 'ordinary'; + target_covered: number; + target_available: number; + target_allocatable: number; + safety_buffer: number; + enabled: boolean; + updated_by: number | null; + updated_at: string | null; +} + export interface DouyuSupplyTarget extends DouyuSupplyTargetStatus { platform: string; enabled: boolean; @@ -859,6 +875,11 @@ export interface DouyuPlatformTrends { lifecycle: DouyuLifecycleTrendDay[]; } +export interface DouyuPlatformTrendsResponse { + trends: DouyuPlatformTrends; + alerts: DouyuPlatformAlert[]; +} + export interface DouyuAccountPlatformStatus { checked_at: string; accounts: { @@ -882,7 +903,7 @@ export interface DouyuAccountPlatformStatus { protection_targets: DouyuAccountProtectionTarget[]; supply_targets: DouyuSupplyTargetStatus[]; alerts: DouyuPlatformAlert[]; - trends: DouyuPlatformTrends; + trends: DouyuPlatformTrends | null; } export interface DouyuConfig { diff --git a/web/frontend/src/pages/douyu-tasks/AccountPlatformStatusPanel.tsx b/web/frontend/src/pages/douyu-tasks/AccountPlatformStatusPanel.tsx index c074875..7664252 100644 --- a/web/frontend/src/pages/douyu-tasks/AccountPlatformStatusPanel.tsx +++ b/web/frontend/src/pages/douyu-tasks/AccountPlatformStatusPanel.tsx @@ -30,7 +30,10 @@ import { douyuApi, type DouyuAccountProtectionTarget, type DouyuAccountPlatformStatus, + type DouyuPlatformAlert, + type DouyuPlatformTrends, type DouyuSupplyTarget, + type DouyuSupplyTargetConfig, } from '../../api/modules'; import { usePermissions } from '../../hooks/usePermissions'; import { message } from '../../utils/antdMessage'; @@ -83,8 +86,11 @@ export default function AccountPlatformStatusPanel() { const [form] = Form.useForm(); const [protectionForm] = Form.useForm(); const [status, setStatus] = useState(null); - const [targets, setTargets] = useState([]); + const [targetConfigs, setTargetConfigs] = useState([]); + const [trends, setTrends] = useState(null); + const [trendAlerts, setTrendAlerts] = useState([]); const [loading, setLoading] = useState(false); + const [trendsLoading, setTrendsLoading] = useState(false); const [error, setError] = useState(''); const [modalOpen, setModalOpen] = useState(false); const [saving, setSaving] = useState(false); @@ -96,26 +102,43 @@ export default function AccountPlatformStatusPanel() { const load = useCallback(async () => { setLoading(true); + setTrendsLoading(true); setError(''); - try { - const platformStatus = await douyuApi.getAccountPlatformStatus(); - if (canManage) { - setTargets(await douyuApi.listSupplyTargets()); - } else { - setTargets(platformStatus.supply_targets.map((row) => ({ - ...row, - platform: 'douyu', - enabled: true, - updated_by: null, - updated_at: null, - }))); + const statusPromise = douyuApi + .getAccountPlatformStatus(false) + .then((platformStatus) => { + setStatus(platformStatus); + }) + .catch((loadError: unknown) => { + setError(getErrorMessage(loadError)); + }) + .finally(() => { + setLoading(false); + }); + const targetsPromise = canManage + ? douyuApi.listSupplyTargetConfigs() + .then(setTargetConfigs) + .catch((loadError: unknown) => { + setError((current) => current || getErrorMessage(loadError)); + }) + : Promise.resolve(); + // 主状态返回后再加载趋势,避免两条重查询同时争抢数据库和 CPU。 + const trendsPromise = statusPromise.then(async () => { + try { + const response = await douyuApi.getAccountPlatformTrends(); + setTrends(response.trends); + setTrendAlerts(response.alerts); + } catch (loadError: unknown) { + setTrendAlerts([{ + code: 'account_trends_load_failed', + severity: 'info', + message: `趋势加载失败:${getErrorMessage(loadError)}`, + }]); + } finally { + setTrendsLoading(false); } - setStatus(platformStatus); - } catch (loadError: unknown) { - setError(getErrorMessage(loadError)); - } finally { - setLoading(false); - } + }); + await Promise.allSettled([statusPromise, targetsPromise, trendsPromise]); }, [canManage]); useEffect(() => { @@ -129,10 +152,48 @@ export default function AccountPlatformStatusPanel() { ), [status?.work_queue], ); + const targets = useMemo(() => { + const inventoryByTarget = new Map( + (status?.supply_targets || []).map((row) => [row.target_id, row]), + ); + const statusConfigs: DouyuSupplyTargetConfig[] = (status?.supply_targets || []).map( + (row) => ({ + id: row.target_id, + target_id: row.target_id, + platform: 'douyu', + scope: row.scope, + commodity_id: row.commodity_id, + value_class: row.value_class, + target_covered: row.target_covered, + target_available: row.target_available, + target_allocatable: row.target_allocatable, + safety_buffer: row.safety_buffer, + enabled: true, + updated_by: null, + updated_at: null, + }), + ); + const sourceConfigs = canManage && targetConfigs.length > 0 + ? targetConfigs + : statusConfigs; + return sourceConfigs.map((config) => { + const inventory = inventoryByTarget.get(config.target_id); + return { + ...config, + covered: inventory?.covered || 0, + available: inventory?.available || 0, + allocatable: inventory?.allocatable || 0, + covered_shortage: inventory?.covered_shortage || 0, + available_shortage: inventory?.available_shortage || 0, + allocatable_shortage: inventory?.allocatable_shortage || 0, + needs_replenishment: inventory?.needs_replenishment || false, + }; + }); + }, [canManage, status?.supply_targets, targetConfigs]); const trendRows = useMemo(() => { - if (!status) return []; + if (!trends) return []; const rows = new Map(); - for (const item of status.trends.query) { + for (const item of trends.query) { rows.set(item.date, { date: item.date, queryTotal: item.total, @@ -143,7 +204,7 @@ export default function AccountPlatformStatusPanel() { reloginOk: 0, }); } - for (const item of status.trends.login) { + for (const item of trends.login) { const row = rows.get(item.date) || { date: item.date, queryTotal: 0, @@ -157,7 +218,7 @@ export default function AccountPlatformStatusPanel() { row.loginRate = item.success_rate; rows.set(item.date, row); } - for (const item of status.trends.lifecycle) { + for (const item of trends.lifecycle) { const row = rows.get(item.date) || { date: item.date, queryTotal: 0, @@ -172,7 +233,11 @@ export default function AccountPlatformStatusPanel() { rows.set(item.date, row); } return [...rows.values()].sort((left, right) => left.date.localeCompare(right.date)); - }, [status]); + }, [trends]); + const visibleAlerts = useMemo( + () => [...(status?.alerts || []), ...trendAlerts], + [status?.alerts, trendAlerts], + ); const openCreate = () => { setEditing(null); @@ -480,15 +545,15 @@ export default function AccountPlatformStatusPanel() { > {error ? : null} - - - - + + + + - {status?.alerts.length ? ( + {visibleAlerts.length ? ( - {status.alerts.map((alert) => ( + {visibleAlerts.map((alert) => ( - {`近 ${status?.trends.days || 7} 天趋势`} + {`近 ${trends?.days || 7} 天趋势`}