Files
Gset/app.py
T
treeandClaude Opus 5.5 e9616af34d 修复 P0:根因判定、退服率口径、影响评估与告警关联量化
- 根因判定改为三级(衍生关系/时间窗/疑似)并带置信度;小区退服告警 ±2 分钟匹配;
  衍生告警按父告警归类;优先选随业务恢复清除的告警;时间窗按历史流水 95% 分位数标定
- 退服率按日历统计周期计算;站点数分母支持站名关键字;重复退服率除以全部站点;
  月均按统计周期自然月数;导出与看板同一口径
- 影响评估新增受影响用户·小时与 500 米邻站覆盖补偿
- 新增告警—退服关联量化(支持度/置信度/提升度)及 /api/association,根因页展示
- 新增 tests/(扰动数据集留出检验、指标口径检验)与 bench.py;旧库启动时自动迁移

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-18 14:43:34 +08:00

684 lines
30 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
"""5G 基站退服时长智能分析与故障闭环管控系统 —— Flask 入口。运行:python app.py 后访问 http://127.0.0.1:5000
前端为免构建的 React 单页应用(static/index.html + static/js/),由本文件直接托管,改完刷新浏览器即生效。
本文件只负责:登录与权限、接收请求参数、调用 core.py / importer.py、把结果转成 JSON 或 Excel。
接口分组(与下方代码顺序一致):
页面与认证 / /login /logout /healthz
看板与统计 /api/meta /api/dashboard /api/stats /api/confusion /api/association /api/sites/rank
退服流水 /api/outages(查询、新增、修改、删除、批量) /api/analyze
数据导入 /api/import/preview /api/import/confirm /api/template
站点与场景 /api/sites /api/scenes
导出与系统 /api/export/<报表> /api/logs /api/users
"""
import io
import os
import time
import uuid
from datetime import datetime
from functools import wraps
import pandas as pd
from flask import Flask, jsonify, redirect, request, send_file, send_from_directory, session
from werkzeug.security import check_password_hash, generate_password_hash
import core
import importer
from core import execute, log, query
STATIC = os.path.join(core.BASE, 'static')
app = Flask(__name__)
app.secret_key = os.environ.get('SECRET_KEY', 'outage-5g-nanning')
app.config['MAX_CONTENT_LENGTH'] = 32 * 1024 * 1024 # 上传文件最大 32 MB
app.config['SESSION_COOKIE_SECURE'] = os.environ.get('COOKIE_SECURE') == '1' # 线上启用 HTTPS 后设为 1
# 导入预览缓存:token -> (类型, 合格数据)。预览和确认是两次请求,中间的数据暂存在进程内存里,
# 所以线上 gunicorn 只能开 1 个进程(见 Online-sever/gunicorn.conf.py)。
PENDING = {}
# 可用作筛选条件的查询参数
FILTER_KEYS = ['scene', 'region', 'site_type', 'vendor', 'root_cause', 'status', 'site', 'cause_category', 'month',
'date_from', 'date_to']
# ================================================================ 权限检查
# 二十多个接口都要做同样的登录 / 管理员检查,用装饰器写一次,接口函数上标注即可一眼看出权限要求。
def login_required(fn):
@wraps(fn)
def wrapper(*args, **kwargs):
if 'user' not in session:
if request.path.startswith('/api'):
return jsonify(error='未登录'), 401
return redirect('/login')
return fn(*args, **kwargs)
return wrapper
def admin_required(fn):
@wraps(fn)
@login_required
def wrapper(*args, **kwargs):
if session.get('role') != 'admin':
return jsonify(error='权限不足,仅管理员可操作'), 403
return fn(*args, **kwargs)
return wrapper
def current_filters():
"""从查询参数中取出非空的筛选条件。"""
filters = {}
for key in FILTER_KEYS:
value = request.args.get(key, '').strip()
if value:
filters[key] = value
return filters
def to_records(df, columns):
"""DataFrame 转成前端用的字典列表,空值转为空字符串。"""
return df[columns].fillna('').to_dict('records')
@app.errorhandler(Exception)
def on_error(e):
"""所有未处理的异常都以 JSON 返回错误信息,前端统一弹出提示。"""
code = getattr(e, 'code', 500)
if not isinstance(code, int):
code = 500
message = getattr(e, 'description', None) or str(e)
return jsonify(error=message), code
# ================================================================ 页面与认证
def single_page():
"""登录页与主界面是同一个页面,前端根据 /api/meta 是否返回 401 决定显示哪个。"""
return send_from_directory(STATIC, 'index.html')
@app.route('/')
def index():
return single_page()
@app.route('/healthz')
def healthz():
"""健康检查:数据库可访问即返回 ok,供面板 / Docker 监控使用(无需登录)。"""
query('SELECT 1')
return jsonify(ok=True)
@app.route('/login', methods=['GET'])
def login_page():
return single_page()
@app.route('/login', methods=['POST'])
def login():
data = request.get_json()
users = query('SELECT * FROM users WHERE username=?', (data.get('username'),))
if not users or not check_password_hash(users[0]['password'], data.get('password', '')):
return jsonify(error='用户名或密码错误'), 400
user = users[0]
session.update(user=user['username'], role=user['role'])
log(user['username'], '登录')
return jsonify(ok=True)
@app.route('/logout')
def logout():
if 'user' in session:
log(session['user'], '注销')
session.clear()
return redirect('/login')
# ================================================================ 看板与统计
@app.route('/api/meta')
@login_required
def meta():
"""下拉选项、当前用户与数据概况。前端启动时请求一次。"""
months = [row['m'] for row in query('SELECT DISTINCT substr(start_time,1,7) AS m FROM outages ORDER BY m')]
regions = [row['d'] for row in query('SELECT DISTINCT district AS d FROM sites ORDER BY d')]
vendors = [row['v'] for row in query('SELECT DISTINCT vendor AS v FROM sites ORDER BY v')]
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=['待处理', '处理中', '已闭环'],
role=session['role'], user=session['user'], overview=overview)
@app.route('/api/dashboard')
@login_required
def dashboard():
started = time.time()
filters = current_filters()
df = core.frame(filters)
minutes, months = core.period(filters)
stats = core.site_stats(df, months)
# 月度趋势:次数与时长(小时)
trend = df.groupby('month').agg(n=('id', 'size'), h=('duration_min', 'sum')).reset_index()
trend['h'] = (trend['h'] / 60).round(1)
# 场景 × 月份 热力图:[场景, 月份, 小时]
heat = df.groupby(['scene', 'month'])['duration_min'].sum().div(60).round(1).reset_index()
# 根因占比:[根因, 次数]
pie = df['root_cause'].fillna('未分析').value_counts().reset_index().values.tolist()
# 0-23 点各时段退服次数
hours = df['start'].dt.hour.value_counts().sort_index().reindex(range(24), fill_value=0).tolist()
# 分场景对标:每个场景单独核算一遍考核指标
bench = []
for scene in core.SCENES:
scene_sites = core.site_count({**filters, 'scene': scene})
if scene_sites == 0:
continue
scene_kpi = core.kpis(df[df['scene'] == scene], scene_sites, minutes, months)
bench.append(dict(scene=scene, **scene_kpi))
return jsonify(
kpi=core.kpis(df, core.site_count(filters), minutes, months),
period=dict(days=round(minutes / 1440, 1), months=months),
elapsed=round(time.time() - started, 3),
rank=to_records(stats.head(15), ['site_name', 'scene', 'total_min', 'count']),
trend=trend.to_dict('records'),
pie=pie,
heat=heat.values.tolist(),
months=sorted(df['month'].unique().tolist()),
bench=bench,
levels=df['level'].value_counts().to_dict(),
status=df['status'].value_counts().to_dict(),
hours=hours,
)
STAT_DIMENSIONS = ['scene', 'region', 'site_type', 'vendor', 'month', 'root_cause', 'cause_category', 'cause_code',
'site_name', 'level']
@app.route('/api/stats')
@login_required
def stats():
"""按指定维度分组统计退服次数、时长、超长占比、影响用户等。"""
dimension = request.args.get('dim', 'scene')
if dimension not in STAT_DIMENSIONS:
return jsonify(error='不支持的维度'), 400
df = core.frame(current_filters())
grouped = df.groupby(dimension).agg(
count=('id', 'size'), total_min=('duration_min', 'sum'), avg_min=('duration_min', 'mean'),
max_min=('duration_min', 'max'), long_count=('is_long', 'sum'), users=('affected_users', 'sum'),
user_h=('user_hours', 'sum'), loss_gb=('loss_gb', 'sum'), sites=('site_name', 'nunique'),
).reset_index()
grouped['long_ratio'] = (grouped['long_count'] / grouped['count'] * 100).round(2)
grouped = grouped.round({'total_min': 1, 'avg_min': 1, 'loss_gb': 1, 'user_h': 1})
sort = request.args.get('sort', 'total_min')
if sort not in grouped.columns:
sort = 'total_min'
grouped = grouped.sort_values(sort, ascending=request.args.get('asc') == '1')
log(session['user'], '统计查询', f'维度={dimension} 条件={current_filters()}')
return jsonify(rows=grouped.rename(columns={dimension: 'key'}).to_dict('records'))
@app.route('/api/confusion')
@login_required
def confusion():
"""上报原因 × 系统判定根因 交叉表,对角线为判定一致,用于检验根因判定准确率。"""
df = core.frame(current_filters())
df = df[df['cause_category'].isin(core.CAUSES)]
matrix = pd.crosstab(df['cause_category'], df['root_cause'])
matrix = matrix.reindex(index=core.CAUSES, columns=core.CAUSES, fill_value=0)
# 按置信度分组的准确率:用来说明“高 / 中 / 低”置信度标签是否可信
by_confidence = []
for level in ['高', '中', '低']:
part = df[df['confidence'] == level]
if len(part):
by_confidence.append(dict(level=level, n=len(part),
acc=round((part['cause_category'] == part['root_cause']).mean() * 100, 2)))
return jsonify(causes=core.CAUSES, matrix=matrix.values.tolist(), by_confidence=by_confidence)
@app.route('/api/association')
@login_required
def association():
"""告警类别 → 退服 的关联强度(支持度、置信度、提升度)与当前使用的时间窗。"""
return jsonify(rows=core.association(current_filters()), windows=core.window_table())
@app.route('/api/sites/rank')
@login_required
def site_rank():
"""超长退服站点(kind=long)/ 高频重复站点(kind=repeat)清单,附处置建议。"""
filters = current_filters()
stats = core.site_stats(core.frame(filters), core.period(filters)[1])
kind = request.args.get('kind', 'long')
if kind == 'long':
stats = stats[stats['long']]
elif kind == 'repeat':
stats = stats[stats['repeat']]
stats = stats.copy()
stats['advice'] = [core.advice(cause, '重要') for cause in stats['top_cause']]
columns = ['ne_id', 'site_name', 'region', 'scene', 'site_type', 'count', 'total_min', 'avg_min', 'max_min',
'long_count', 'long_min', 'freq_count', 'top_cause', 'advice']
return jsonify(rows=to_records(stats, columns))
# ================================================================ 退服流水管理
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']
# 新增 / 管理员修改时写入的字段,顺序与 outage_values() 返回值一致
OUTAGE_EDIT_FIELDS = ['record_id', 'ne_id', 'cell_id', 'start_time', 'end_time', 'duration_min', 'cause_category',
'cause_detail', 'ticket_id', 'status', 'handler', 'remark']
@app.route('/api/outages')
@login_required
def outages():
"""退服流水分页查询。除通用筛选外,long=1 只看超长,diff=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']]
sort = request.args.get('sort', 'start_time')
if sort not in df.columns:
sort = 'start_time'
df = df.sort_values(sort, ascending=request.args.get('asc') == '1')
page = int(request.args.get('page', 1))
size = int(request.args.get('size', 20))
rows = df.iloc[(page - 1) * size: page * size].copy()
rows['advice'] = [core.advice(cause, level) for cause, level in zip(rows['root_cause'], rows['level'])]
if filters:
log(session['user'], '查询退服流水', str(filters))
return jsonify(total=len(df), rows=to_records(rows, OUTAGE_LIST_COLUMNS))
def outage_values(data):
"""校验新增 / 修改的表单,返回按 OUTAGE_EDIT_FIELDS 顺序排列的值。退服时长按起止时间计算。"""
start = pd.to_datetime(data['start_time'])
end = pd.to_datetime(data['end_time'])
if end < start:
raise ValueError('恢复时间早于开始时间')
if not query('SELECT 1 FROM sites WHERE ne_id=?', (data['ne_id'],)):
raise ValueError('基站不在站点库中')
values = {
'record_id': data.get('record_id', ''),
'ne_id': data['ne_id'],
'cell_id': data.get('cell_id', ''),
'start_time': start.strftime(core.TIME_FMT),
'end_time': end.strftime(core.TIME_FMT),
'duration_min': round((end - start).total_seconds() / 60, 1),
'cause_category': data.get('cause_category') or None,
'cause_detail': data.get('cause_detail', ''),
'ticket_id': data.get('ticket_id', ''),
'status': data.get('status') or '待处理',
'handler': data.get('handler', ''),
'remark': data.get('remark', ''),
}
return tuple(values[field] for field in OUTAGE_EDIT_FIELDS)
@app.route('/api/outages', methods=['POST'])
@admin_required
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()))
core.analyze_all([new_id])
log(session['user'], '新增退服记录', f'id={new_id}')
return jsonify(ok=True, id=new_id)
@app.route('/api/outages/<int:outage_id>', methods=['PUT'])
@login_required
def outage_update(outage_id):
"""
两种修改:
闭环处理:普通用户(或请求中没有 ne_id 时)只更新状态、处理人、处理说明;
完整修改:管理员修改全部字段,并重新做根因分析。
"""
data = request.get_json()
is_admin = session['role'] == 'admin'
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))
log(session['user'], '更新闭环进度', f"id={outage_id} -> {data.get('status')}")
return jsonify(ok=True)
assignments = ','.join(f'{field}=?' for field in OUTAGE_EDIT_FIELDS)
execute(f'UPDATE outages SET {assignments} WHERE id=?', outage_values(data) + (outage_id,))
core.analyze_all([outage_id])
log(session['user'], '修改退服记录', f'id={outage_id}')
return jsonify(ok=True)
@app.route('/api/outages/<int:outage_id>', methods=['DELETE'])
@login_required
def outage_delete(outage_id):
if session['role'] != 'admin':
return jsonify(error='权限不足,仅管理员可删除'), 403
execute('DELETE FROM outages WHERE id=?', (outage_id,))
log(session['user'], '删除退服记录', f'id={outage_id}')
return jsonify(ok=True)
@app.route('/api/outages/batch', methods=['POST'])
@admin_required
def outage_batch():
"""批量删除(action=delete)或批量修改闭环状态(其他 action)。"""
data = request.get_json()
ids = [int(i) for i in data.get('ids', [])]
if not ids:
return jsonify(error='未选择记录'), 400
placeholders = ','.join('?' * len(ids))
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)
log(session['user'], '批量维护', f"{data.get('action')} {len(ids)} 条")
return jsonify(ok=True, n=len(ids))
@app.route('/api/analyze', methods=['POST'])
@admin_required
def reanalyze():
"""先按历史流水重新标定时间窗,再对全部退服流水重新做根因分析(导入告警或流水后使用)。"""
started = time.time()
count = core.analyze_all()
accuracy = core.kpis(core.frame())['acc']
log(session['user'], '全量根因分析', f'{count} 条')
return jsonify(n=count, elapsed=round(time.time() - started, 3), acc=accuracy, windows=core.window_table())
# ================================================================ 数据导入
PREVIEW_ROWS = 50 # 预览时返回给前端的合格数据条数(工参为按基站汇总后的站点)
@app.route('/api/import/preview', methods=['POST'])
@admin_required
def import_preview():
"""
上传文件 → 自动识别类型并逐行校验 → 返回统计、问题行与前 50 条合格数据,合格数据暂存等待确认。
支持的文件类型见 importer.py。
"""
started = time.time()
upload = request.files['file']
df = importer.read_upload(upload.read(), upload.filename)
kind, label, good, errors = importer.validate(df)
token = uuid.uuid4().hex
PENDING[token] = (kind, good)
result = dict(token=token, kind=kind, label=label, total=len(df), ok=len(good), bad=len(errors),
errors=errors[:500], diff=0)
if kind == 'outage':
# 上报时长与系统按起止时间重算的时长相差超过 1 分钟的条数
reported = pd.to_numeric(good['reported_min'], errors='coerce')
result['diff'] = int(((reported - good['duration_min'].astype(float)).abs() > 1).sum())
if kind == 'alarm':
# 告警的基站在站点库中能找到的条数:找不到的告警可以入库,但不会参与本系统站点的根因分析
known_sites = {row['ne_id'] for row in query('SELECT ne_id FROM sites')}
result['matched'] = int(good['ne_id'].isin(known_sites).sum())
if kind == 'site':
result['added'] = int((good['action'] == '新增').sum())
result['updated'] = int((good['action'] == '更新').sum())
# 先把空值换成空字符串再转文本:JSON 里不能出现 NaN,否则浏览器无法解析
preview = good.head(PREVIEW_ROWS).fillna('').astype(str).replace({'None': '', 'nan': ''})
result['preview'] = preview.to_dict('records')
result['elapsed'] = round(time.time() - started, 3)
log(session['user'], '导入预览', f'{upload.filename}({label})共{len(df)}行,合格{len(good)},问题{len(errors)}')
return jsonify(result)
@app.route('/api/import/confirm', methods=['POST'])
@admin_required
def import_confirm():
"""把预览时暂存的合格数据入库。告警入库后对全部流水重新关联;流水入库后只分析新记录。"""
started = time.time()
token = request.get_json().get('token')
kind, good = PENDING.pop(token, (None, None))
if good is None or good.empty:
return jsonify(error='预览已失效或无合格数据'), 400
result = dict(kind=kind)
if kind == 'alarm':
count = core.save_alarms(good)
core.analyze_all()
description = f'告警 {count} 条'
elif kind == 'site':
added, updated = core.save_sites(good)
count = added + updated
result['added'] = added
result['updated'] = updated
description = f'站点 新增{added} 更新{updated}'
else:
new_ids = core.save_outages(good)
core.analyze_all(new_ids)
count = len(new_ids)
description = f'退服流水 {count} 条'
log(session['user'], '导入入库', description)
result['n'] = count
result['elapsed'] = round(time.time() - started, 3)
return jsonify(result)
@app.route('/api/template')
@login_required
def template():
"""退服流水导入模板:故意包含几行错误数据,用于演示校验功能。"""
ne = [row['ne_id'] for row in query('SELECT ne_id FROM sites LIMIT 6')]
rows = [
['TF9000001', ne[0], '2026-10-02 08:10:00', '2026-10-02 09:40:00', 90, '电源故障', '市电停电', 'PW01', '是'],
['TF9000002', ne[1], '2026-10-03 14:00:00', '2026-10-03 14:35:00', 35, '传输中断', '光模块损坏', 'TR02', '是'],
['TF9000003', ne[2], '2026-10-04 22:00:00', '2026-10-04 21:00:00', 60, '设备硬件', '单板复位', 'HW04', '否'], # 恢复早于开始
['TF9000004', '', '2026-10-05 10:00:00', '2026-10-05 11:00:00', 60, '', '', '', '否'], # 缺站号
['TF9000005', ne[3], '2026/10/06 7:30', '错误时间', '', '', '', '', '否'], # 时间格式错
['TF9000006', ne[1], '2026-10-03 14:00:00', '2026-10-03 14:35:00', 35, '传输中断', '光模块损坏', 'TR02', '是'], # 与第 2 行重复
['TF9000007', 'gNodeB-00000', '2026-10-07 10:00:00', '2026-10-07 10:20:00', 20, '其他', '原因待查', 'OT01', '否'], # 站号不存在
['TF9000008', ne[4], '2026-10-07 23:15:00', '2026-10-08 06:00:00', 45, '割接施工', '计划割接', 'OP01', '否'], # 上报时长错误
]
columns = ['record_id', 'ne_id', 'start_time', 'end_time', 'duration_min', 'cause_category', 'cause_detail',
'cause_code', 'closed']
return excel_response({'退服流水': pd.DataFrame(rows, columns=columns)}, '退服流水导入模板.xlsx')
# ================================================================ 站点与场景
@app.route('/api/sites')
@login_required
def sites():
return jsonify(rows=query('SELECT * FROM sites ORDER BY scene, district, site_name'),
scenes=query('SELECT * FROM scenes'))
@app.route('/api/sites/<site_id>', methods=['PUT'])
@admin_required
def site_edit(site_id):
data = request.get_json()
execute('UPDATE sites SET scene=?, site_type=?, district=? WHERE ne_id=?',
(data['scene'], data['site_type'], data['district'], site_id))
log(session['user'], '修改站点', f"{site_id} -> {data['scene']}/{data['site_type']}")
return jsonify(ok=True)
@app.route('/api/scenes/<scene>', methods=['PUT'])
@admin_required
def scene_edit(scene):
data = request.get_json()
execute('UPDATE scenes SET long_min=?, freq_count=?, users_per_cell=?, gb_per_cell_h=? WHERE scene=?',
(int(data['long_min']), int(data['freq_count']), int(data['users_per_cell']),
float(data['gb_per_cell_h']), scene))
log(session['user'], '修改场景阈值', f'{scene}: {data}')
return jsonify(ok=True)
# ================================================================ 报表导出
# 导出 Excel 时的中文列名
EXPORT_COLUMN_NAMES = {
'ne_id': '基站编号', 'site_name': '基站名称', 'region': '片区', 'vendor': '厂家', 'cell_id': '小区', 'scene': '场景',
'site_type': '站型', 'count': '退服次数', 'total_min': '累计退服时长(分)', 'avg_min': '平均退服时长(分)',
'max_min': '最长单次(分)', 'long_count': '超长次数', 'users': '受影响用户', 'top_cause': '主要根因',
'long_min': '超长阈值(分)', 'freq_count': '次数阈值(次/月)', 'start_time': '开始时间', 'end_time': '恢复时间',
'duration_min': '系统计算时长(分)', 'reported_min': '上报时长(分)', 'cause_category': '上报原因大类',
'cause_detail': '原因细项', 'cause_code': '原因码', 'ticket_id': '工单号', 'root_cause': '系统判定根因',
'evidence': '关联告警', 'level': '断站分级', 'status': '闭环状态', 'advice': '处置建议', 'record_id': '流水号',
'confidence': '判定置信度', 'user_h': '受影响用户·小时', 'user_hours': '受影响用户·小时',
}
def excel_response(sheets, filename):
"""把 {工作表名: DataFrame} 写成 Excel 并作为下载返回。列宽按内容长度自动调整(10~60)。"""
buffer = io.BytesIO()
with pd.ExcelWriter(buffer, engine='openpyxl') as writer:
for sheet_name, df in sheets.items():
df.to_excel(writer, sheet_name=sheet_name, index=False)
worksheet = writer.sheets[sheet_name]
for column_cells in worksheet.columns:
longest = 10
for cell in column_cells[:200]: # 只看前 200 行,避免大表导出变慢
longest = max(longest, len(str(cell.value or '')) * 1.6)
worksheet.column_dimensions[column_cells[0].column_letter].width = min(60, longest)
buffer.seek(0)
return send_file(buffer, as_attachment=True, download_name=filename)
@app.route('/api/export/<kind>')
@login_required
def export(kind):
"""三类报表:stats 退服统计表、long 超长退服站点清单、advice 根因处置建议清单。"""
filters = current_filters()
df = core.frame(filters)
minutes, months = core.period(filters)
stats = core.site_stats(df, months)
stamp = datetime.now().strftime('%Y%m%d%H%M')
if kind == 'stats':
k = core.kpis(df, core.site_count(filters), minutes, months) # 与看板同一口径
kpi_rows = [
['退服次数', k['count']], ['累计退服时长(小时)', k['total_h']], ['平均退服时长(分钟)', k['avg_min']],
['退服率(%)', 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']],
]
site_columns = ['ne_id', 'site_name', 'region', 'scene', 'site_type', 'count', 'total_min', 'avg_min',
'max_min', 'long_count', 'users', 'user_h', 'top_cause']
sheets = {
'考核指标': pd.DataFrame(kpi_rows, columns=['指标', '数值']),
'站点退服统计': stats[site_columns].rename(columns=EXPORT_COLUMN_NAMES),
}
title = '退服统计表'
elif kind == 'long':
stats = stats[stats['long'] | stats['repeat']].copy()
site_kinds = []
for is_long, is_repeat in zip(stats['long'], stats['repeat']):
if is_long and is_repeat:
site_kinds.append('超长+高频')
elif is_long:
site_kinds.append('超长退服')
else:
site_kinds.append('高频重复')
stats['类型'] = site_kinds
stats['advice'] = [core.advice(cause, '重要') for cause in stats['top_cause']]
columns = ['ne_id', 'site_name', 'region', 'scene', 'site_type', '类型', 'count', 'total_min', 'avg_min',
'long_min', 'freq_count', 'top_cause', 'advice']
sheets = {'超长与高频站点': stats[columns].rename(columns=EXPORT_COLUMN_NAMES)}
title = '超长退服站点清单'
elif kind == 'advice':
long_outages = df[df['is_long']].copy()
long_outages['advice'] = [core.advice(cause, level)
for cause, level in zip(long_outages['root_cause'], long_outages['level'])]
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']
sheets = {'根因处置建议': long_outages[columns].rename(columns=EXPORT_COLUMN_NAMES)}
title = '根因处置建议清单'
else:
return jsonify(error='未知报表'), 400
log(session['user'], '导出报表', title)
return excel_response(sheets, f'{title}_{stamp}.xlsx')
# ================================================================ 日志与用户
@app.route('/api/logs')
@admin_required
def logs():
return jsonify(rows=query('SELECT * FROM logs ORDER BY id DESC LIMIT 500'))
@app.route('/api/users', methods=['GET'])
@admin_required
def users_list():
return jsonify(rows=query('SELECT id, username, role, created_at FROM users'))
@app.route('/api/users', methods=['POST'])
@admin_required
def user_add():
data = request.get_json()
if query('SELECT 1 FROM users WHERE username=?', (data['username'],)):
return jsonify(error='用户名已存在'), 400
execute('INSERT INTO users(username,password,role,created_at) VALUES(?,?,?,?)',
(data['username'], generate_password_hash(data['password']), data.get('role', 'user'),
datetime.now().strftime(core.TIME_FMT)))
log(session['user'], '新增用户', data['username'])
return users_list()
@app.route('/api/users/<int:user_id>', methods=['PUT'])
@admin_required
def user_update(user_id):
"""重置密码或修改角色(请求里带哪个字段就改哪个)。密码以 PBKDF2-SHA256 加盐哈希保存。"""
users = query('SELECT username FROM users WHERE id=?', (user_id,))
if not users:
return jsonify(error='用户不存在'), 404
data = request.get_json()
if data.get('password'):
execute('UPDATE users SET password=? WHERE id=?', (generate_password_hash(data['password']), user_id))
if data.get('role'):
execute('UPDATE users SET role=? WHERE id=?', (data['role'], user_id))
log(session['user'], '修改用户', users[0]['username'])
return jsonify(ok=True)
@app.route('/api/users/<int:user_id>', methods=['DELETE'])
@admin_required
def user_delete(user_id):
users = query('SELECT username FROM users WHERE id=?', (user_id,))
if not users:
return jsonify(error='用户不存在'), 404
if users[0]['username'] == session['user']:
return jsonify(error='不能删除当前登录账号'), 400
execute('DELETE FROM users WHERE id=?', (user_id,))
log(session['user'], '删除用户', users[0]['username'])
return jsonify(ok=True)
core.init_db()
if __name__ == '__main__':
app.run(debug=True, port=int(os.environ.get('PORT', 5000)))