-
🤔 AI思考过程
+
🤔 AI思考过程
${data.thinking}
diff --git a/frontend/js/components/meituan-test.js b/frontend/js/components/meituan-test.js
new file mode 100644
index 0000000..413151a
--- /dev/null
+++ b/frontend/js/components/meituan-test.js
@@ -0,0 +1,424 @@
+// 美团基站测试组件
+Router.register('/test/meituan', async () => {
+ const currentUser = await API.me().catch(() => null);
+ if (!currentUser) {
+ window.location.href = './login.html';
+ return '';
+ }
+
+ return `
+
+
+
+
+
+
+
+
+
+ 服务器地址:
+ 180.163.74.83:8888
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ | 基站SN |
+ 连接时间 |
+ 状态 |
+ 最后心跳 |
+
+
+
+
+ | 暂无基站连接 |
+
+
+
+
+
+
+
+
+ `;
+});
+
+// 美团基站测试逻辑
+(() => {
+ let ws = null;
+ let connected = false;
+ let stations = new Map();
+ let isInitialized = false;
+
+ // 初始化
+ function initMeituanTest() {
+ if (isInitialized) return;
+
+ // 等待DOM渲染完成
+ const checkElements = () => {
+ const statusEl = document.getElementById('server-status');
+ if (statusEl) {
+ isInitialized = true;
+ setupEventListeners();
+ connectServer();
+ } else {
+ setTimeout(checkElements, 50);
+ }
+ };
+
+ checkElements();
+ }
+
+ function cleanup() {
+ isInitialized = false;
+ if (ws) {
+ ws.close();
+ ws = null;
+ }
+ connected = false;
+ }
+
+ // 监听路由变化
+ Router.onAfterEach(async (path) => {
+ if (path === '/test/meituan') {
+ initMeituanTest();
+ } else {
+ cleanup();
+ }
+ });
+
+ function setupEventListeners() {
+ // 连接服务器按钮
+ const connectBtn = document.getElementById('connect-server-btn');
+ if (connectBtn) {
+ connectBtn.addEventListener('click', connectServer);
+ }
+
+ // 刷新按钮
+ const refreshBtn = document.getElementById('refresh-btn');
+ if (refreshBtn) {
+ refreshBtn.addEventListener('click', () => {
+ if (ws) {
+ ws.close();
+ }
+ connectServer();
+ });
+ }
+
+ // 搜索基站
+ const searchInput = document.getElementById('search-station');
+ if (searchInput) {
+ searchInput.addEventListener('input', (e) => {
+ filterStations(e.target.value);
+ });
+ }
+
+ // 隐藏离线基站
+ const hideOfflineCheckbox = document.getElementById('hide-offline');
+ if (hideOfflineCheckbox) {
+ hideOfflineCheckbox.addEventListener('change', () => {
+ updateStationsList();
+ updateStationSelect();
+ });
+ }
+
+ // 自检按钮
+ const selfTestBtn = document.getElementById('self-test-btn');
+ if (selfTestBtn) {
+ selfTestBtn.addEventListener('click', startSelfTest);
+ }
+ }
+
+ function connectServer() {
+ const statusEl = document.getElementById('server-status');
+
+ // 更新状态为连接中
+ statusEl.innerHTML = '
连接中...';
+
+ // 获取服务器状态
+ fetch('/api/meituan/server-status')
+ .then(response => response.json())
+ .then(data => {
+ if (data.success) {
+ connected = true;
+ statusEl.innerHTML = `
${data.status === 'online' ? '在线' : '离线'}`;
+
+ // 获取基站列表
+ loadStations();
+
+ // 定期刷新
+ setInterval(() => {
+ loadStations();
+ }, 5000);
+ } else {
+ statusEl.innerHTML = '
连接失败';
+ }
+ })
+ .catch(error => {
+ console.error('连接失败:', error);
+ statusEl.innerHTML = '
连接失败';
+ });
+ }
+
+ function startLogPolling() {
+ // 轮询获取服务器日志
+ setInterval(async () => {
+ try {
+ // 这里应该调用实际的API获取日志
+ // const logs = await API.getServerLogs();
+ // updateLogs(logs);
+ } catch (e) {
+ console.error('获取日志失败:', e);
+ }
+ }, 2000);
+ }
+
+ function loadStations() {
+ fetch('/api/meituan/stations')
+ .then(response => response.json())
+ .then(data => {
+ if (data.success) {
+ stations.clear();
+ data.stations.forEach(station => {
+ stations.set(station.id, station);
+ });
+ updateStationsList();
+ updateStationSelect();
+ }
+ })
+ .catch(error => {
+ console.error('获取基站列表失败:', error);
+ });
+ }
+
+ function updateStationsList() {
+ const tbody = document.getElementById('stations-tbody');
+ const hideOffline = document.getElementById('hide-offline')?.checked ?? true;
+
+ if (!tbody) return;
+
+ // 过滤基站
+ let filteredStations = Array.from(stations.values());
+ if (hideOffline) {
+ filteredStations = filteredStations.filter(s => s.status === 'online');
+ }
+
+ if (filteredStations.length === 0) {
+ tbody.innerHTML = `
| ${hideOffline ? '暂无在线基站' : '暂无基站连接'} |
`;
+ return;
+ }
+
+ tbody.innerHTML = filteredStations.map(station => {
+ // 处理可能缺失的字段，适配实际数据格式
+ const lastSeen = station.last_seen || station.lastHeartbeat || new Date();
+ const connectTime = station.connect_time || station.connectTime || station.last_seen || new Date();
+ const ip = station.ip || '10.8.0.x'; // 基站通常在内网
+ const status = station.status || 'offline';
+
+ // 转换为Date对象
+ const connectTimeDate = connectTime instanceof Date ? connectTime : new Date(connectTime);
+ const lastSeenDate = lastSeen instanceof Date ? lastSeen : new Date(lastSeen);
+
+ return `
+
+ | ${station.id || '未知'} |
+ ${connectTimeDate.toLocaleString()} |
+ ${status === 'online' ? '在线' : '离线'} |
+ ${lastSeenDate.toLocaleString()} |
+
+ `;
+ }).join('');
+ }
+
+ function updateStationSelect() {
+ const select = document.getElementById('station-select');
+ const hideOffline = document.getElementById('hide-offline')?.checked ?? true;
+
+ if (!select) return;
+
+ // 保存当前选中的值
+ const currentValue = select.value;
+
+ // 过滤基站
+ let filteredStations = Array.from(stations.values());
+ if (hideOffline) {
+ filteredStations = filteredStations.filter(s => s.status === 'online');
+ }
+
+ select.innerHTML = '
' +
+ filteredStations.map(station => {
+ const ip = station.ip || '未知';
+ return `
`;
+ }).join('');
+
+ // 恢复之前选中的值（如果仍然存在）
+ if (currentValue && filteredStations.some(s => s.id === currentValue)) {
+ select.value = currentValue;
+ }
+ }
+
+ function filterStations(keyword) {
+ const rows = document.querySelectorAll('#stations-tbody tr');
+ rows.forEach(row => {
+ const text = row.textContent.toLowerCase();
+ row.style.display = text.includes(keyword.toLowerCase()) ? '' : 'none';
+ });
+ }
+
+ function startSelfTest() {
+ const stationId = document.getElementById('station-select').value;
+
+ if (!stationId) {
+ API.toast('请先选择基站', 'warning');
+ return;
+ }
+
+ // 显示自检卡片
+ const selfTestCard = document.getElementById('self-test-card');
+ selfTestCard.style.display = 'block';
+
+ // 重置状态
+ resetTestStatus();
+
+ // 更新状态
+ document.getElementById('test-status').textContent = `正在检测基站 ${stationId}...`;
+
+ // 模拟自检过程
+ simulateSelfTest(stationId);
+ }
+
+ function resetTestStatus() {
+ // 重置所有模块状态
+ ['g', 'd', 'h'].forEach(module => {
+ document.getElementById(`${module}-status`).textContent = '待检测';
+ document.getElementById(`${module}-status`).className = 'module-status';
+ document.getElementById(`${module}-result`).textContent = '';
+ document.getElementById(`${module}-result`).className = 'module-result';
+ });
+ }
+
+ function simulateSelfTest(stationId) {
+ // 模拟G模块检测
+ updateModuleStatus('g', 'testing', '检测中...');
+ setTimeout(() => {
+ const gResult = Math.random() > 0.2 ? '正常' : '异常';
+ updateModuleStatus('g', gResult === '正常' ? 'success' : 'error', gResult === '正常' ? '正常' : '异常');
+
+ // 模拟D模块检测
+ updateModuleStatus('d', 'testing', '检测中...');
+ setTimeout(() => {
+ const dResult = Math.random() > 0.2 ? '正常' : '异常';
+ updateModuleStatus('d', dResult === '正常' ? 'success' : 'error', dResult === '正常' ? '正常' : '异常');
+
+ // 模拟H模块检测
+ updateModuleStatus('h', 'testing', '检测中...');
+ setTimeout(() => {
+ const hResult = Math.random() > 0.2 ? '正常' : '异常';
+ updateModuleStatus('h', hResult === '正常' ? 'success' : 'error', hResult === '正常' ? '正常' : '异常');
+
+ // 更新总体状态
+ document.getElementById('test-status').textContent = '检测完成';
+ }, 2000);
+ }, 2000);
+ }, 2000);
+ }
+
+ function updateModuleStatus(module, status, result) {
+ const statusEl = document.getElementById(`${module}-status`);
+ const resultEl = document.getElementById(`${module}-result`);
+
+ statusEl.textContent = status === 'testing' ? '检测中' : (status === 'success' ? '正常' : '异常');
+ statusEl.className = `module-status ${status}`;
+
+ if (result) {
+ resultEl.textContent = result;
+ resultEl.className = `module-result ${status}`;
+ }
+ }
+})();
diff --git a/server/app.py b/server/app.py
index f60ba58..cdfd8b7 100644
--- a/server/app.py
+++ b/server/app.py
@@ -6192,6 +6192,193 @@ def add_cache_headers(response):
return response
+# ===== 基站测试API =====
+import subprocess
+import json
+from datetime import datetime, timedelta
+import re
+
+# 存储基站连接信息
+base_stations = {}
+
+@app.route('/api/meituan/server-status', methods=['GET'])
+def get_server_status():
+ """获取基站服务器状态"""
+ try:
+ # 检查服务器进程是否运行
+ result = subprocess.run(['systemctl', 'is-active', 'basestation-server'],
+ capture_output=True, text=True)
+ is_active = result.stdout.strip() == 'active'
+
+ # 获取服务器日志并解析基站状态
+ logs = []
+ try:
+ result = subprocess.run(['journalctl', '-u', 'basestation-server', '-n', '200', '--no-pager'],
+ capture_output=True, text=True)
+ if result.stdout:
+ logs = result.stdout.strip().split('\n')
+ # 解析日志更新基站状态
+ parse_station_logs(logs)
+ except:
+ pass
+
+ # 清理超过5分钟未活动的基站
+ cleanup_stations()
+
+ return jsonify({
+ 'success': True,
+ 'status': 'online' if is_active else 'offline',
+ 'logs': logs[-50:], # 只返回最近50条日志
+ 'station_count': len([s for s in base_stations.values() if s['status'] == 'online']) # 返回在线基站数
+ })
+ except Exception as e:
+ return jsonify({'success': False, 'error': str(e)})
+
+def parse_station_logs(logs):
+ """解析日志更新基站状态"""
+ now = datetime.now()
+
+ # 先解析所有注册和断开事件
+ for log in logs:
+ # 解析基站注册
+ if '基站' in log and '已注册' in log:
+ match = re.search(r'基站 (\w+) 已注册', log)
+ if match:
+ station_id = match.group(1)
+ # 提取时间戳
+ log_time = extract_log_time(log)
+ base_stations[station_id] = {
+ 'id': station_id,
+ 'status': 'online',
+ 'last_seen': log_time,
+ 'connect_time': log_time
+ }
+
+ # 解析基站断开
+ elif '基站' in log and '已断开' in log:
+ match = re.search(r'基站 (\w+) 已断开', log)
+ if match:
+ station_id = match.group(1)
+ if station_id in base_stations:
+ base_stations[station_id]['status'] = 'offline'
+ base_stations[station_id]['last_seen'] = extract_log_time(log)
+
+ # 然后处理心跳 - 假设最近的基站仍然在线
+ # 找到最后注册的基站
+ if base_stations:
+ # 按注册时间排序，最近的在前
+ sorted_stations = sorted(base_stations.values(),
+ key=lambda x: x['connect_time'],
+ reverse=True)
+
+ # 检查最近是否有心跳
+ recent_time = now - timedelta(minutes=1) # 最近1分钟
+ has_recent_heartbeat = False
+ for log in logs:
+ if 'heartbeat' in log:
+ heartbeat_time = extract_log_time(log)
+ if heartbeat_time > recent_time:
+ has_recent_heartbeat = True
+ break
+
+ # 如果最近有心跳，标记最新的基站为在线
+ if has_recent_heartbeat and sorted_stations:
+ latest_station = sorted_stations[0]
+ base_stations[latest_station['id']]['last_seen'] = now
+ base_stations[latest_station['id']]['status'] = 'online'
+
+ # 其他基站标记为离线（假设只有一个基站会发送心跳）
+ for station in sorted_stations[1:]:
+ if now - station['last_seen'] > timedelta(minutes=1):
+ base_stations[station['id']]['status'] = 'offline'
+ else:
+ # 如果没有最近的心跳，所有基站都标记为离线
+ for station in base_stations.values():
+ if now - station['last_seen'] > timedelta(minutes=1):
+ station['status'] = 'offline'
+
+def extract_log_time(log_line):
+ """从日志行中提取时间戳"""
+ try:
+ # 日志格式：Jan 05 10:33:56 ...
+ time_str = ' '.join(log_line.split()[:3])
+ # 添加年份
+ current_year = datetime.now().year
+ time_with_year = f"{current_year} {time_str}"
+ return datetime.strptime(time_with_year, "%Y %b %d %H:%M:%S")
+ except:
+ return datetime.now()
+
+def cleanup_stations():
+ """清理超过5分钟未活动的基站"""
+ now = datetime.now()
+ to_remove = []
+
+ for station_id, station in base_stations.items():
+ # 如果基站超过2分钟没有活动，标记为离线
+ if now - station['last_seen'] > timedelta(minutes=2):
+ station['status'] = 'offline'
+
+ # 可选：完全移除超过1小时离线的基站
+ # for station_id, station in base_stations.items():
+ # if station['status'] == 'offline' and now - station['last_seen'] > timedelta(hours=1):
+ # to_remove.append(station_id)
+
+ for station_id in to_remove:
+ del base_stations[station_id]
+
+@app.route('/api/meituan/send-command', methods=['POST'])
+def send_station_command():
+ """向基站发送命令"""
+ try:
+ data = request.get_json()
+ station_id = data.get('station_id')
+ command = data.get('command')
+
+ if not station_id or not command:
+ return jsonify({'success': False, 'error': '参数不完整'})
+
+ # 这里需要连接到基站服务器发送命令
+ # 暂时返回模拟响应
+ return jsonify({
+ 'success': True,
+ 'message': f'命令已发送到基站 {station_id}',
+ 'command': command
+ })
+ except Exception as e:
+ return jsonify({'success': False, 'error': str(e)})
+
+@app.route('/api/meituan/stations', methods=['GET'])
+def get_stations():
+ """获取基站列表"""
+ try:
+ # 先更新基站状态（通过解析日志）
+ try:
+ result = subprocess.run(['journalctl', '-u', 'basestation-server', '-n', '200', '--no-pager'],
+ capture_output=True, text=True)
+ if result.stdout:
+ logs = result.stdout.strip().split('\n')
+ parse_station_logs(logs)
+ cleanup_stations()
+ except:
+ pass
+
+ # 转换时间格式为字符串
+ stations_list = []
+ for station in base_stations.values():
+ station_copy = station.copy()
+ station_copy['last_seen'] = station['last_seen'].strftime('%Y-%m-%d %H:%M:%S')
+ station_copy['connect_time'] = station['connect_time'].strftime('%Y-%m-%d %H:%M:%S')
+ stations_list.append(station_copy)
+
+ return jsonify({
+ 'success': True,
+ 'stations': stations_list
+ })
+ except Exception as e:
+ return jsonify({'success': False, 'error': str(e)})
+
+
if __name__ == '__main__':
print("🚀 启动服务器（已启用静态资源缓存）...")
app.run(host='0.0.0.0', port=int(os.environ.get('PORT', '5000')), threaded=True)
diff --git a/test-meituan-api.html b/test-meituan-api.html
new file mode 100644
index 0000000..5bfee9d
--- /dev/null
+++ b/test-meituan-api.html
@@ -0,0 +1,145 @@
+
+
+
+
+
美团基站测试 - API调试
+
+
+
+
美团基站测试 - API调试
+
+
+
服务器状态
+
+
点击按钮检查
+
服务器日志：
+
+
+
+
+
基站列表
+
+
点击按钮加载
+
+
+
+
+
+
+