- 闭环状态流转自动记录接单/闭环时间,状态值校验;按断站分级判定响应时限 (及时/超时/超时未响应/未到期/无记录),新增及时响应率、平均闭环时长、超时未闭环指标与筛选 - 新增治理成效评估 /api/effect:分界日期前后指标对比与问题站点逐站改善判定 - 新增站型阈值系数(实际阈值 = 场景阈值 × 站型系数)及配置接口与页面 - 样例数据新增接单/闭环时间(独立随机数,原字段不变),导入支持并校验 - 新增 tests/test_api.py(权限、导入模板、闭环流程、站型系数、成效评估、无数据边界) - 修复:新流水无告警匹配时根因分析报错;空筛选时超长站点清单返回 500 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
738 lines
33 KiB
Python
738 lines
33 KiB
Python
"""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/effect
|
||
退服流水 /api/outages(查询、新增、修改、删除、批量) /api/analyze
|
||
数据导入 /api/import/preview /api/import/confirm /api/template
|
||
站点与场景 /api/sites /api/scenes /api/site_types
|
||
导出与系统 /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=core.STATUSES,
|
||
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/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():
|
||
"""超长退服站点(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',
|
||
'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',
|
||
'cause_detail', 'ticket_id', 'status', 'handler', 'remark']
|
||
|
||
|
||
@app.route('/api/outages')
|
||
@login_required
|
||
def outages():
|
||
"""退服流水分页查询。除通用筛选外,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:
|
||
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('基站不在站点库中')
|
||
if (data.get('status') or '待处理') not in core.STATUSES:
|
||
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))
|
||
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)
|
||
|
||
|
||
@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 query('SELECT 1 FROM outages WHERE id=?', (outage_id,)):
|
||
return jsonify(error='记录不存在'), 404
|
||
|
||
if not is_admin or 'ne_id' not in data:
|
||
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=?', 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)
|
||
|
||
|
||
@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:
|
||
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))
|
||
|
||
|
||
@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'), site_types=query('SELECT * FROM site_types'))
|
||
|
||
|
||
@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)
|
||
|
||
|
||
@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 = {
|
||
'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': '受影响用户·小时',
|
||
'handled_at': '接单时间', 'closed_at': '闭环时间', 'response_min': '响应时长(分)', 'limit_h': '响应时限(h)',
|
||
'sla': '时限判定',
|
||
}
|
||
|
||
|
||
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['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']
|
||
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',
|
||
'handled_at', 'response_min', 'limit_h', 'sla', 'closed_at', '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)))
|