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 0e070a64fe
13 files changed
+6540 -6043

No files matched your search

+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 '恶化'