P1:闭环时限管控、治理成效评估、站型阈值系数与接口测试

- 闭环状态流转自动记录接单/闭环时间,状态值校验;按断站分级判定响应时限
  (及时/超时/超时未响应/未到期/无记录),新增及时响应率、平均闭环时长、超时未闭环指标与筛选
- 新增治理成效评估 /api/effect:分界日期前后指标对比与问题站点逐站改善判定
- 新增站型阈值系数(实际阈值 = 场景阈值 × 站型系数)及配置接口与页面
- 样例数据新增接单/闭环时间(独立随机数,原字段不变),导入支持并校验
- 新增 tests/test_api.py(权限、导入模板、闭环流程、站型系数、成效评估、无数据边界)
- 修复:新流水无告警匹配时根因分析报错;空筛选时超长站点清单返回 500

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
treeandClaude Opus 5.5 committed 2026-11-18 15:14:06 +08:00
1 parent e9616af34d
commit 9400ab9053
13 files changed
+6540 -6043

No files matched your search

+8 -2
View File
@@ -95,6 +95,8 @@ npm run build # 重新生成 ../../static/vendor/
重新生成数据:`python data_gen.py --rows 6000`,然后删除 `data/outage.db` 并重启。
样例流水含接单时间 `handle_time` 与闭环时间 `close_time`(独立随机数生成,不影响其他字段)。旧版数据库启动时会自动补字段,但旧记录没有这两个时间,及时响应率显示为“—”;删除 `data/outage.db` 重启即可载入带闭环时间的样例数据。
## 支持导入的文件(「数据导入校验」页,上传后自动识别)
| 类型 | 文件 | 入库方式 |
@@ -113,7 +115,8 @@ npm run build # 重新生成 ../../static/vendor/
- **退服时长**:一律按“恢复时间 − 开始时间”重算;上报时长保存为 `reported_min`,两者相差超过 1 分钟即标记为“时长差错”。
- **统计周期**:顶栏筛选了月份 / 日期范围时取筛选范围(同时有则取交集),否则取全部流水首日 0 点到末日 24 点。
- **退服率** = 总退服时长 ÷(站点数 × 统计周期);**网络可用率** = 1 − 退服率。站点数按场景、片区、站型、厂家、站名关键字筛选。看板、对标与导出用同一口径。
- **超长退服站点**:月均超长退服 ≥ 1 次(单次时长 ≥ 场景阈值)。**高频重复站点**:月均退服次数 ≥ 场景次数阈值。“月均”按统计周期的自然月数计算。**重复退服率** = 高频重复站点数 ÷ 站点数。
- **站型分级阈值**:站点实际阈值 = 场景阈值 × 站型系数。默认室分超长时长 ×0.75(重点楼宇从严),分布式皮基站两项 ×1.5(覆盖小、有宏站兜底),宏站 ×1;可在「场景与站点分级」页修改。
- **超长退服站点**:月均超长退服 ≥ 1 次(单次时长 ≥ 站点实际阈值)。**高频重复站点**:月均退服次数 ≥ 站点实际次数阈值。“月均”按统计周期的自然月数计算。**重复退服率** = 高频重复站点数 ÷ 站点数。
- **根因判定分三级**(每条结果带置信度 高 / 中 / 低):
0. 衍生告警归并:带 `parent_alarm_id` 的告警按父告警类别计(停电引起的传输告警归为电源故障)。
1. 衍生关系(高):与退服开始相差 ≤ 2 分钟的“小区退服”告警带父告警时,取父告警类别。
@@ -123,7 +126,9 @@ npm run build # 重新生成 ../../static/vendor/
多条命中时依次比较:级别 → 是否随业务恢复清除(±15 分钟)→ 规则优先级(割接施工 → 电源故障 → 机房环境 → 传输中断 → 天馈故障 → 设备硬件)→ 时间早;都没有命中判为“其他”。
- **时间窗标定**:每次全量分析前,用已闭环流水中同站同类告警的提前量 95% 分位数标定各类时间窗(不小于默认值 30/300/180/15/30/15 分钟,不大于 720 分钟;样本少于 30 条时沿用默认值)。
- **告警—退服关联量化**:对每类告警计算支持度(退服前 W 分钟内有该类告警的退服占比)、置信度(该类告警其后 W 分钟内发生退服的比例)、提升度(置信度 ÷ 随机窗口遇到退服的概率)。
- **断站分级**:重要 / 主要 / 次要,对应不同的处置响应时限。
- **断站分级**:重要 / 主要 / 次要,对应不同的处置响应时限(2 / 4 / 24 小时,从退服开始算到接单)。
- **闭环时限**:状态改为“处理中 / 已闭环”时自动记录接单时间,改为“已闭环”时自动记录闭环时间,重新打开时清空闭环时间。每条流水判定为 及时 / 超时 / 超时未响应 / 未到期 / 无记录(历史数据没有接单时间);看板给出及时响应率、平均闭环时长、超时未闭环条数,流水管理可筛选“仅超时未闭环”。
- **治理成效评估**:以分界日期把统计周期分为治理前后两段,各按自身天数折算后比较 8 项指标;治理前被判为超长 / 高频的站点逐站比较月均退服次数与时长,变化超过 ±10% 记为改善或恶化。退服有季节性,跨季节对比需结合同期数据判断。
- **影响评估**:受影响用户 = 小区数 × 单小区在线用户 × 忙闲时系数 × 覆盖补偿系数;受影响用户·小时 = 受影响用户 × 退服时长;业务损失 = 小区话务 × 忙闲时系数 × 覆盖补偿系数 × 退服时长。覆盖补偿:500 米内每有一个邻站下降 10%(室分 5%),最低 40%。
## 测试
@@ -133,6 +138,7 @@ npm run build # 重新生成 ../../static/vendor/
```bash
python tests/test_rootcause.py # 根因判定准确率:基线 + 6 组扰动数据(去父告警、时钟偏移、告警缺失、干扰告警、提前量变宽、综合)
python tests/test_kpi.py # 统计周期、稀疏筛选、月均口径、看板与导出一致、影响评估、关联量化
python tests/test_api.py # 登录与权限、导入模板校验、闭环流程与响应时限、站型系数、治理成效、无数据边界
python bench.py # 单批 1 万条导入耗时、全量分析耗时、时长计算准确率
```
+68 -14
View File
@@ -5,10 +5,10 @@
接口分组(与下方代码顺序一致):
页面与认证 / /login /logout /healthz
看板与统计 /api/meta /api/dashboard /api/stats /api/confusion /api/association /api/sites/rank
看板与统计 /api/meta /api/dashboard /api/stats /api/confusion /api/association /api/sites/rank /api/effect
退服流水 /api/outages(查询、新增、修改、删除、批量) /api/analyze
数据导入 /api/import/preview /api/import/confirm /api/template
站点与场景 /api/sites /api/scenes
站点与场景 /api/sites /api/scenes /api/site_types
导出与系统 /api/export/<报表> /api/logs /api/users
"""
import io
@@ -144,7 +144,7 @@ def meta():
overview = query("SELECT (SELECT COUNT(*) FROM sites) AS sites, COUNT(*) AS records, "
"SUM(status <> '已闭环') AS open FROM outages")[0] # 侧边栏底部的数据概况
return jsonify(scenes=core.SCENES, site_types=core.SITE_TYPES, causes=core.CAUSES, months=months,
regions=regions, vendors=vendors, status=['待处理', '处理中', '已闭环'],
regions=regions, vendors=vendors, status=core.STATUSES,
role=session['role'], user=session['user'], overview=overview)
@@ -250,6 +250,17 @@ def association():
return jsonify(rows=core.association(current_filters()), windows=core.window_table())
@app.route('/api/effect')
@login_required
def effect():
"""治理成效评估:split=YYYY-MM-DD 为治理分界日期,不传时取评估周期中点所在月的 1 日。"""
try:
result = core.effect(current_filters(), request.args.get('split') or None)
except ValueError as e:
return jsonify(error=str(e)), 400
return jsonify(result)
@app.route('/api/sites/rank')
@login_required
def site_rank():
@@ -272,7 +283,8 @@ def site_rank():
OUTAGE_LIST_COLUMNS = ['id', 'record_id', 'ne_id', 'cell_id', 'site_name', 'scene', 'site_type', 'region', 'vendor',
'start_time', 'end_time', 'duration_min', 'reported_min', 'dur_diff', 'cause_category',
'cause_detail', 'cause_code', 'ticket_id', 'root_cause', 'evidence', 'confidence', 'level',
'status', 'handler', 'remark', 'affected_users', 'user_hours', 'loss_gb', 'advice']
'status', 'handler', 'remark', 'affected_users', 'user_hours', 'loss_gb', 'advice',
'handled_at', 'closed_at', 'response_min', 'close_h', 'limit_h', 'sla']
# 新增 / 管理员修改时写入的字段,顺序与 outage_values() 返回值一致
OUTAGE_EDIT_FIELDS = ['record_id', 'ne_id', 'cell_id', 'start_time', 'end_time', 'duration_min', 'cause_category',
@@ -282,13 +294,15 @@ OUTAGE_EDIT_FIELDS = ['record_id', 'ne_id', 'cell_id', 'start_time', 'end_time',
@app.route('/api/outages')
@login_required
def outages():
"""退服流水分页查询。除通用筛选外,long=1 只看超长,diff=1 只看上报时长差错。"""
"""退服流水分页查询。除通用筛选外,long=1 只看超长,diff=1 只看上报时长差错,overdue=1 只看超时未闭环。"""
filters = current_filters()
df = core.frame(filters)
if request.args.get('long') == '1':
df = df[df['is_long']]
if request.args.get('diff') == '1':
df = df[df['dur_diff']]
if request.args.get('overdue') == '1':
df = df[(df['status'] != '已闭环') & df['sla'].isin(['超时', '超时未响应'])]
sort = request.args.get('sort', 'start_time')
if sort not in df.columns:
@@ -313,6 +327,8 @@ def outage_values(data):
raise ValueError('恢复时间早于开始时间')
if not query('SELECT 1 FROM sites WHERE ne_id=?', (data['ne_id'],)):
raise ValueError('基站不在站点库中')
if (data.get('status') or '待处理') not in core.STATUSES:
raise ValueError('闭环状态不正确')
values = {
'record_id': data.get('record_id', ''),
@@ -336,7 +352,13 @@ def outage_values(data):
def outage_add():
columns = ','.join(OUTAGE_EDIT_FIELDS)
placeholders = ','.join('?' * len(OUTAGE_EDIT_FIELDS))
new_id = execute(f'INSERT INTO outages({columns}) VALUES({placeholders})', outage_values(request.get_json()))
data = request.get_json()
try:
values = outage_values(data)
except ValueError as e:
return jsonify(error=str(e)), 400
new_id = execute(f'INSERT INTO outages({columns}) VALUES({placeholders})', values)
core.update_status([new_id], data.get('status') or '待处理') # 按状态补接单 / 闭环时间
core.analyze_all([new_id])
log(session['user'], '新增退服记录', f'id={new_id}')
return jsonify(ok=True, id=new_id)
@@ -347,20 +369,29 @@ def outage_add():
def outage_update(outage_id):
"""
两种修改:
闭环处理:普通用户(或请求中没有 ne_id 时)只更新状态、处理人、处理说明;
闭环处理:普通用户(或请求中没有 ne_id 时)只更新状态、处理人、处理说明,接单 / 闭环时间自动记录;
完整修改:管理员修改全部字段,并重新做根因分析。
"""
data = request.get_json()
is_admin = session['role'] == 'admin'
if not query('SELECT 1 FROM outages WHERE id=?', (outage_id,)):
return jsonify(error='记录不存在'), 404
if not is_admin or 'ne_id' not in data:
execute('UPDATE outages SET status=?, handler=?, remark=? WHERE id=?',
(data.get('status'), data.get('handler', ''), data.get('remark', ''), outage_id))
try:
core.update_status([outage_id], data.get('status') or '', data.get('handler', ''), data.get('remark', ''))
except ValueError as e:
return jsonify(error=str(e)), 400
log(session['user'], '更新闭环进度', f"id={outage_id} -> {data.get('status')}")
return jsonify(ok=True)
try:
values = outage_values(data)
except ValueError as e:
return jsonify(error=str(e)), 400
assignments = ','.join(f'{field}=?' for field in OUTAGE_EDIT_FIELDS)
execute(f'UPDATE outages SET {assignments} WHERE id=?', outage_values(data) + (outage_id,))
execute(f'UPDATE outages SET {assignments} WHERE id=?', values + (outage_id,))
core.update_status([outage_id], data.get('status') or '待处理')
core.analyze_all([outage_id])
log(session['user'], '修改退服记录', f'id={outage_id}')
return jsonify(ok=True)
@@ -389,7 +420,10 @@ def outage_batch():
if data.get('action') == 'delete':
execute(f'DELETE FROM outages WHERE id IN ({placeholders})', ids)
else:
execute(f'UPDATE outages SET status=? WHERE id IN ({placeholders})', [data.get('status', '已闭环')] + ids)
try:
core.update_status(ids, data.get('status', '已闭环'))
except ValueError as e:
return jsonify(error=str(e)), 400
log(session['user'], '批量维护', f"{data.get('action')} {len(ids)} 条")
return jsonify(ok=True, n=len(ids))
@@ -506,7 +540,7 @@ def template():
@login_required
def sites():
return jsonify(rows=query('SELECT * FROM sites ORDER BY scene, district, site_name'),
scenes=query('SELECT * FROM scenes'))
scenes=query('SELECT * FROM scenes'), site_types=query('SELECT * FROM site_types'))
@app.route('/api/sites/<site_id>', methods=['PUT'])
@@ -530,6 +564,22 @@ def scene_edit(scene):
return jsonify(ok=True)
@app.route('/api/site_types/<site_type>', methods=['PUT'])
@admin_required
def site_type_edit(site_type):
"""站型阈值系数:站点实际阈值 = 场景阈值 × 系数。"""
if site_type not in core.SITE_TYPES:
return jsonify(error='未知站型'), 404
data = request.get_json()
long_factor = float(data['long_factor'])
freq_factor = float(data['freq_factor'])
if not (0.1 <= long_factor <= 10 and 0.1 <= freq_factor <= 10):
return jsonify(error='系数应在 0.1 ~ 10 之间'), 400
execute('INSERT OR REPLACE INTO site_types VALUES(?,?,?)', (site_type, long_factor, freq_factor))
log(session['user'], '修改站型系数', f'{site_type}: 时长×{long_factor} 次数×{freq_factor}')
return jsonify(ok=True)
# ================================================================ 报表导出
# 导出 Excel 时的中文列名
EXPORT_COLUMN_NAMES = {
@@ -541,6 +591,8 @@ EXPORT_COLUMN_NAMES = {
'cause_detail': '原因细项', 'cause_code': '原因码', 'ticket_id': '工单号', 'root_cause': '系统判定根因',
'evidence': '关联告警', 'level': '断站分级', 'status': '闭环状态', 'advice': '处置建议', 'record_id': '流水号',
'confidence': '判定置信度', 'user_h': '受影响用户·小时', 'user_hours': '受影响用户·小时',
'handled_at': '接单时间', 'closed_at': '闭环时间', 'response_min': '响应时长(分)', 'limit_h': '响应时限(h)',
'sla': '时限判定',
}
@@ -577,7 +629,9 @@ def export(kind):
['退服率(%)', k['outage_rate']], ['网络可用率(%)', k['availability']], ['超长退服占比(%)', k['long_ratio']],
['重复退服率(%)', k['repeat_rate']], ['受影响用户数', k['users']], ['受影响用户·小时', k['user_h']],
['业务损失(GB)', k['loss_gb']], ['统计站点数', k['sites']], ['统计周期(天)', round(minutes / 1440, 1)],
['根因判定准确率(%)', k['acc']], ['闭环率(%)', k['closed']], ['上报时长差错(条)', k['dur_fix']],
['根因判定准确率(%)', k['acc']], ['闭环率(%)', k['closed']], ['及时响应率(%)', k['response_rate']],
['平均闭环时长(h)', k['avg_close_h']], ['超时未闭环(条)', k['overdue_open']],
['上报时长差错(条)', k['dur_fix']],
]
site_columns = ['ne_id', 'site_name', 'region', 'scene', 'site_type', 'count', 'total_min', 'avg_min',
'max_min', 'long_count', 'users', 'user_h', 'top_cause']
@@ -611,7 +665,7 @@ def export(kind):
long_outages = long_outages.sort_values('duration_min', ascending=False)
columns = ['record_id', 'ne_id', 'site_name', 'scene', 'start_time', 'end_time', 'duration_min',
'cause_category', 'cause_code', 'root_cause', 'evidence', 'confidence', 'level', 'status',
'ticket_id', 'advice']
'handled_at', 'response_min', 'limit_h', 'sla', 'closed_at', 'ticket_id', 'advice']
sheets = {'根因处置建议': long_outages[columns].rename(columns=EXPORT_COLUMN_NAMES)}
title = '根因处置建议清单'
+187 -14
View File
@@ -66,6 +66,15 @@ COVER_RADIUS_M = 500
COVER_STEP = 0.1
COVER_FLOOR = 0.4
# 闭环管控
STATUSES = ['待处理', '处理中', '已闭环']
RESPONSE_HOURS = {'重要': 2, '主要': 4, '次要': 24} # 各断站分级的响应时限(从退服开始算到接单),与 LEVEL_TIP 一致
EFFECT_TOL = 10 # 治理成效:前后变化在 ±10% 以内视为“持平”
# 站型阈值系数:站点实际阈值 = 场景阈值 × 站型系数(超长时长系数, 高频次数系数)。
# 室分多覆盖商场、车站等重点楼宇,超长阈值从严;分布式皮基站覆盖范围小、有宏站兜底,两项阈值放宽。
SITE_TYPE_DEFAULT = {'宏站': (1.0, 1.0), '室分': (0.75, 1.0), '分布式皮基站': (1.5, 1.5)}
ADVICE = {
'电源故障': ['核查市电及开关电源状态,必要时调度油机发电', '检测蓄电池组容量,老化电池纳入更换计划', '评估加装智能电表与远程动环监控'],
'传输中断': ['联系传输专业排查光缆/光模块,定位断点', '核查 SCTP 偶联与 NG 链路配置', '重要站点规划传输双路由保护'],
@@ -139,26 +148,34 @@ CREATE TABLE IF NOT EXISTS sites(ne_id TEXT PRIMARY KEY, site_name TEXT, distric
CREATE TABLE IF NOT EXISTS outages(id INTEGER PRIMARY KEY, record_id TEXT, ne_id TEXT, cell_id TEXT,
start_time TEXT, end_time TEXT, duration_min REAL, reported_min REAL, cause_category TEXT, cause_detail TEXT,
cause_code TEXT, ticket_id TEXT, root_cause TEXT, evidence TEXT, status TEXT DEFAULT '待处理',
handler TEXT, remark TEXT, confidence TEXT);
handler TEXT, remark TEXT, confidence TEXT, handled_at TEXT, closed_at TEXT);
CREATE INDEX IF NOT EXISTS ix_out_ne ON outages(ne_id, start_time);
CREATE TABLE IF NOT EXISTS alarms(alarm_id TEXT PRIMARY KEY, ne_id TEXT, alarm_code TEXT, alarm_name TEXT,
alarm_level TEXT, category TEXT, start_time TEXT, clear_time TEXT, duration_s INTEGER, cleared TEXT,
parent_alarm_id TEXT);
CREATE INDEX IF NOT EXISTS ix_alarm_ne ON alarms(ne_id, start_time);
CREATE TABLE IF NOT EXISTS logs(id INTEGER PRIMARY KEY, username TEXT, action TEXT, detail TEXT, ts TEXT);
CREATE TABLE IF NOT EXISTS site_types(site_type TEXT PRIMARY KEY, long_factor REAL, freq_factor REAL);
CREATE TABLE IF NOT EXISTS windows(category TEXT PRIMARY KEY, window_min REAL, default_min REAL, samples INTEGER,
source TEXT, updated_at TEXT);
"""
def migrate():
"""旧版数据库补字段:outages.confidence(根因判定置信度)。补了字段返回 True,需要重新做一次全量分析。"""
"""
旧版数据库升级:outages 补 confidence(根因置信度)、handled_at(接单时间)、closed_at(闭环时间)字段,
站型系数表补默认值。补了 confidence 时返回 True,需要重新做一次全量分析。
"""
needs_analysis = False
with db() as conn:
columns = {row['name'] for row in conn.execute('PRAGMA table_info(outages)')}
if 'confidence' not in columns:
conn.execute('ALTER TABLE outages ADD COLUMN confidence TEXT')
return True
return False
for column in ('confidence', 'handled_at', 'closed_at'):
if column not in columns:
conn.execute(f'ALTER TABLE outages ADD COLUMN {column} TEXT')
needs_analysis = needs_analysis or column == 'confidence'
for site_type, (long_factor, freq_factor) in SITE_TYPE_DEFAULT.items():
conn.execute('INSERT OR IGNORE INTO site_types VALUES(?,?,?)', (site_type, long_factor, freq_factor))
return needs_analysis
def init_db():
@@ -248,6 +265,37 @@ def save_sites(df):
return added, updated
def update_status(ids, status, handler=None, remark=None):
"""
更新闭环状态并自动记录时间:
转为“处理中 / 已闭环”且还没有接单时间 → 接单时间 = 当前时间;
转为“已闭环”且还没有闭环时间 → 闭环时间 = 当前时间;转为其他状态(重新打开)→ 清空闭环时间。
handler / remark 不为 None 时一并更新。
"""
if status not in STATUSES:
raise ValueError(f'闭环状态只能是:{"、".join(STATUSES)}')
ids = [int(i) for i in ids]
if not ids:
return 0
now = datetime.now().strftime(TIME_FMT)
sets = ['status = ?',
"handled_at = CASE WHEN ? <> '待处理' THEN COALESCE(handled_at, ?) ELSE handled_at END",
"closed_at = CASE WHEN ? = '已闭环' THEN COALESCE(closed_at, ?) ELSE NULL END"]
args = [status, status, now, status, now]
if handler is not None:
sets.append('handler = ?')
args.append(handler)
if remark is not None:
sets.append('remark = ?')
args.append(remark)
placeholders = ','.join('?' * len(ids))
with db() as conn:
changed = conn.execute(f'UPDATE outages SET {", ".join(sets)} WHERE id IN ({placeholders})',
args + ids).rowcount
data_changed()
return changed
# ================================================================ 5. 根因关联分析
def read_alarms(ne_ids=None, categories=None):
"""读取告警(可按基站、类别过滤),时间列解析为 datetime,开始时间列改名为 alarm_time。"""
@@ -387,7 +435,9 @@ def analyze(outages, windows=None):
child = alarms[(alarms['category'] == '小区退服') & linked][['ne_id', 'alarm_time', 'root_cat', 'root_name']]
matched = outages.merge(child, on='ne_id')
gap = (matched['alarm_time'] - matched['start_time']).abs()
matched = matched[gap <= pd.Timedelta(minutes=MATCH_TOL_MIN)].assign(gap=gap)
close_enough = gap <= pd.Timedelta(minutes=MATCH_TOL_MIN)
# 先筛选再赋值且只赋筛选后的部分:给空 DataFrame 赋一个整列 Series 时,pandas 会沿用 Series 的索引凭空生成空行
matched = matched[close_enough].assign(gap=gap[close_enough])
matched = matched.sort_values(['id', 'gap']).drop_duplicates('id')
for row in matched.itertuples():
results[row.id] = (row.root_cat, f'衍生关系:{row.root_name} → 小区退服@{row.alarm_time:%m-%d %H:%M}', '高')
@@ -519,9 +569,10 @@ def site_cover():
def full_frame():
"""
全部退服流水 + 站点信息 + 场景阈值,并计算派生字段:
全部退服流水 + 站点信息 + 场景阈值 × 站型系数,并计算派生字段:
is_long 是否超长、dur_diff 上报时长差错、cover_factor 覆盖补偿系数、affected_users 受影响用户、
user_hours 受影响用户·小时、loss_gb 业务损失、level 断站分级。
user_hours 受影响用户·小时、loss_gb 业务损失、level 断站分级、
response_min 响应时长、close_h 闭环时长、limit_h 响应时限、sla 响应时限判定。
结果缓存到数据变化为止(见 data_changed)。
"""
global _frame_cache
@@ -530,14 +581,19 @@ def full_frame():
with db() as conn:
df = pd.read_sql('SELECT o.*, s.site_name, s.district AS region, s.scene, s.site_type, s.vendor, s.cells, '
'c.long_min, c.freq_count, c.users_per_cell, c.gb_per_cell_h FROM outages o '
'LEFT JOIN sites s ON o.ne_id = s.ne_id LEFT JOIN scenes c ON s.scene = c.scene', conn)
'c.long_min AS scene_long_min, c.freq_count AS scene_freq_count, c.users_per_cell, '
'c.gb_per_cell_h, t.long_factor, t.freq_factor FROM outages o '
'LEFT JOIN sites s ON o.ne_id = s.ne_id LEFT JOIN scenes c ON s.scene = c.scene '
'LEFT JOIN site_types t ON s.site_type = t.site_type', conn)
df['site_name'] = df['site_name'].fillna(df['ne_id']) # 站点库里没有的站,用站号代替站名
df['start'] = pd.to_datetime(df['start_time'])
df['month'] = df['start_time'].str[:7]
long_min = df['long_min'].fillna(120)
# 站点实际阈值 = 场景阈值 × 站型系数
df['long_min'] = (df['scene_long_min'].fillna(120) * df['long_factor'].fillna(1)).round(1)
df['freq_count'] = (df['scene_freq_count'].fillna(4) * df['freq_factor'].fillna(1)).round(1)
long_min = df['long_min']
df['is_long'] = df['duration_min'] >= long_min
df['dur_diff'] = (df['reported_min'] - df['duration_min']).abs() > 1 # 人工上报时长与系统计算相差超过 1 分钟
@@ -563,6 +619,25 @@ def full_frame():
is_major = df['is_long'] | (key_scene & (df['duration_min'] >= 30))
df['level'] = np.select([is_important, is_major], ['重要', '主要'], default='次要')
# 闭环时限(从退服开始算):
# 及时 已接单,响应时长 ≤ 时限
# 超时 已接单,响应时长 > 时限
# 超时未响应 未接单且已超过时限
# 未到期 未接单,还在时限内
# 无记录 已闭环但没有接单时间(历史数据),不参与及时率统计
handled = pd.to_datetime(df['handled_at'], errors='coerce')
closed = pd.to_datetime(df['closed_at'], errors='coerce')
df['response_min'] = ((handled - df['start']).dt.total_seconds() / 60).round(1)
df['close_h'] = ((closed - df['start']).dt.total_seconds() / 3600).round(2)
df['limit_h'] = df['level'].map(RESPONSE_HOURS).astype(float)
waited_min = (pd.Timestamp.now() - df['start']).dt.total_seconds() / 60
df['sla'] = np.select(
[handled.notna() & (df['response_min'] <= df['limit_h'] * 60),
handled.notna(),
(df['status'] != '已闭环') & (waited_min > df['limit_h'] * 60),
df['status'] != '已闭环'],
['及时', '超时', '超时未响应', '未到期'], default='无记录')
_frame_cache = df
return df
@@ -661,6 +736,8 @@ def kpis(df, n_sites=None, minutes=None, months=None):
运维考核指标。n_sites / minutes / months 为站点数、统计时长(分钟)、统计月数,不传时按全量计算。
退服率 = 总退服时长 ÷(站点数 × 统计时长);网络可用率 = 1 − 退服率
重复退服率 = 高频重复站点数 ÷ 站点数
及时响应率 = 响应及时数 ÷(及时 + 超时 + 超时未响应);平均闭环时长 = 已闭环且有闭环时间的记录从退服开始到闭环
超时未闭环 = 未闭环且已超过响应时限(含已接单但超时的)
根因判定准确率 = 上报原因与系统判定一致的比例(只统计上报原因已填写的记录)
"""
if n_sites is None:
@@ -671,7 +748,8 @@ def kpis(df, n_sites=None, minutes=None, months=None):
months = months or default_months
if df.empty:
return dict(count=0, total_h=0, avg_min=0, outage_rate=0, availability=100, long_ratio=0, repeat_rate=0,
users=0, user_h=0, loss_gb=0, sites=n_sites, acc=0, dur_fix=0, closed=0)
users=0, user_h=0, loss_gb=0, sites=n_sites, acc=0, dur_fix=0, closed=0, response_rate=None,
avg_close_h=None, overdue_open=0)
total_minutes = df['duration_min'].sum()
denominator = max(n_sites, 1) * max(minutes, 1)
@@ -685,6 +763,13 @@ def kpis(df, n_sites=None, minutes=None, months=None):
else:
accuracy = 0
judged = df['sla'].isin(['及时', '超时', '超时未响应'])
# 没有可判定的记录(例如旧数据没有接单时间)时返回 None,页面显示“—”,避免误读成 0%
response_rate = round((df['sla'] == '及时').sum() / judged.sum() * 100, 2) if judged.any() else None
close_hours = df.loc[df['status'] == '已闭环', 'close_h'].dropna()
avg_close_h = round(float(close_hours.mean()), 1) if len(close_hours) else None
overdue_open = int(((df['status'] != '已闭环') & df['sla'].isin(['超时', '超时未响应'])).sum())
return dict(
count=len(df),
total_h=round(total_minutes / 60, 1),
@@ -700,6 +785,9 @@ def kpis(df, n_sites=None, minutes=None, months=None):
acc=accuracy,
dur_fix=int(df['dur_diff'].sum()),
closed=round((df['status'] == '已闭环').mean() * 100, 2),
response_rate=response_rate,
avg_close_h=avg_close_h,
overdue_open=overdue_open,
)
@@ -712,7 +800,8 @@ def site_stats(df, months=None):
if df.empty:
return pd.DataFrame(columns=['ne_id', 'site_name', 'region', 'scene', 'site_type', 'count', 'total_min',
'avg_min', 'max_min', 'long_count', 'users', 'user_h', 'long_min', 'freq_count',
'top_cause', 'long', 'repeat'])
'top_cause', 'long', 'repeat']).astype({'long': bool, 'repeat': bool})
# long / repeat 必须是布尔列:空的 object 列用作 stats[stats['long']] 时会被当成“选列”,结果丢掉所有列
if months is None:
months = period()[1]
@@ -741,3 +830,87 @@ def advice(cause, level):
"""处置建议文本:响应时限(按断站分级)+ 该根因的三条处置措施。"""
measures = ADVICE.get(cause or '其他', ADVICE['其他'])
return f"【{LEVEL_TIP.get(level, '')}】" + ';'.join(measures)
def effect(filters=None, split=None):
"""
治理成效评估:以 split 日期为界,把统计周期分成治理前、治理后两段,比较两段的考核指标与问题站点变化。
- 两段各按自己的天数折算(退服率按各自时长,“月均”按 30.44 天折算),不同长度的两段可以直接比较;
- 问题站点 = 治理前被判为超长或高频的站点,逐站比较前后的月均退服次数与时长,变化超过 ±10% 记为改善 / 恶化。
split 不传时取统计周期中点所在月的 1 日。月份 / 日期筛选用来限定整个评估周期。
"""
filters = filters or {}
lo, hi = period_bounds(filters)
if split:
split = pd.Timestamp(split)
else:
split = (lo + (hi - lo) / 2).to_period('M').start_time
if not lo < split < hi:
raise ValueError(f'分界日期需在评估周期 {lo:%Y-%m-%d} ~ {hi - pd.Timedelta(days=1):%Y-%m-%d} 之内')
df = frame(filters)
n_sites = site_count(filters)
parts = {'before': (df[df['start'] < split], lo, split), 'after': (df[df['start'] >= split], split, hi)}
summary = {}
monthly = {}
for name, (part, begin, end) in parts.items():
minutes = (end - begin).total_seconds() / 60
month_equivalent = minutes / 1440 / 30.44
k = kpis(part, n_sites, minutes, max(round(month_equivalent), 1))
k['monthly_count'] = round(k['count'] / month_equivalent, 1)
k['monthly_user_h'] = round(k['user_h'] / month_equivalent)
k['days'] = round(minutes / 1440)
summary[name] = k
monthly[name] = month_equivalent
# 指标名, 字段, 越小越好
metrics = [('月均退服次数', 'monthly_count', True), ('退服率(%)', 'outage_rate', True),
('平均退服时长(分)', 'avg_min', True), ('超长退服占比(%)', 'long_ratio', True),
('重复退服率(%)', 'repeat_rate', True), ('月均受影响用户·小时', 'monthly_user_h', True),
('及时响应率(%)', 'response_rate', False), ('平均闭环时长(h)', 'avg_close_h', True)]
rows = []
for title, key, lower_is_better in metrics:
before, after = summary['before'][key], summary['after'][key]
change = round((after - before) / before * 100, 1) if before and after is not None else None
rows.append(dict(metric=title, before=before, after=after, change=change,
verdict=judge(change, lower_is_better)))
# 问题站点逐站对比
before_part = parts['before'][0]
before_stats = site_stats(before_part, max(round(monthly['before']), 1))
problem = before_stats[before_stats['long'] | before_stats['repeat']]
after_part = parts['after'][0]
after_count = after_part.groupby('ne_id').size()
after_minutes = after_part.groupby('ne_id')['duration_min'].sum()
sites = []
for site in problem.itertuples():
count_before = site.count / monthly['before']
count_after = after_count.get(site.ne_id, 0) / monthly['after']
minutes_before = site.total_min / monthly['before']
minutes_after = after_minutes.get(site.ne_id, 0) / monthly['after']
change = round((count_after - count_before) / count_before * 100, 1) if count_before else None
sites.append(dict(
ne_id=site.ne_id, site_name=site.site_name, scene=site.scene, site_type=site.site_type,
kind='超长+高频' if site.long and site.repeat else ('超长退服' if site.long else '高频重复'),
top_cause=site.top_cause, count_before=round(count_before, 2), count_after=round(count_after, 2),
min_before=round(minutes_before, 1), min_after=round(minutes_after, 1), change=change,
verdict=judge(change, True)))
sites.sort(key=lambda r: r['min_before'], reverse=True)
verdicts = pd.Series([r['verdict'] for r in sites], dtype=object)
return dict(
split=f'{split:%Y-%m-%d}', begin=f'{lo:%Y-%m-%d}', end=f'{hi - pd.Timedelta(days=1):%Y-%m-%d}',
days_before=summary['before']['days'], days_after=summary['after']['days'], rows=rows, sites=sites,
improved=int((verdicts == '改善').sum()), worsened=int((verdicts == '恶化').sum()),
flat=int((verdicts == '持平').sum()),
)
def judge(change, lower_is_better):
"""变化幅度 → 改善 / 恶化 / 持平。"""
if change is None:
return '—'
if abs(change) <= EFFECT_TOL:
return '持平'
better = change < 0 if lower_is_better else change > 0
return '改善' if better else '恶化'
+6001 -6001
View File
File diff suppressed because it is too large. Load diff
+27 -2
View File
@@ -4,7 +4,8 @@
================================================================
字段口径与 data.py 完全一致:
data_outage.csv 退服记录 record_id, ne_id, cell_id, district, vendor, start_time, end_time,
duration_min, cause_category, cause_detail, cause_code, ticket_id, closed
duration_min, cause_category, cause_detail, cause_code, ticket_id, closed,
handle_time, close_time(后两列为本版新增:接单时间、闭环时间)
data_alarm.csv 告警流 alarm_id, ne_id, alarm_code, alarm_name, alarm_level, category,
start_time, clear_time, duration_s, cleared, parent_alarm_id
sites.csv 站点库 ne_id, site_name, district, scene, site_type, vendor, cells, lng, lat
@@ -84,7 +85,7 @@ MONTH_W = [0.8, 0.75, 0.9, 1.0, 1.15, 1.35, 1.45, 1.4, 1.1] # 各月退服权
FMT = '%Y-%m-%d %H:%M:%S'
OUTAGE_HEAD = ['record_id', 'ne_id', 'cell_id', 'district', 'vendor', 'start_time', 'end_time', 'duration_min',
'cause_category', 'cause_detail', 'cause_code', 'ticket_id', 'closed']
'cause_category', 'cause_detail', 'cause_code', 'ticket_id', 'closed', 'handle_time', 'close_time']
ALARM_HEAD = ['alarm_id', 'ne_id', 'alarm_code', 'alarm_name', 'alarm_level', 'category', 'start_time',
'clear_time', 'duration_s', 'cleared', 'parent_alarm_id']
SITE_HEAD = ['ne_id', 'site_name', 'district', 'scene', 'site_type', 'vendor', 'cells', 'lng', 'lat']
@@ -249,6 +250,30 @@ def generate(n=6000, seed=2026, out='.'):
noise_end = noise_start + datetime.timedelta(minutes=rng.randint(2, 30))
add_alarm(rng, alarms, ne_id, noise_category, noise_start, noise_end)
# 闭环过程时间:用独立的随机数生成器,不改变上面已有数据的随机序列。
# 接单(响应)时间 = 退服开始 + 响应时延:75% 在 1.5 小时内,18% 在 1.5~5 小时,7% 超过 5 小时;
# 已闭环的闭环时间 = max(恢复时间, 接单时间) + 10 分钟 ~ 10 小时(复核、回单);
# 未闭环的一半已接单(处理中),一半未接单(待处理)。
flow_rng = random.Random(seed + 1018)
for outage in outages:
start = datetime.datetime.strptime(outage['start_time'], FMT)
end = datetime.datetime.strptime(outage['end_time'], FMT)
r = flow_rng.random()
if r < .75:
delay = flow_rng.randint(3, 90)
elif r < .93:
delay = flow_rng.randint(91, 300)
else:
delay = flow_rng.randint(301, 1440)
handle = start + datetime.timedelta(minutes=delay)
if outage['closed'] == '是':
close = max(end, handle) + datetime.timedelta(minutes=flow_rng.randint(10, 600))
outage['handle_time'] = handle.strftime(FMT)
outage['close_time'] = close.strftime(FMT)
else:
outage['handle_time'] = handle.strftime(FMT) if flow_rng.random() < .5 else ''
outage['close_time'] = ''
# 背景告警:与退服无关的日常闪断告警
for _ in range(n):
site = rng.choice(sites)
+23 -3
View File
@@ -11,6 +11,7 @@
"""
import io
import numpy as np
import pandas as pd
from core import CAUSES, TIME_FMT, query
@@ -119,15 +120,19 @@ OUTAGE_ALIASES = {
'end_time': ['退服恢复时间', '恢复时间', '结束时间'], 'duration_min': ['退服时长', '退服时长(分钟)'],
'cause_category': ['原因大类', '退服原因'], 'cause_detail': ['原因细项'], 'cause_code': ['原因码'],
'ticket_id': ['工单号'], 'closed': ['是否闭环'],
'handled_at': ['handle_time', '接单时间', '响应时间'], 'closed_at': ['close_time', '闭环时间', '回单时间'],
}
OUTAGE_SAVE_COLUMNS = ['record_id', 'ne_id', 'cell_id', 'start_time', 'end_time', 'duration_min', 'reported_min',
'cause_category', 'cause_detail', 'cause_code', 'ticket_id', 'status']
'cause_category', 'cause_detail', 'cause_code', 'ticket_id', 'status', 'handled_at',
'closed_at']
def validate_outages(df):
"""
退服流水校验:必填字段、站号是否在站点库、时间格式、恢复早于开始、超过 30 天、文件内及库内重复。
退服流水校验:必填字段、站号是否在站点库、时间格式、恢复早于开始、超过 30 天、文件内及库内重复、
接单 / 闭环时间格式及是否早于退服开始。
退服时长一律按“恢复时间 − 开始时间”重算;文件里人工上报的时长保存为 reported_min,供核对差错。
闭环状态:是否闭环=是 或有闭环时间 → 已闭环;否则有接单时间 → 处理中;其余 → 待处理。
"""
df = rename_columns(df, OUTAGE_ALIASES)
@@ -153,6 +158,10 @@ def validate_outages(df):
start_text = clean_text(df['start_time']) # 问题行里原样显示用户填写的开始时间
start = parse_time(df['start_time'])
end = parse_time(df['end_time'])
handled = parse_time(df['handled_at'])
closed = parse_time(df['closed_at'])
handled_given = clean_text(df['handled_at']) != ''
closed_given = clean_text(df['closed_at']) != ''
known_sites = {row['ne_id'] for row in query('SELECT ne_id FROM sites')}
existing = {(row['ne_id'], row['start_time']) for row in query('SELECT ne_id, start_time FROM outages')}
@@ -182,6 +191,14 @@ def validate_outages(df):
elif key in seen_in_file or key in existing:
reasons.append('重复记录(同站同开始时间)')
seen_in_file.add(key)
if handled_given[i] and pd.isna(handled[i]):
reasons.append('接单时间格式错误')
elif handled_given[i] and handled[i] < start[i]:
reasons.append('接单时间早于退服开始')
if closed_given[i] and pd.isna(closed[i]):
reasons.append('闭环时间格式错误')
elif closed_given[i] and closed[i] < start[i]:
reasons.append('闭环时间早于退服开始')
if reasons:
errors.append({'row': i + 2, 'key': ne_id, 'start_time': start_text[i], 'reason': ';'.join(reasons)})
@@ -195,7 +212,10 @@ def validate_outages(df):
good['end_time'] = good_end.dt.strftime(TIME_FMT)
good['reported_min'] = pd.to_numeric(good['duration_min'], errors='coerce').astype(float)
good['duration_min'] = ((good_end - good_start).dt.total_seconds() / 60).round(1)
good['status'] = good['closed'].map({'是': '已闭环', '否': '待处理'}).fillna('待处理')
good['handled_at'] = handled.loc[good_rows].dt.strftime(TIME_FMT)
good['closed_at'] = closed.loc[good_rows].dt.strftime(TIME_FMT)
is_closed = (clean_text(good['closed']) == '是') | good['closed_at'].notna()
good['status'] = np.select([is_closed, good['handled_at'].notna()], ['已闭环', '处理中'], default='待处理')
# 原因大类只接受系统定义的 7 类,其他写法视为未填写
good['cause_category'] = good['cause_category'].where(good['cause_category'].isin(CAUSES), None)
+9 -1
View File
@@ -1,6 +1,6 @@
/* 内容层组件。只放有实际逻辑的组件;纯布局直接写 className(.grid / .row / .grow / .note / .chips,见 app.css)。 */
import {Card, Fragment, html, Picker, useState} from 'vendor';
import {CAUSE_COLOR, LEVEL_TONE, STATUS_TONE} from '../format.js';
import {CAUSE_COLOR, LEVEL_TONE, SLA_TONE, STATUS_TONE} from '../format.js';
/** 内容卡片:不透明,可带标题栏。span 为 12 栅格中占的列数 */
export function Section({title, hint, extra, span = 12, children}) {
@@ -40,6 +40,14 @@ export function StatusTag({value}) {
return html`<span className="tag" data-tone=${STATUS_TONE[value]}>${dot}${value}</span>`;
}
/** 响应时限判定标签(及时 / 超时 / 超时未响应 / 未到期 / 无记录) */
export const SlaTag = ({value}) => value && html`<span className="tag" data-tone=${SLA_TONE[value]}>${value}</span>`;
/** 变化判定:改善绿、恶化红、持平灰 */
export const VerdictTag = ({value}) => value && value !== '—'
? html`<span className="tag" data-tone=${{改善: 'green', 恶化: 'red', 持平: 'gray'}[value]}>${value}</span>`
: '—';
/** 根因:色点 + 名称 */
export const Cause = ({value}) => value && html`
<span className="cause"><i style=${{background: CAUSE_COLOR[value] || '#8e8e93'}}></i>${value}</span>`;
+2
View File
@@ -56,5 +56,7 @@ export const BLUE_SCALE = ['#e8f2ff', '#a9cfff', '#4da3ff', '#0062cc'];
/** 断站分级、闭环状态 -> 标签色调(见 app.css 中的 .tag[data-tone]) */
export const LEVEL_TONE = {重要: 'red', 主要: 'orange', 次要: 'gray'};
export const STATUS_TONE = {已闭环: 'green', 处理中: 'blue', 待处理: 'yellow'};
/** 响应时限判定 -> 标签色调 */
export const SLA_TONE = {及时: 'green', 超时: 'orange', 超时未响应: 'red', 未到期: 'blue', 无记录: 'gray'};
export const ROLE_NAME = {admin: '管理员', user: '普通用户'};
+67 -5
View File
@@ -1,9 +1,9 @@
import {html} from 'vendor';
import {html, TextField, useState} from 'vendor';
import {useApp, useFetch} from '../api.js';
import {accentMax, fixed, num} from '../format.js';
import {EChart} from '../components/EChart.js';
import {DataTable} from '../components/DataTable.js';
import {Kpi, Loading, Section} from '../components/ui.js';
import {Cause, Kpi, Loading, Section, VerdictTag} from '../components/ui.js';
const BENCH_COLUMNS = [
{key: 'scene', title: '场景'}, {key: 'sites', title: '站点数'}, {key: 'count', title: '退服次数'},
@@ -11,6 +11,24 @@ const BENCH_COLUMNS = [
{key: 'availability', title: '可用率(%)'}, {key: 'long_ratio', title: '超长占比(%)'}, {key: 'repeat_rate', title: '重复退服率(%)'},
{key: 'users', title: '受影响用户', render: num}, {key: 'user_h', title: '用户·小时', render: num},
{key: 'loss_gb', title: '业务损失(GB)', render: num},
{key: 'response_rate', title: '及时响应率(%)', render: v => v ?? '—'},
{key: 'avg_close_h', title: '平均闭环(h)', render: v => v ?? '—'},
];
const EFFECT_COLUMNS = [
{key: 'metric', title: '指标'}, {key: 'before', title: '治理前', render: v => (v == null ? '—' : num(v))},
{key: 'after', title: '治理后', render: v => (v == null ? '—' : num(v))},
{key: 'change', title: '变化(%)', render: v => (v === null ? '—' : `${v > 0 ? '+' : ''}${v}`)},
{key: 'verdict', title: '判定', render: v => html`<${VerdictTag} value=${v}/>`},
];
const EFFECT_SITE_COLUMNS = [
{key: 'site_name', title: '基站名称'}, {key: 'scene', title: '场景'}, {key: 'site_type', title: '站型'},
{key: 'kind', title: '治理前问题'}, {key: 'top_cause', title: '主要根因', render: v => html`<${Cause} value=${v}/>`},
{key: 'count_before', title: '月均次数·前'}, {key: 'count_after', title: '月均次数·后'},
{key: 'min_before', title: '月均时长·前(分)', render: num}, {key: 'min_after', title: '月均时长·后(分)', render: num},
{key: 'change', title: '次数变化(%)', render: v => (v === null ? '—' : `${v > 0 ? '+' : ''}${v}`)},
{key: 'verdict', title: '判定', render: v => html`<${VerdictTag} value=${v}/>`},
];
/** 场景柱状图配置:最大的场景用强调色标出 */
@@ -41,12 +59,24 @@ export default function Impact() {
<${Kpi} title="重复退服率" value=${fixed(k.repeat_rate)} unit="%"/>
</div>
</${Section}>
<${Section} title="闭环管控" hint="响应时限从退服开始算:重要 2 小时、主要 4 小时、次要 24 小时">
<div className="kpis">
<${Kpi} title="闭环率" value=${fixed(k.closed)} unit="%"/>
<${Kpi} title="及时响应率" value=${fixed(k.response_rate) || '—'} unit="%" sub="及时 ÷(及时 + 超时 + 超时未响应)"/>
<${Kpi} title="平均闭环时长" value=${k.avg_close_h ?? '—'} unit="h" sub="退服开始 → 闭环;无接单 / 闭环时间的记录不计"/>
<${Kpi} title="超时未闭环" value=${num(k.overdue_open)} unit="条" sub="可在退服流水管理中筛选处理"/>
</div>
</${Section}>
<${Section} span=${6} title="分场景退服率" hint="单位:%">
<${EChart} option=${sceneBar(bench, bench.map(x => x.outage_rate))}/>
</${Section}>
<${Section} span=${6} title="分场景受影响用户·小时" hint="单位:万人·h">
<${EChart} option=${sceneBar(bench, bench.map(x => +(x.user_h / 1e4).toFixed(1)))}/>
</${Section}>
<${Section} title="通信场景运维考核指标横向对标">
<${DataTable} rowKey="scene" columns=${BENCH_COLUMNS} rows=${bench}/>
</${Section}>
<${Effect}/>
<${Section} title="口径说明">
<div className="note">
退服率 = 总退服时长 ÷(站点数 × 统计周期);统计周期取顶栏的月份 / 日期范围,未筛选时为全部流水首日至末日。
@@ -54,8 +84,40 @@ export default function Impact() {
覆盖补偿:站点 500 米内每有一个邻站,受影响用户与话务损失下降 10%(室分站 5%),最低保留 40%。
</div>
</${Section}>
<${Section} title="通信场景运维考核指标横向对标">
<${DataTable} rowKey="scene" columns=${BENCH_COLUMNS} rows=${bench}/>
</${Section}>
</div>`;
}
/** 治理成效评估:以分界日期把统计周期分成前后两段,比较考核指标与问题站点的变化 */
function Effect() {
const {filters} = useApp();
const [split, setSplit] = useState('');
const {data} = useFetch('/api/effect', {...filters, split});
const picker = html`
<${TextField} type="date" label="治理分界日期" labelHidden controlSize="small" value=${split || data?.split || ''}
onChange=${e => setSplit(e.target.value)}/>`;
if (!data) return html`<${Section} title="治理成效评估" extra=${picker}><${Loading}/></${Section}>`;
const hint = `${data.begin} ~ ${data.split}(${data.days_before} 天)对比 ${data.split} ~ ${data.end}(${data.days_after} 天)`;
return html`
<${Section} title="治理成效评估" hint=${hint} extra=${picker}>
<div className="grid">
<div className="span-5">
<${DataTable} rowKey="metric" columns=${EFFECT_COLUMNS} rows=${data.rows}/>
<div className="note">
两段各按自身天数折算,长度不同也可直接比较;变化在 ±10% 以内记为持平。
退服存在季节性(夏季雷雨、高温停电多),跨季节对比时请结合同期数据判断。
</div>
</div>
<div className="span-7">
<div className="chips">
<div className="chip"><span>治理前问题站点</span>${data.sites.length} 个</div>
<div className="chip" data-tone="green"><span>改善</span>${data.improved}</div>
<div className="chip"><span>持平</span>${data.flat}</div>
<div className="chip"><span>恶化</span>${data.worsened}</div>
</div>
<${DataTable} rowKey="ne_id" columns=${EFFECT_SITE_COLUMNS} rows=${data.sites} maxHeight=${420}/>
</div>
</div>
</${Section}>`;
}
+11 -1
View File
@@ -2,7 +2,7 @@ import {Fragment, GlassButton, GlassCheckbox, html, SearchField, TextField, useS
import {api, useApp, useFetch} from '../api.js';
import {DataTable, Pager} from '../components/DataTable.js';
import {FormDialog} from '../components/FormDialog.js';
import {Cause, LevelTag, Loading, Section, Select, StatusTag} from '../components/ui.js';
import {Cause, LevelTag, Loading, Section, Select, SlaTag, StatusTag} from '../components/ui.js';
const PAGE_SIZE = 20;
@@ -60,6 +60,10 @@ export default function Outages() {
{key: 'root_cause', title: '判定根因', render: v => html`<${Cause} value=${v}/>`},
{key: 'level', title: '分级', render: v => html`<${LevelTag} value=${v}/>`},
{key: 'status', title: '状态', render: v => html`<${StatusTag} value=${v}/>`},
{key: 'sla', title: '响应时限', render: (v, r) => html`
<span title=${r.response_min !== '' ? `响应 ${r.response_min} 分钟,时限 ${r.limit_h} 小时` : `时限 ${r.limit_h} 小时`}>
<${SlaTag} value=${v}/></span>`},
{key: 'response_min', title: '响应(分)', sortable: true},
{key: 'affected_users', title: '影响用户', sortable: true},
{key: 'id', title: '操作', render: (_, r) => html`
<div className="row nowrap">
@@ -78,6 +82,7 @@ export default function Outages() {
<${Select} label="闭环状态" all="全部闭环状态" options=${meta.status} value=${draft.status} onChange=${setD('status')}/>
<${GlassCheckbox} label="仅超长" checked=${!!draft.long} onCheckedChange=${v => setD('long')(v ? 1 : '')}/>
<${GlassCheckbox} label="仅时长差错" checked=${!!draft.diff} onCheckedChange=${v => setD('diff')(v ? 1 : '')}/>
<${GlassCheckbox} label="仅超时未闭环" checked=${!!draft.overdue} onCheckedChange=${v => setD('overdue')(v ? 1 : '')}/>
<${GlassButton} variant="glassProminent" onClick=${search}>查询</${GlassButton}>
<span className="grow"></span>
${isAdmin && html`
@@ -151,6 +156,11 @@ function OutageDialog({row, onClose, onSaved}) {
<${Select} name="status" label="闭环状态" showLabel options=${meta.status} value=${row.status || '待处理'}/>
<${TextField} name="handler" label="处理人" defaultValue=${row.handler}/>
<${TextField} className="full" name="remark" label="处理说明" multiline rows=${2} defaultValue=${row.remark}/>
${!isNew && html`<div className="note full">
接单时间:${row.handled_at || '—'} 闭环时间:${row.closed_at || '—'}
 响应时限:${row.limit_h} 小时(${row.level}) 判定:${row.sla}<br/>
状态改为“处理中 / 已闭环”时自动记录接单时间,改为“已闭环”时自动记录闭环时间。
</div>`}
${row.advice && html`<div className="note full"><b>系统判定根因:${row.root_cause}</b>(${row.evidence})<br/>${row.advice}</div>`}
</${FormDialog}>`;
}
+21
View File
@@ -18,6 +18,7 @@ export default function Sites() {
const [keyword, setKeyword] = useState('');
const [editScene, setEditScene] = useState(null);
const [editSite, setEditSite] = useState(null);
const [editType, setEditType] = useState(null);
if (!data) return html`<${Loading}/>`;
@@ -62,6 +63,17 @@ export default function Sites() {
<${DataTable} rowKey="scene" rows=${data.scenes} columns=${[{key: 'scene', title: '场景'}, ...SCENE_FIELDS, ...editColumn(setEditScene)]}/>
</${Section}>
<${Section} span=${5} title="场景 × 站型 站点数量"><${EChart} option=${mixChart}/></${Section}>
<${Section} span=${5} title="站型阈值系数" hint="站点实际阈值 = 场景阈值 × 站型系数">
<${DataTable} rowKey="site_type" rows=${data.site_types} columns=${[
{key: 'site_type', title: '站型'}, {key: 'long_factor', title: '超长时长系数'},
{key: 'freq_factor', title: '高频次数系数'}, ...editColumn(setEditType)]}/>
</${Section}>
<${Section} span=${7} title="场景 × 站型 实际阈值" hint="超长阈值(分钟) / 高频阈值(次/月)">
<${DataTable} rowKey="scene" rows=${data.scenes} columns=${[
{key: 'scene', title: '场景'},
...data.site_types.map(t => ({key: t.site_type, title: t.site_type, render: (_, s) =>
`${+(s.long_min * t.long_factor).toFixed(1)} / ${+(s.freq_count * t.freq_factor).toFixed(1)}`}))]}/>
</${Section}>
<${Section} title="站点场景标签与站型分级" extra=${siteFilters}>
<${DataTable} rowKey="ne_id" rows=${sites} columns=${[
{key: 'ne_id', title: '基站编号'}, {key: 'site_name', title: '站点名称'}, {key: 'vendor', title: '厂家'},
@@ -77,6 +89,15 @@ export default function Sites() {
<${TextField} key=${f.key} name=${f.key} label=${f.title} type="number" step=${f.step || '1'} min="0" required
defaultValue=${editScene[f.key]}/>`)}
</${FormDialog}>`}
${editType && html`
<${FormDialog} onClose=${() => setEditType(null)} title=${`站型系数 · ${editType.site_type}`}
description="系数 < 1 表示从严,> 1 表示放宽;保存后立即生效"
onSubmit=${d => save(`/api/site_types/${editType.site_type}`, d, '站型系数已更新')}>
<${TextField} name="long_factor" label="超长时长系数" type="number" step="0.05" min="0.1" max="10" required
defaultValue=${editType.long_factor}/>
<${TextField} name="freq_factor" label="高频次数系数" type="number" step="0.05" min="0.1" max="10" required
defaultValue=${editType.freq_factor}/>
</${FormDialog}>`}
${editSite && html`
<${FormDialog} onClose=${() => setEditSite(null)} title="编辑站点分级" description=${`${editSite.ne_id} · ${editSite.site_name}`}
onSubmit=${d => save(`/api/sites/${editSite.ne_id}`, d, '站点已更新')}>
+1
View File
@@ -44,6 +44,7 @@ def use_db(name):
conn.execute('INSERT INTO scenes VALUES(?,?,?,?,?)', (scene, *values))
conn.execute("INSERT INTO users(username, password, role, created_at) VALUES('admin', ?, 'admin', '')",
(generate_password_hash('admin123'),)) # 测试库的接口测试账号
core.migrate() # 与正式启动一致:补站型系数默认值
def load(name, sites, alarms, outages, calibrate_until=None):
+115
View File
@@ -0,0 +1,115 @@
"""接口与业务流程测试:登录与权限、导入校验、闭环时限、站型阈值、治理成效、边界情况。
运行:python tests/test_api.py
"""
import io
import pandas as pd
from harness import check, core, finish, load, sample_data # 先导入 harness:它把数据库指向 tests/_work
import app as webapp # noqa: E402
load('api', *sample_data())
core.execute("INSERT INTO users(username, password, role, created_at) VALUES('user', ?, 'user', '')",
(webapp.generate_password_hash('user123'),), changes_data=False)
admin = webapp.app.test_client()
user = webapp.app.test_client()
print('== 1. 登录与权限')
check('错误密码登录失败', admin.post('/login', json={'username': 'admin', 'password': 'x'}).status_code == 400)
check('管理员登录', admin.post('/login', json={'username': 'admin', 'password': 'admin123'}).status_code == 200)
check('普通用户登录', user.post('/login', json={'username': 'user', 'password': 'user123'}).status_code == 200)
check('未登录访问接口返回 401', webapp.app.test_client().get('/api/dashboard').status_code == 401)
for method, url in [('get', '/api/logs'), ('get', '/api/users'), ('post', '/api/analyze'),
('post', '/api/import/preview'), ('post', '/api/outages/batch'), ('put', '/api/site_types/宏站')]:
code = getattr(user, method)(url, json={}).status_code
check(f'普通用户 {method.upper()} {url} 被拒绝', code == 403, f'({code})')
check('普通用户可看看板', user.get('/api/dashboard').status_code == 200)
print('\n== 2. 导入模板校验(模板含 5 行故意写错的数据)')
template = admin.get('/api/template')
preview = admin.post('/api/import/preview', data={'file': (io.BytesIO(template.data), 'template.xlsx')},
content_type='multipart/form-data').get_json()
reasons = {e['row']: e['reason'] for e in preview['errors']}
check('合格 3 行、问题 5 行', (preview['ok'], preview['bad']) == (3, 5), f'({preview["ok"]} / {preview["bad"]})')
expected = {4: '恢复时间早于开始时间', 5: '基站编号缺失', 6: '恢复时间缺失或格式错误', 7: '重复记录', 8: '基站不在站点库中'}
for row, phrase in expected.items():
check(f'第 {row} 行:{phrase}', phrase in reasons.get(row, ''), f'({reasons.get(row)})')
check('上报时长差错 1 条(第 9 行 45 分 vs 实际 405 分)', preview['diff'] == 1)
before = core.query('SELECT COUNT(*) AS n FROM outages')[0]['n']
result = admin.post('/api/import/confirm', json={'token': preview['token']}).get_json()
after = core.query('SELECT COUNT(*) AS n FROM outages')[0]['n']
check('确认后入库 3 条', result['n'] == 3 and after - before == 3)
check('预览令牌只能用一次', admin.post('/api/import/confirm', json={'token': preview['token']}).status_code == 400)
print('\n== 3. 闭环流程与响应时限')
site = core.query('SELECT ne_id FROM sites LIMIT 1')[0]['ne_id']
new = admin.post('/api/outages', json={'ne_id': site, 'start_time': '2026-10-20 08:00', 'end_time': '2026-10-20 08:40',
'status': '待处理'}).get_json()
oid = new['id']
def row():
core.data_changed()
return core.full_frame().set_index('id').loc[oid]
r = row()
check('新增待处理:无接单 / 闭环时间', pd.isna(r['handled_at']) and pd.isna(r['closed_at']))
check('早已超过时限 → 超时未响应', r['sla'] == '超时未响应', f'({r["sla"]},时限 {r["limit_h"]} h)')
check('非法状态被拒绝', user.put(f'/api/outages/{oid}', json={'status': '随便'}).status_code == 400)
check('不存在的记录返回 404', user.put('/api/outages/99999999', json={'status': '处理中'}).status_code == 404)
user.put(f'/api/outages/{oid}', json={'status': '处理中', 'handler': '张工', 'remark': '已派单'})
r = row()
check('转处理中:自动记录接单时间', pd.notna(r['handled_at']) and pd.isna(r['closed_at']))
check('接单晚于时限 → 超时', r['sla'] == '超时', f'({r["sla"]})')
handled_first = r['handled_at']
user.put(f'/api/outages/{oid}', json={'status': '已闭环'})
r = row()
check('转已闭环:自动记录闭环时间,接单时间不变', pd.notna(r['closed_at']) and r['handled_at'] == handled_first)
user.put(f'/api/outages/{oid}', json={'status': '处理中'})
check('重新打开:清空闭环时间', pd.isna(row()['closed_at']))
ids = [x['id'] for x in core.query("SELECT id FROM outages WHERE status = '待处理' LIMIT 3")]
admin.post('/api/outages/batch', json={'ids': ids, 'action': 'status', 'status': '已闭环'})
rows = core.query(f'SELECT handled_at, closed_at FROM outages WHERE id IN ({",".join(map(str, ids))})')
check('批量闭环:都有接单与闭环时间', all(x['handled_at'] and x['closed_at'] for x in rows))
overdue = admin.get('/api/outages', query_string={'overdue': 1, 'size': 5}).get_json()
check('“仅超时未闭环”筛选只返回未闭环且超时的记录',
overdue['total'] > 0 and all(x['status'] != '已闭环' and x['sla'] in ('超时', '超时未响应') for x in overdue['rows']))
k = admin.get('/api/dashboard').get_json()['kpi']
check('看板含及时响应率 / 平均闭环时长 / 超时未闭环',
all(key in k for key in ('response_rate', 'avg_close_h', 'overdue_open')), f'({k["response_rate"]}%,'
f'{k["avg_close_h"]} h,{k["overdue_open"]} 条)')
print('\n== 4. 站型阈值系数')
core.data_changed()
long_before = int(core.full_frame().query("site_type == '室分'")['is_long'].sum())
check('系数越界被拒绝', admin.put('/api/site_types/室分', json={'long_factor': 0, 'freq_factor': 1}).status_code == 400)
admin.put('/api/site_types/室分', json={'long_factor': 0.5, 'freq_factor': 1})
core.data_changed()
frame = core.full_frame()
indoor = frame[frame['site_type'] == '室分']
check('室分系数 0.5:实际阈值 = 场景阈值 × 0.5', (indoor['long_min'] == indoor['scene_long_min'] * 0.5).all())
check('阈值从严后室分超长次数增加', int(indoor['is_long'].sum()) > long_before,
f'({long_before} → {int(indoor["is_long"].sum())})')
macro = frame[frame['site_type'] == '宏站']
check('宏站不受影响', (macro['long_min'] == macro['scene_long_min']).all())
print('\n== 5. 治理成效评估')
effect = admin.get('/api/effect', query_string={'split': '2026-06-01'}).get_json()
check('返回 8 项指标对比', len(effect['rows']) == 8)
check('问题站点改善 + 持平 + 恶化 = 问题站点数',
effect['improved'] + effect['flat'] + effect['worsened'] + sum(s['verdict'] == '—' for s in effect['sites'])
== len(effect['sites']), f'({len(effect["sites"])} 个)')
check('分界日期超出周期返回 400', admin.get('/api/effect', query_string={'split': '2030-01-01'}).status_code == 400)
check('默认分界日期可用', admin.get('/api/effect').status_code == 200)
print('\n== 6. 边界情况')
for url, params in [('/api/dashboard', {'month': '2030-01'}), ('/api/stats', {'month': '2030-01'}),
('/api/association', {'month': '2030-01'}), ('/api/sites/rank', {'site': '不存在的站'}),
('/api/export/stats', {'month': '2030-01'}), ('/api/outages', {'site': '不存在的站'})]:
code = admin.get(url, query_string=params).status_code
check(f'无数据筛选 {url}', code == 200, f'({code})')
finish()