移除event_smart模块

2、重复导入子计划时，增量被检设备并删除未检设备。

CLAUDE.md

@@ -1,215 +0,0 @@
-# CLAUDE.md
-
-This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
-
-## 项目概述
-
-CN_Gather是灿能公司的融合工具项目体，专门用于电能质量设备检测的企业级应用系统。采用Spring Boot多模块Maven架构，以detection模块为核心的检测业务系统。
-
-## 项目架构
-
-### 核心模块结构
-- **entrance**: 应用入口模块，端口18092，整合所有其他模块
-- **detection**: 核心检测业务模块，电能质量设备检测的完整业务流程
-- **storage**: 数据存储模块，处理检测数据存储和谐波数据处理
-- **system**: 基础系统模块，提供字典管理、日志管理、配置管理等基础功能
-- **user**: 用户管理模块，处理认证授权和权限控制
-
-### 模块依赖关系
-```
-entrance (启动入口)
-├── system (基础服务层)
-├── user (认证授权层)
-├── detection (核心业务层) → 依赖 system, storage
-└── storage (数据存储层) → 依赖 system
-```
-
-## 常用开发命令
-
-### 构建和打包
-```bash
-# 编译整个项目
-mvn clean compile
-
-# 打包所有模块
-mvn clean package
-
-# 跳过测试打包
-mvn clean package -DskipTests
-
-# 安装到本地仓库
-mvn clean install
-```
-
-### 运行应用
-```bash
-# 运行主入口应用 (端口18092)
-cd entrance
-mvn spring-boot:run
-
-# 运行事件智能模块 (独立应用)
-cd event_smart  
-mvn spring-boot:run
-```
-
-### 测试
-```bash
-# 运行所有测试
-mvn test
-
-# 运行特定模块测试
-cd detection
-mvn test
-```
-
-## 技术栈
-
-### 核心框架
-- **Spring Boot**: 2.3.12.RELEASE
-- **MyBatis Plus**: 数据持久层框架
-- **Maven**: 项目构建管理
-- **Java**: 1.8
-
-### 数据库
-- **MySQL**: 主数据库 (192.168.1.24:13306/pqs9100)
-- **Oracle**: event_smart模块使用
-- **Druid**: 数据库连接池
-
-### 通信技术
-- **Netty**: Socket通信 (端口61000设备, 62000源)
-- **WebSocket**: 实时数据推送 (端口7777)
-- **RestTemplate**: HTTP客户端通信
-
-### 其他关键技术
-- **Apache POI + docx4j**: Word文档报告生成
-- **FastJSON**: JSON数据处理
-- **Spring Security + JWT**: 安全认证 (event_smart模块)
-- **Redis**: 缓存服务 (event_smart模块)
-
-## 关键配置
-
-### 数据库配置
-- 数据库URL: `jdbc:mysql://192.168.1.24:13306/pqs9100`
-- MyBatis映射文件位置: `classpath*:com/njcn/**/mapping/*.xml`
-- 主键生成策略: `assign_uuid`
-
-### Socket通信配置
-- 源设备Socket: 127.0.0.1:62000
-- 被检设备Socket: 127.0.0.1:61000
-- WebSocket端口: 7777
-
-### 文件路径配置
-- 日志目录: `D:\logs`
-- 报告模板目录: `D:\template`
-- 报告输出目录: `D:\report`
-- Word模板位置: `entrance/src/main/resources/model/`
-
-## detection模块核心架构
-
-### 子模块功能划分
-- **device**: 设备管理 - PqDev(被检设备)、PqStandardDev(标准设备)、PqDevSub(设备子表)
-- **plan**: 检测计划管理 - AdPlan(检测计划)、AdPlanSource(计划源)、AdPlanStandardDev(计划标准设备)
-- **script**: 检测脚本管理 - PqScript(检测脚本)、PqScriptDtls(脚本详情)、PqScriptCheckData(检测数据)
-- **source**: 程控源管理 - PqSource(程控源设备)
-- **err**: 误差体系管理 - PqErrSys(误差体系)、PqErrSysDtls(误差详情)
-- **report**: 报告生成管理 - PqReport(报告模板)，支持Word模板处理
-- **monitor**: 监测管理 - PqMonitor(监测点管理)
-- **icd**: ICD路径管理 - PqIcdPath(通信配置)
-- **result**: 结果管理 - 检测结果查询和数据展示
-- **type**: 设备类型管理 - DevType(设备类型字典)
-
-### 核心检测流程 (PreDetectionController)
-```java
-// 主要检测接口
-@PostMapping("/startPreTest")         // 检测通用入口
-@PostMapping("/ytxCheckSimulate")     // 源通讯校验
-@PostMapping("/startSimulateTest")    // 启动程控源检测
-@PostMapping("/coefficientCheck")     // 系数校验
-@PostMapping("/startContrastTest")    // 比对检测
-@PostMapping("/devPhaseSequence")     // 设备相序检测
-```
-
-### Socket通信架构
-- **SocketManager**: Socket会话管理，存储userId与Channel映射
-- **WebServiceManager**: WebSocket服务管理，实时数据推送
-- **通信处理器**:
-  - SocketSourceResponseService: 程控源响应处理
-  - SocketDevResponseService: 设备响应处理
-  - SocketContrastResponseService: 比对检测响应处理
-- **通信工具**:
-  - CnSocketUtil: Socket连接工具
-  - FormalTestManager: 正式检测管理
-  - XiNumberManager: 系数管理
-
-### 暂态检测参数
-- 暂态前时间: 2秒
-- 写入时间: 0.001秒
-- 写出时间: 0.001秒  
-- 暂态后时间: 3秒
-
-### 闪变参数
-- 波形类型: CPM/SQU
-- 占空比: 50%
-
-## 开发注意事项
-
-### detection模块包结构
-```
-detection/
-├── controller/          # 控制层 - PreDetectionController
-├── handler/            # Socket响应处理器
-├── service/            # 业务逻辑层
-│   └── impl/          # 服务实现
-├── util/              # 工具类层
-│   ├── business/      # 业务工具 - DetectionCommunicateUtil
-│   └── socket/        # Socket通信工具
-├── pojo/              # 数据模型层
-│   ├── constant/      # 常量 - DetectionCommunicateConstant
-│   ├── dto/          # 数据传输对象
-│   ├── enums/        # 枚举 - DetectionCodeEnum等
-│   ├── param/        # 请求参数
-│   ├── po/           # 持久化对象
-│   └── vo/           # 视图对象 - DetectionData等
-└── [子模块]/          # device、plan、script等子模块
-    ├── controller/    # 子模块控制器
-    ├── service/       # 子模块服务
-    ├── mapper/        # 数据访问层
-    │   └── mapping/   # MyBatis映射文件
-    └── pojo/         # 子模块数据对象
-```
-
-### 检测数据处理机制
-- **任意值**: 取第一个满足条件的数据
-- **部分值**: 去除最大最小值后取值  
-- **所有值**: 要求所有数据都合格
-- **CP95值**: 取95%分位数
-- **平均值**: 取算术平均值
-
-### 检测项目类型
-- **频率**: FREQ
-- **电压**: V_RELATIVE(相对值)/V_ABSOLUTELY(绝对值)
-- **电流**: I_RELATIVE/I_ABSOLUTELY
-- **谐波**: HV/HI (2-50次谐波)
-- **间谐波**: HSV/HSI
-- **不平衡度**: IMBV/IMBA (三相不平衡)
-- **闪变**: F (PST)
-- **暂态**: VOLTAGE_MAG/VOLTAGE_DUR
-
-### 检测模式
-- **数字式检测**: 数字接口通信
-- **模拟式检测**: 模拟信号输出
-- **比对式检测**: 多台设备比对
-
-### 报告生成机制
-- **模板处理**: 使用POI和docx4j处理Word文档
-- **模板位置**: `entrance/src/main/resources/model/`
-- **支持模板**: NPQS-580、PQV-700、njcn_882系列等
-- **功能**: 书签替换、表格填充、文档合并
-- **云端上传**: 支持FTP批量上传报告
-
-### 依赖组件
-项目使用灿能公司自研组件:
-- `njcn-common`: 通用工具包
-- `mybatis-plus`: MyBatis增强包  
-- `spingboot2.3.12`: Spring Boot定制包
-- `RestTemplate-plugin`: HTTP客户端插件

Gitea本地协作开发服务器配置指南.md

@@ -1,238 +0,0 @@
-# Gitea本地协作开发服务器配置指南
-
-## 概述
-
-本文档说明如何将本地安装的Gitea配置为团队协作开发服务器，替代原有的物理服务器环境。
-
-## 1. 网络配置
-
-### 1.1 确认本机IP地址
-```bash
-# Windows系统
-ipconfig
-# 查找本机局域网IP地址，通常形如 192.168.x.x 或 10.x.x.x
-```
-
-### 1.2 配置Gitea服务地址
-编辑Gitea配置文件 `app.ini`：
-
-```ini
-[server]
-# 将localhost改为本机IP地址，确保同事可以访问
-HTTP_ADDR = 0.0.0.0
-HTTP_PORT = 3000
-# 外部访问URL，替换为你的实际IP
-ROOT_URL = http://192.168.x.x:3000/
-```
-
-### 1.3 防火墙配置
-确保Windows防火墙允许Gitea端口通信：
-
-```bash
-# 打开Windows防火墙入站规则
-# 添加端口3000的TCP入站规则
-```
-
-或在Windows防火墙中：
-- 控制面板 → 系统和安全 → Windows Defender防火墙 → 高级设置
-- 入站规则 → 新建规则 → 端口 → TCP → 特定本地端口: 3000
-
-## 2. Gitea服务配置
-
-### 2.1 启动Gitea服务
-```bash
-# 进入Gitea安装目录
-cd C:\gitea  # 或你的安装路径
-gitea.exe web
-```
-
-### 2.2 配置为Windows服务（推荐）
-创建Windows服务确保开机自启：
-
-1. 下载NSSM (Non-Sucking Service Manager)
-2. 以管理员身份运行命令提示符：
-```bash
-nssm install Gitea
-# 在弹出界面中配置：
-# Path: C:\gitea\gitea.exe
-# Arguments: web
-# Working directory: C:\gitea
-```
-
-3. 启动服务：
-```bash
-net start Gitea
-```
-
-### 2.3 数据库配置优化
-如果使用SQLite（默认），确保数据文件路径正确：
-```ini
-[database]
-DB_TYPE = sqlite3
-PATH = data/gitea.db
-```
-
-如果需要更好性能，考虑配置MySQL：
-```ini
-[database]
-DB_TYPE = mysql
-HOST = 127.0.0.1:3306
-NAME = gitea
-USER = gitea
-PASSWD = your_password
-```
-
-## 3. 同事访问配置
-
-### 3.1 提供访问地址
-向同事提供访问地址：
-```
-http://你的IP地址:3000
-例如: http://192.168.1.100:3000
-```
-
-### 3.2 用户账号管理
-1. 访问管理界面创建用户账号
-2. 或开启用户自注册：
-```ini
-[service]
-DISABLE_REGISTRATION = false
-REQUIRE_SIGNIN_VIEW = false
-```
-
-### 3.3 权限配置
-为协作项目设置适当权限：
-- 项目所有者：完全控制权限
-- 协作者：推送/拉取权限
-- 读者：仅读取权限
-
-## 4. 代码仓库迁移
-
-### 4.1 从原服务器迁移仓库
-如果原服务器数据可恢复：
-```bash
-# 在原服务器或备份中找到Git裸仓库
-# 复制到新Gitea的repositories目录
-# 通常位于 gitea-repositories/用户名/仓库名.git
-```
-
-### 4.2 重新创建仓库
-如果需要重新创建：
-1. 在Gitea界面创建新仓库
-2. 本地添加新的远程地址：
-```bash
-git remote remove origin
-git remote add origin http://你的IP:3000/用户名/仓库名.git
-git push -u origin master
-```
-
-## 5. 开发工作流配置
-
-### 5.1 分支保护规则
-为主要分支设置保护规则：
-- 设置 → 分支 → 分支保护规则
-- 保护master分支，要求代码审查
-
-### 5.2 Webhook配置
-如果需要CI/CD集成：
-```
-设置 → Webhooks → 添加Webhook
-配置自动构建触发器
-```
-
-## 6. 备份策略
-
-### 6.1 定期备份
-```bash
-# 备份Gitea数据目录
-# 包括：repositories/, data/, log/, custom/
-robocopy "C:\gitea" "D:\backup\gitea" /MIR /Z /R:3 /W:10
-```
-
-### 6.2 自动备份脚本
-创建批处理文件实现定期备份：
-```batch
-@echo off
-set BACKUP_DIR=D:\backup\gitea_%date:~0,4%%date:~5,2%%date:~8,2%
-robocopy "C:\gitea" "%BACKUP_DIR%" /MIR /Z /R:3 /W:10
-echo Backup completed to %BACKUP_DIR%
-```
-
-## 7. 常见问题排查
-
-### 7.1 访问问题
-- 检查防火墙设置
-- 确认IP地址和端口正确
-- 验证Gitea服务是否正常运行
-
-### 7.2 权限问题
-- 检查用户账号状态
-- 确认仓库权限设置
-- 验证SSH密钥配置（如使用SSH）
-
-### 7.3 性能优化
-```ini
-[server]
-# 调整并发连接数
-HTTP_ADDR = 0.0.0.0
-HTTP_PORT = 3000
-
-[database]
-# 数据库连接池配置
-MAX_IDLE_CONNS = 30
-MAX_OPEN_CONNS = 300
-```
-
-## 8. 安全建议
-
-1. **网络安全**：
-   - 仅在受信任的局域网环境中开放
-   - 考虑使用VPN访问
-   - 定期更新Gitea版本
-
-2. **访问控制**：
-   - 禁用不必要的公开注册
-   - 使用强密码策略
-   - 启用双因子认证
-
-3. **数据安全**：
-   - 定期备份重要数据
-   - 监控异常访问
-   - 记录操作日志
-
-## 9. 同事操作指南
-
-### 9.1 首次设置
-```bash
-# 克隆仓库
-git clone http://你的IP:3000/用户名/CN_Gather.git
-
-# 配置用户信息
-git config user.name "姓名"
-git config user.email "邮箱"
-```
-
-### 9.2 日常协作
-```bash
-# 拉取最新代码
-git pull origin master
-
-# 创建功能分支
-git checkout -b feature/新功能
-
-# 提交更改
-git add .
-git commit -m "描述信息"
-git push origin feature/新功能
-
-# 在Gitea界面创建Pull Request
-```
-
----
-
-**联系信息**：
-- Gitea服务地址：http://你的IP:3000
-- 管理员：[你的联系方式]
-- 紧急联系：[备用联系方式]
-
-**注意**：请确保定期备份重要代码，避免数据丢失。

detection/src/main/java/com/njcn/gather/detection/handler/SocketDevResponseService.java

@@ -849,7 +849,7 @@ public class SocketDevResponseService {
                     boolean isContinue = true;
                     List<String> descList = icdCheckData.getResultData().stream().map(
                             obj -> {
-                                if (DetectionCodeEnum.MAG.getCode().equals(obj.getDesc()) || DetectionCodeEnum.DUR.getCode().equals(obj.getDesc())) {
+                                if (DetectionCodeEnum.MAG.getCode().equals(obj.getDesc()) || DetectionCodeEnum.DUR.getCode().equals(obj.getDesc()) || DetectionCodeEnum.PST.getCode().equals(obj.getDesc())) {
                                     return DetectionCodeEnum.AVG_PREFIX.getCode() + obj.getDesc();
                                 } else {
                                     return DetectionCodeEnum.REAL_PREFIX.getCode() + obj.getDesc();

detection/src/main/java/com/njcn/gather/detection/pojo/enums/DetectionCodeEnum.java

@@ -50,7 +50,10 @@ public enum DetectionCodeEnum {
     DELTA("Delta", "角型接线"),
 
     REAL_PREFIX("real$", "实时数据前缀"),
-    AVG_PREFIX("avg$", "统计数据前缀");
+    CP_95_PREFIX("cp95$", "分钟统计-CP95值数据前缀"),
+    MAX_PREFIX("max$", "分钟统计-最大值数据前缀"),
+    MIN_PREFIX("min$", "分钟统计-最小值数据前缀"),
+    AVG_PREFIX("avg$", "分钟统计-平均值数据前缀");
 
     private final String code;
     private final String message;

detection/src/main/java/com/njcn/gather/detection/pojo/enums/SourceOperateCodeEnum.java

@@ -52,7 +52,7 @@ public enum SourceOperateCodeEnum {
     YJC_MXYZXJY("yjc_mxyzxjy", "模型一致性校验"),
     FORMAL_REAL("formal_real","正式检测"),
     RECORD_WAVE_STEP1("record_wave_step1","启动录波_step1"),
-    RECORD_WAVE_STEP2("record_wave_step2","启动录波_step2"),
+//    RECORD_WAVE_STEP2("record_wave_step2","启动录波_step2"),
 //    SIMULATE_REAL("simulate_real","模拟检测"),
     Coefficient_Check("Coefficient_Check","系数校验"),
     QUITE("quit","关闭设备通讯初始化"),

detection/src/main/java/com/njcn/gather/detection/pojo/enums/SourceResponseCodeEnum.java

@@ -42,7 +42,8 @@ public enum SourceResponseCodeEnum {
     FAIL(25002,"失败"),
     ALL_FAIL(25003,"校验失败"),
     RECEIVE_DATA_TIME_OUT(25004,"接收数据超时"),
-    REAL_DATA_CHECK_FAIL(25005,"实时数据校验失败")
+    REAL_DATA_CHECK_FAIL(25005,"实时数据校验失败"),
+    STATISTICS_DATA_CHECK_FAIL(25006,"统计数据校验失败")
 
 
 

detection/src/main/java/com/njcn/gather/detection/service/impl/DetectionServiceImpl.java

@@ -1508,9 +1508,10 @@ public class DetectionServiceImpl {
      * @param numMap              第几次检测 key为设备id_通道号，value为第几次检测
      * @param code                结果表code
      * @param waveNum             第几次录波
+     * @param dataSourceEnum      数据源类型
      * @return key为被检设备ip_通道号、value为是否合格（1合格 2不合格 4无法处理）
      */
-    public List<DevLineTestResult> processing(List<DevData> devDataList, List<DevData> standardDevDataList, Map<String, String> parsIp, Map<String, String> devIdMapComm, List<String> testItemCodeList, String errorSysId, DictDataEnum dataRule, Map<String, Integer> numMap, String code, Integer waveNum) {
+    public List<DevLineTestResult> processing(List<DevData> devDataList, List<DevData> standardDevDataList, Map<String, String> parsIp, Map<String, String> devIdMapComm, List<String> testItemCodeList, String errorSysId, DictDataEnum dataRule, Map<String, Integer> numMap, String code, Integer waveNum, DataSourceEnum dataSourceEnum) {
         Map<String, List<DevData>> devDataMap = devDataList.stream().collect(Collectors.groupingBy(obj -> obj.getId().split("_")[0]));
         Map<String, List<DevData>> standardDevDataMap = standardDevDataList.stream().collect(Collectors.groupingBy(DevData::getId));
 
@@ -1525,7 +1526,7 @@ public class DetectionServiceImpl {
             Map<String, List<Integer>> chnResultMap = new HashMap<>();
             devMonitorMap.forEach((devMoniterId, devData) -> {
                 String[] split = devMoniterId.split(CnSocketUtil.SPLIT_TAG);
-                Map<String, Integer> map = singleMonitorProcessing(devData, standardDevDataMap.get(parsIp.get(devMoniterId)), devIdMapComm, testItemCodeList, errorSysId, dataRule, numMap.get(devId + CnSocketUtil.SPLIT_TAG + split[1]), code, waveNum);
+                Map<String, Integer> map = singleMonitorProcessing(devData, standardDevDataMap.get(parsIp.get(devMoniterId)), devIdMapComm, testItemCodeList, errorSysId, dataRule, numMap.get(devId + CnSocketUtil.SPLIT_TAG + split[1]), code, waveNum, dataSourceEnum);
                 map.forEach((key, value) -> {
                     DevLineTestResult devLineTestResult = new DevLineTestResult();
                     devLineTestResult.setDeviceId(devId);
@@ -1560,9 +1561,10 @@ public class DetectionServiceImpl {
      * @param num                 第几次检测
      * @param code                结果表code
      * @param waveNum             第几次录波
+     * @param dataSourceEnum      数据源类型
      * @return
      */
-    private Map<String, Integer> singleMonitorProcessing(List<DevData> devDataList, List<DevData> standardDevDataList, Map<String, String> devIdMapComm, List<String> testItemCodeList, String errorSysId, DictDataEnum dataRule, Integer num, String code, Integer waveNum) {
+    private Map<String, Integer> singleMonitorProcessing(List<DevData> devDataList, List<DevData> standardDevDataList, Map<String, String> devIdMapComm, List<String> testItemCodeList, String errorSysId, DictDataEnum dataRule, Integer num, String code, Integer waveNum, DataSourceEnum dataSourceEnum) {
         Map<String, Integer> resultMap = new HashMap<>();
         if (CollUtil.isNotEmpty(devDataList) && CollUtil.isNotEmpty(standardDevDataList) && CollUtil.isNotEmpty(testItemCodeList)) {
             SysTestConfig oneConfig = sysTestConfigService.getOneConfig();
@@ -1603,19 +1605,19 @@ public class DetectionServiceImpl {
 
                 switch (anEnum) {
                     case FREQ:
-//                        if (ObjectUtil.isNull(waveNum)) {
+                        if (ObjectUtil.isNull(waveNum)) {
-//                            devDataList.stream().forEach(devData -> devData.getSqlData().stream().filter(sqlData -> sqlData.getDesc().equals(DetectionCodeEnum.FREQ.getCode())).findFirst().ifPresent(sqlData -> {
+                            devDataList.stream().forEach(devData -> devData.getSqlData().stream().filter(sqlData -> sqlData.getDesc().equals(DetectionCodeEnum.FREQ.getCode())).findFirst().ifPresent(sqlData -> {
-//                                DevData.SqlDataDTO.ListDTO listDTO = sqlData.getList();
+                                DevData.SqlDataDTO.ListDTO listDTO = sqlData.getList();
-//                                listDTO.setT(55.0);
+                                listDTO.setT(55.0);
-//                                sqlData.setList(listDTO);
+                                sqlData.setList(listDTO);
-//                            }));
+                            }));
-//                        }
+                        }
-                        resultMap.put(PowerIndexEnum.FREQ.getKey(), isQualified(devDataList, standardDevDataList, devIdMapComm, pqErrSysDtls, true, fHz, DetectionCodeEnum.FREQ.getCode(), dataRule, num, code, oneConfig.getScale(), waveNum));
+                        resultMap.put(PowerIndexEnum.FREQ.getKey(), isQualified(devDataList, standardDevDataList, devIdMapComm, pqErrSysDtls, true, fHz, DetectionCodeEnum.FREQ.getCode(), dataRule, num, code, oneConfig.getScale(), waveNum, dataSourceEnum));
                         break;
                     case VRMS:
                     case PVRMS:
                         // 如果是角型接法且存在角型接法的一些指标，则不进行使用角型接线的指标。反之，则使用相别的指标。
-                        resultMap.put(PowerIndexEnum.V.getKey(), isQualified(devDataList, standardDevDataList, devIdMapComm, pqErrSysDtls, true, fUn, (isDelta && isExitDelta ? DetectionCodeEnum.PVRMS.getCode() : DetectionCodeEnum.VRMS.getCode()), dataRule, num, code, oneConfig.getScale(), waveNum));
+                        resultMap.put(PowerIndexEnum.V.getKey(), isQualified(devDataList, standardDevDataList, devIdMapComm, pqErrSysDtls, true, fUn, (isDelta && isExitDelta ? DetectionCodeEnum.PVRMS.getCode() : DetectionCodeEnum.VRMS.getCode()), dataRule, num, code, oneConfig.getScale(), waveNum, dataSourceEnum));
                         break;
                     case IRMS:
 //                        if (ObjectUtil.isNotNull(waveNum) && (waveNum.equals(2) || waveNum.equals(5))) {
@@ -1626,30 +1628,33 @@ public class DetectionServiceImpl {
 //                                sqlData.setList(listDTO);
 //                            }));
 //                        }
-                        resultMap.put(PowerIndexEnum.I.getKey(), isQualified(devDataList, standardDevDataList, devIdMapComm, pqErrSysDtls, true, fIn, DetectionCodeEnum.IRMS.getCode(), dataRule, num, code, oneConfig.getScale(), waveNum));
+                        resultMap.put(PowerIndexEnum.I.getKey(), isQualified(devDataList, standardDevDataList, devIdMapComm, pqErrSysDtls, true, fIn, DetectionCodeEnum.IRMS.getCode(), dataRule, num, code, oneConfig.getScale(), waveNum, dataSourceEnum));
                         break;
                     case V_UNBAN:
-                        resultMap.put(PowerIndexEnum.IMBV.getKey(), isQualified(devDataList, standardDevDataList, devIdMapComm, pqErrSysDtls, false, fUn, DetectionCodeEnum.V_UNBAN.getCode(), dataRule, num, code, oneConfig.getScale(), waveNum));
+                        resultMap.put(PowerIndexEnum.IMBV.getKey(), isQualified(devDataList, standardDevDataList, devIdMapComm, pqErrSysDtls, false, fUn, DetectionCodeEnum.V_UNBAN.getCode(), dataRule, num, code, oneConfig.getScale(), waveNum, dataSourceEnum));
                         break;
                     case I_UNBAN:
-                        resultMap.put(PowerIndexEnum.IMBA.getKey(), isQualified(devDataList, standardDevDataList, devIdMapComm, pqErrSysDtls, false, fIn, DetectionCodeEnum.I_UNBAN.getCode(), dataRule, num, code, oneConfig.getScale(), waveNum));
+                        resultMap.put(PowerIndexEnum.IMBA.getKey(), isQualified(devDataList, standardDevDataList, devIdMapComm, pqErrSysDtls, false, fIn, DetectionCodeEnum.I_UNBAN.getCode(), dataRule, num, code, oneConfig.getScale(), waveNum, dataSourceEnum));
                         break;
                     case V2_50:
                     case PV2_50:
-                        resultMap.put(PowerIndexEnum.HV.getKey(), isHarmQualified(devDataList, standardDevDataList, devIdMapComm, pqErrSysDtls, U, fUn, HARMONIC_FLAG, isDelta && isExitDelta, dataRule, num, code, oneConfig.getScale(), waveNum));
+                        resultMap.put(PowerIndexEnum.HV.getKey(), isHarmQualified(devDataList, standardDevDataList, devIdMapComm, pqErrSysDtls, U, fUn, HARMONIC_FLAG, isDelta && isExitDelta, dataRule, num, code, oneConfig.getScale(), waveNum, dataSourceEnum));
                         break;
                     case I2_50:
-                        resultMap.put(PowerIndexEnum.HI.getKey(), isHarmQualified(devDataList, standardDevDataList, devIdMapComm, pqErrSysDtls, I, fIn, HARMONIC_FLAG, isDelta && isExitDelta, dataRule, num, code, oneConfig.getScale(), waveNum));
+                        resultMap.put(PowerIndexEnum.HI.getKey(), isHarmQualified(devDataList, standardDevDataList, devIdMapComm, pqErrSysDtls, I, fIn, HARMONIC_FLAG, isDelta && isExitDelta, dataRule, num, code, oneConfig.getScale(), waveNum, dataSourceEnum));
                         break;
                     case P2_50:
-                        resultMap.put(PowerIndexEnum.HP.getKey(), isHarmQualified(devDataList, standardDevDataList, devIdMapComm, pqErrSysDtls, HP, fUn * fIn, HARMONIC_FLAG, isDelta && isExitDelta, dataRule, num, code, oneConfig.getScale(), waveNum));
+                        resultMap.put(PowerIndexEnum.HP.getKey(), isHarmQualified(devDataList, standardDevDataList, devIdMapComm, pqErrSysDtls, HP, fUn * fIn, HARMONIC_FLAG, isDelta && isExitDelta, dataRule, num, code, oneConfig.getScale(), waveNum, dataSourceEnum));
                         break;
                     case SV_1_49:
                     case PSV_1_49:
-                        resultMap.put(PowerIndexEnum.HSV.getKey(), isHarmQualified(devDataList, standardDevDataList, devIdMapComm, pqErrSysDtls, U, fUn, INHARMONIC_FLAG, isDelta && isExitDelta, dataRule, num, code, oneConfig.getScale(), waveNum));
+                        resultMap.put(PowerIndexEnum.HSV.getKey(), isHarmQualified(devDataList, standardDevDataList, devIdMapComm, pqErrSysDtls, U, fUn, INHARMONIC_FLAG, isDelta && isExitDelta, dataRule, num, code, oneConfig.getScale(), waveNum, dataSourceEnum));
                         break;
                     case SI_1_49:
-                        resultMap.put(PowerIndexEnum.HSI.getKey(), isHarmQualified(devDataList, standardDevDataList, devIdMapComm, pqErrSysDtls, I, fIn, INHARMONIC_FLAG, isDelta && isExitDelta, dataRule, num, code, oneConfig.getScale(), waveNum));
+                        resultMap.put(PowerIndexEnum.HSI.getKey(), isHarmQualified(devDataList, standardDevDataList, devIdMapComm, pqErrSysDtls, I, fIn, INHARMONIC_FLAG, isDelta && isExitDelta, dataRule, num, code, oneConfig.getScale(), waveNum, dataSourceEnum));
+                        break;
+                    case PST:
+                        resultMap.put(PowerIndexEnum.PST.getKey(), isQualified(devDataList, standardDevDataList, devIdMapComm, pqErrSysDtls, true, fUn , DetectionCodeEnum.PST.getCode(), dataRule, num, code, oneConfig.getScale(), waveNum, dataSourceEnum));
                         break;
                     case UNKNOWN_ERROR:
                         break;
@@ -1708,6 +1713,7 @@ public class DetectionServiceImpl {
      * @param code                结果表code
      * @param scale               小数点位数
      * @param waveNum             第几次录波
+     * @param dataSourceEnum      数据源类型
      * @return
      */
     private Integer isQualified(List<DevData> devDataList,
@@ -1721,11 +1727,15 @@ public class DetectionServiceImpl {
                                 Integer num,
                                 String code,
                                 Integer scale,
-                                Integer waveNum) {
+                                Integer waveNum,
+                                DataSourceEnum dataSourceEnum) {
         List<ContrastNonHarmonicResult> info = new ArrayList<>();
         if (CollUtil.isNotEmpty(devDataList) && CollUtil.isNotEmpty(standardDevDataList) && CollUtil.isNotEmpty(errSysDtls)) {
 
             Map<String, List<List<Double>>> map = devListMap(devDataList, standardDevDataList, desc, dataRule);
+            if (ObjectUtil.isNull(map)) {
+                return 4;
+            }
             ContrastNonHarmonicResult result = new ContrastNonHarmonicResult();
             result.setWaveNum(waveNum);
 
@@ -1735,7 +1745,7 @@ public class DetectionServiceImpl {
             result.setDevMonitorId(devIdMapComm.get(split1[0]) + "_" + split1[1]);
             result.setStdDevMonitorId(devIdMapComm.get(split2[0]) + "_" + split2[1]);
             result.setAdType(errSysDtls.get(0).getScriptType());
-            result.setDataType(DataSourceEnum.REAL_DATA.getValue());
+            result.setDataType(dataSourceEnum.getValue());
             if (ObjectUtil.isNotNull(waveNum)) {
                 result.setDataType(DataSourceEnum.WAVE_DATA.getValue());
             }
@@ -1790,6 +1800,7 @@ public class DetectionServiceImpl {
      * @param code                结果表code
      * @param scale               小数点位数
      * @param waveNum             第几次录波
+     * @param dataSourceEnum      数据源类型
      * @return
      */
     public Integer isHarmQualified(List<DevData> devDataList,
@@ -1804,7 +1815,8 @@ public class DetectionServiceImpl {
                                    Integer num,
                                    String code,
                                    Integer scale,
-                                   Integer waveNum) {
+                                   Integer waveNum,
+                                   DataSourceEnum dataSourceEnum) {
         List<ContrastHarmonicResult> info = new ArrayList<>();
         if (CollUtil.isNotEmpty(devDataList) && CollUtil.isNotEmpty(standardDevDataList) && CollUtil.isNotEmpty(errSysDtls)) {
             String fundCode = "";
@@ -1849,14 +1861,14 @@ public class DetectionServiceImpl {
             result.setDevMonitorId(devIdMapComm.get(split1[0]) + "_" + split1[1]);
             result.setStdDevMonitorId(devIdMapComm.get(split2[0]) + "_" + split2[1]);
             result.setAdType(errSysDtls.get(0).getScriptType());
-            result.setDataType(DataSourceEnum.REAL_DATA.getValue());
+            result.setDataType(dataSourceEnum.getValue());
             if (ObjectUtil.isNotNull(waveNum)) {
                 result.setDataType(DataSourceEnum.WAVE_DATA.getValue());
             }
 
             List<DetectionData> integerBooleanA = harmRangeComparison(devMap.get(TYPE_A).get(0), devMap.get(TYPE_A).get(1), errSysDtls, type, fData, scale, dataRule);
-            List<DetectionData> integerBooleanB = harmRangeComparison(devMap.get(TYPE_B).get(0), devMap.get(TYPE_A).get(1), errSysDtls, type, fData, scale, dataRule);
+            List<DetectionData> integerBooleanB = harmRangeComparison(devMap.get(TYPE_B).get(0), devMap.get(TYPE_B).get(1), errSysDtls, type, fData, scale, dataRule);
-            List<DetectionData> integerBooleanC = harmRangeComparison(devMap.get(TYPE_C).get(0), devMap.get(TYPE_A).get(1), errSysDtls, type, fData, scale, dataRule);
+            List<DetectionData> integerBooleanC = harmRangeComparison(devMap.get(TYPE_C).get(0), devMap.get(TYPE_C).get(1), errSysDtls, type, fData, scale, dataRule);
             reflectHarmonic(true, "a", integerBooleanA, result, harmonicFlag);
             reflectHarmonic(true, "b", integerBooleanB, result, harmonicFlag);
             reflectHarmonic(true, "c", integerBooleanC, result, harmonicFlag);
@@ -1903,6 +1915,10 @@ public class DetectionServiceImpl {
             List<DevData.SqlDataDTO.ListDTO> standardDevList = standardDevSqlData.stream().filter(j -> finalDesc.equals(j.getDesc()))
                     .map(DevData.SqlDataDTO::getList).collect(Collectors.toList());
 
+            if (CollUtil.isEmpty(devList) || CollUtil.isEmpty(standardDevList)) {
+                return null;
+            }
+
             aDev.addAll(devList.stream().filter(x -> ObjectUtil.isNotNull(x.getA()))
                     .map(x -> x.getA().doubleValue())
                     .collect(Collectors.toList()));

detection/src/main/java/com/njcn/gather/detection/service/impl/PreDetectionServiceImpl.java

@@ -25,6 +25,7 @@ import com.njcn.gather.detection.util.socket.websocket.WebServiceManager;
 import com.njcn.gather.device.pojo.po.PqDev;
 import com.njcn.gather.device.pojo.vo.PreDetection;
 import com.njcn.gather.device.service.IPqDevService;
+import com.njcn.gather.plan.pojo.enums.DataSourceEnum;
 import com.njcn.gather.plan.pojo.po.AdPlan;
 import com.njcn.gather.plan.pojo.po.AdPlanSource;
 import com.njcn.gather.plan.service.IAdPlanService;
@@ -385,7 +386,15 @@ public class PreDetectionServiceImpl implements PreDetectionService {
         String jsonString = JSON.toJSONString(map);
         SocketMsg<String> socketMsg = new SocketMsg<>();
         socketMsg.setRequestId(SourceOperateCodeEnum.YJC_SBTXJY.getValue());
+        AdPlan currentTestPlan = FormalTestManager.currentTestPlan;
+        String[] datasource = currentTestPlan.getDatasourceId().split(",");
+        if (Arrays.stream(datasource).anyMatch(x -> x.equals(DataSourceEnum.REAL_DATA.getValue()))) {
             socketMsg.setOperateCode(SourceOperateCodeEnum.DEV_INIT_GATHER_02.getValue());
+        } else if (Arrays.stream(datasource).anyMatch(x -> x.equals(DataSourceEnum.MINUTE_STATISTICS_AVG.getValue()) || x.equals(DataSourceEnum.MINUTE_STATISTICS_MAX.getValue()) || x.equals(DataSourceEnum.MINUTE_STATISTICS_MIN.getValue()) || x.equals(DataSourceEnum.MINUTE_STATISTICS_CP95.getValue()))) {
+            socketMsg.setOperateCode(SourceOperateCodeEnum.DEV_INIT_GATHER_01.getValue());
+        } else if (Arrays.stream(datasource).anyMatch(x -> x.equals(DataSourceEnum.WAVE_DATA.getValue()))) {
+            socketMsg.setOperateCode(SourceOperateCodeEnum.DEV_INIT_GATHER_02.getValue());
+        }
         socketMsg.setData(jsonString);
         PreDetectionParam preDetectionParam = new PreDetectionParam();
         preDetectionParam.setUserPageId(param.getLoginName());

detection/src/main/java/com/njcn/gather/detection/util/DetectionUtil.java

@@ -51,6 +51,11 @@ public class DetectionUtil {
      */
     private static final long MILLIS_TO_SECONDS = 1000L;
 
+    /**
+     * 毫秒转分钟的转换因子
+     */
+    private static final long MILLIS_TO_MINUTES = 1000 * 60L;
+
     /**
      * 时间对齐判断的容差毫秒数
      * 当两个时间戳差值小于此值时，认为时间是对齐的
@@ -123,12 +128,12 @@ public class DetectionUtil {
      * @param standardDevData 标准设备数据，包含时间戳信息
      * @return true表示数据时间对齐，false表示不对齐
      */
-    public static boolean isAlignData(DevData devData, DevData standardDevData) {
+    public static boolean isAlignData(DevData devData, DevData standardDevData, int type) {
         if (ObjectUtil.isNotNull(devData) && ObjectUtil.isNotNull(standardDevData)) {
             // 获取两个设备数据的时间戳（毫秒）
             long devMillis = getMillis(devData.getTime());
             long standardMillis = getMillis(standardDevData.getTime());
-
+            if (type == 1) { // 实时数据
                 // 方式1：将时间戳转换为秒级精度进行比较（处理跨秒边界情况）
                 BigDecimal devSeconds = BigDecimal.valueOf(devMillis).divide(BigDecimal.valueOf(MILLIS_TO_SECONDS), 0, RoundingMode.HALF_UP);
                 BigDecimal standardSeconds = BigDecimal.valueOf(standardMillis).divide(BigDecimal.valueOf(MILLIS_TO_SECONDS), 0, RoundingMode.HALF_UP);
@@ -141,6 +146,15 @@ public class DetectionUtil {
                     return true;
                 }
             }
+            if (type == 2) { //统计数据
+                BigDecimal devSeconds = BigDecimal.valueOf(devMillis).divide(BigDecimal.valueOf(MILLIS_TO_MINUTES), 0, RoundingMode.HALF_UP);
+                BigDecimal standardSeconds = BigDecimal.valueOf(standardMillis).divide(BigDecimal.valueOf(MILLIS_TO_MINUTES), 0, RoundingMode.HALF_UP);
+                if (devSeconds.compareTo(standardSeconds) == 0) {
+                    return true;
+                }
+            }
+        }
+
         return false;
     }
 

detection/src/main/java/com/njcn/gather/detection/util/socket/CnSocketUtil.java

@@ -58,7 +58,7 @@ public class CnSocketUtil {
      * 比对式-退出检测
      */
     public static void contrastSendquit(String loginName, SourceOperateCodeEnum operateCode, boolean isRemoveSocket) {
-        System.out.println("比对式-发送关闭备通讯模块指令。。。。。。。。");
+        System.out.println("比对式-发送" + operateCode.getMsg() + "指令。。。。。。。。");
         SocketMsg<String> socketMsg = new SocketMsg<>();
         socketMsg.setRequestId(SourceOperateCodeEnum.QUITE.getValue());
         socketMsg.setOperateCode(operateCode.getValue());

detection/src/main/java/com/njcn/gather/detection/util/socket/FormalTestManager.java

@@ -7,6 +7,7 @@ import com.njcn.gather.detection.pojo.po.DevData;
 import com.njcn.gather.detection.pojo.vo.DevLineTestResult;
 import com.njcn.gather.device.pojo.enums.PatternEnum;
 import com.njcn.gather.device.pojo.vo.PreDetection;
+import com.njcn.gather.plan.pojo.enums.DataSourceEnum;
 import com.njcn.gather.plan.pojo.po.AdPlan;
 import com.njcn.gather.plan.pojo.po.AdPlanTestConfig;
 import com.njcn.gather.system.dictionary.pojo.enums.DictDataEnum;
@@ -16,6 +17,8 @@ import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.ScheduledFuture;
 
 /**
  * @Author: cdf
@@ -87,6 +90,17 @@ public class FormalTestManager {
      */
     public static AdPlan currentTestPlan;
 
+    /**
+     * 非录波数据源枚举
+     */
+    public static DataSourceEnum nonWaveDataSourceEnum;
+
+
+    /**
+     * 统计数据最大超时时间
+     */
+    public static Long maxTime;
+
     public static AdPlanTestConfig curretntTestPlanConfig;
 
     /**
@@ -154,4 +168,16 @@ public class FormalTestManager {
      */
     public static List<DevLineTestResult> preNumTestResultList = new ArrayList<>();
 
+    /**
+     * 定时器
+     */
+    public static ScheduledExecutorService scheduler;
+
+    /**
+     * 定时器任务
+     */
+    public static ScheduledFuture<?> scheduledFuture;
+
+
+    public static boolean isWaveCheck;
 }

detection/src/main/java/com/njcn/gather/detection/util/socket/MsgUtil.java

@@ -84,6 +84,15 @@ public class MsgUtil {
         }
     }
 
+    public static String getMonitorInfo(String monitorId, Map<String, String> devMap) {
+        if (StrUtil.isBlank(monitorId)) {
+            return "";
+        } else {
+            String[] split1 = monitorId.split("_");
+            return devMap.get(split1[0]) + CnSocketUtil.SPLIT_TAG + split1[1] + "路\"";
+        }
+    }
+
     /**
      * 获取消息
      *

detection/src/main/java/com/njcn/gather/detection/util/socket/cilent/HeartbeatHandler.java

@@ -193,7 +193,7 @@ public class HeartbeatHandler extends SimpleChannelInboundHandler<String> {
                 } else if (CnSocketUtil.SOURCE_TAG.equals(handlerType)) {
                     CnSocketUtil.quitSendSource(param);
                 } else {
-                    if (FormalTestManager.currentStep == SourceOperateCodeEnum.RECORD_WAVE_STEP1 || FormalTestManager.currentStep == SourceOperateCodeEnum.RECORD_WAVE_STEP2) {
+                    if (FormalTestManager.currentStep == SourceOperateCodeEnum.RECORD_WAVE_STEP1) {
                         CnSocketUtil.contrastSendquit(param.getUserPageId(), SourceOperateCodeEnum.QUIT_INIT_03, true);
                     } else {
                         CnSocketUtil.contrastSendquit(param.getUserPageId(), SourceOperateCodeEnum.QUIT_INIT_02, true);

detection/src/main/java/com/njcn/gather/detection/util/socket/cilent/NettyContrastClientHandler.java

@@ -1,6 +1,6 @@
 package com.njcn.gather.detection.util.socket.cilent;
 
-import com.alibaba.fastjson.JSON;
+import cn.hutool.core.util.ObjectUtil;
 import com.njcn.gather.detection.handler.SocketContrastResponseService;
 import com.njcn.gather.detection.pojo.enums.SourceOperateCodeEnum;
 import com.njcn.gather.detection.pojo.enums.SourceResponseCodeEnum;
@@ -60,11 +60,14 @@ public class NettyContrastClientHandler extends SimpleChannelInboundHandler<Stri
             socketContrastResponseService.deal(param, msg);
         } catch (Exception e) {
             log.error("处理服务端消息异常", e);
-            if (FormalTestManager.currentStep == SourceOperateCodeEnum.RECORD_WAVE_STEP1 || FormalTestManager.currentStep == SourceOperateCodeEnum.RECORD_WAVE_STEP2) {
+//            if (FormalTestManager.currentStep == SourceOperateCodeEnum.RECORD_WAVE_STEP1) {
+//                CnSocketUtil.contrastSendquit(param.getUserPageId(), SourceOperateCodeEnum.QUIT_INIT_03, true);
+//            } else {
+//                CnSocketUtil.contrastSendquit(param.getUserPageId(), SourceOperateCodeEnum.QUIT_INIT_02, true);
+//            }
+            CnSocketUtil.contrastSendquit(param.getUserPageId(), SourceOperateCodeEnum.QUIT_INIT_01, false);
+            CnSocketUtil.contrastSendquit(param.getUserPageId(), SourceOperateCodeEnum.QUIT_INIT_02, false);
             CnSocketUtil.contrastSendquit(param.getUserPageId(), SourceOperateCodeEnum.QUIT_INIT_03, true);
-            } else {
-                CnSocketUtil.contrastSendquit(param.getUserPageId(), SourceOperateCodeEnum.QUIT_INIT_02, true);
-            }
         }
     }
 
@@ -86,17 +89,21 @@ public class NettyContrastClientHandler extends SimpleChannelInboundHandler<Stri
         if (evt instanceof IdleStateEvent) { //IdleState.在一段时间内没有收到任何消息时，会触发该事件
             if (((IdleStateEvent) evt).state() == IdleState.READER_IDLE) {
                 System.out.println(LocalDateTime.now() + "contrastClientHandler触发读超时函数**************************************");
-                SocketManager.contrastClockMap.put(DataSourceEnum.REAL_DATA, SocketManager.contrastClockMap.get(DataSourceEnum.REAL_DATA) + 60L);
 
-                if (FormalTestManager.isRemoveSocket) {
+                if (!FormalTestManager.isRemoveSocket && ObjectUtil.isNotNull(FormalTestManager.nonWaveDataSourceEnum)) {
-                    //实时数据
+                    long time = SocketManager.contrastClockMap.get(FormalTestManager.nonWaveDataSourceEnum) + 60L;
-                    if (SocketManager.contrastClockMap.get(DataSourceEnum.REAL_DATA) >= 60) {
+                    SocketManager.contrastClockMap.put(FormalTestManager.nonWaveDataSourceEnum, time);
-                        CnSocketUtil.contrastSendquit(param.getUserPageId(), SourceOperateCodeEnum.QUIT_INIT_02, false);
+
-                        System.out.println("超时处理-----》" + "实时数据已超时----------------关闭");
+                    if (DataSourceEnum.REAL_DATA == FormalTestManager.nonWaveDataSourceEnum) {
-                        timeoutSend();
+                        if (time >= 60) {
+                            CnSocketUtil.contrastSendquit(param.getUserPageId(), SourceOperateCodeEnum.QUIT_INIT_02, true);
+                            timeoutSend(SourceOperateCodeEnum.QUIT_INIT_02);
+                        }
+                    } else if (time >= FormalTestManager.maxTime) {
+                        CnSocketUtil.contrastSendquit(param.getUserPageId(), SourceOperateCodeEnum.QUIT_INIT_02, true);
+                        timeoutSend(SourceOperateCodeEnum.QUIT_INIT_01);
                     }
                 }
-
             }
         }
     }
@@ -126,8 +133,9 @@ public class NettyContrastClientHandler extends SimpleChannelInboundHandler<Stri
             System.out.println("Unknown exception caught: " + cause.getMessage());
             WebServiceManager.sendDetectionErrorMessage(param.getUserPageId(), SourceOperateCodeEnum.DEVICE_ERROR);
         }
-        CnSocketUtil.contrastSendquit(param.getUserPageId(), SourceOperateCodeEnum.QUIT_INIT_02, true);
+        CnSocketUtil.contrastSendquit(param.getUserPageId(), SourceOperateCodeEnum.QUIT_INIT_01, false);
-//        socketContrastResponseService.backCheckState(param);
+        CnSocketUtil.contrastSendquit(param.getUserPageId(), SourceOperateCodeEnum.QUIT_INIT_02, false);
+        CnSocketUtil.contrastSendquit(param.getUserPageId(), SourceOperateCodeEnum.QUIT_INIT_03, true);
         ctx.close();
     }
 
@@ -135,13 +143,14 @@ public class NettyContrastClientHandler extends SimpleChannelInboundHandler<Stri
     /**
      * 接收数据超时处理
      */
-    private void timeoutSend() {
+    private void timeoutSend(SourceOperateCodeEnum sourceOperateCodeEnum) {
+        System.out.println("超时处理-----》" + "统计数据已超时----------------关闭");
         // 向前端推送超时消息
         SocketDataMsg webSend = new SocketDataMsg();
+        webSend.setRequestId(sourceOperateCodeEnum.getValue());
+        webSend.setData(sourceOperateCodeEnum.getMsg() + SourceResponseCodeEnum.RECEIVE_DATA_TIME_OUT.getMessage());
         webSend.setCode(SourceResponseCodeEnum.RECEIVE_DATA_TIME_OUT.getCode());
         WebServiceManager.sendMsg(param.getUserPageId(), MsgUtil.msgToWebData(webSend, FormalTestManager.devNameMapComm, 0));
-
-        WebServiceManager.sendMsg(param.getUserPageId(), JSON.toJSONString(webSend));
     }
 
 }

detection/src/main/java/com/njcn/gather/detection/util/socket/websocket/WebServiceManager.java

@@ -120,6 +120,7 @@ public class WebServiceManager {
             channel.writeAndFlush(frame);
         } else {
             log.error("WebSocket推送消息失败，用户连接已断开，时间: {}, userId: {}", LocalDateTime.now(), userId);
+            WebSocketHandler.cleanupSocketResources(userId);
         }
     }
 
@@ -137,6 +138,7 @@ public class WebServiceManager {
             channel.writeAndFlush(frame);
         } else {
             log.error("WebSocket推送结构化消息失败，用户连接已断开，时间: {}, userId: {}", LocalDateTime.now(), userId);
+            WebSocketHandler.cleanupSocketResources(userId);
         }
     }
 

detection/src/main/java/com/njcn/gather/detection/util/socket/websocket/WebSocketHandler.java

@@ -7,6 +7,7 @@ import com.njcn.gather.detection.util.socket.CnSocketUtil;
 import com.njcn.gather.detection.util.socket.FormalTestManager;
 import com.njcn.gather.detection.util.socket.SocketManager;
 import com.njcn.gather.device.pojo.enums.PatternEnum;
+import com.njcn.gather.plan.pojo.enums.DataSourceEnum;
 import io.netty.channel.ChannelHandlerContext;
 import io.netty.channel.SimpleChannelInboundHandler;
 import io.netty.handler.codec.CorruptedFrameException;
@@ -360,7 +361,7 @@ public class WebSocketHandler extends SimpleChannelInboundHandler<TextWebSocketF
      *
      * @param userId 用户ID
      */
-    private void cleanupSocketResources(String userId) {
+    public static void cleanupSocketResources(String userId) {
         if (userId == null || userId.trim().isEmpty()) {
             log.warn("userId为空，无法进行Socket连接清理");
             return;
@@ -372,17 +373,31 @@ public class WebSocketHandler extends SimpleChannelInboundHandler<TextWebSocketF
                 // 使用该用户的检测参数关闭Socket连接
                 log.info("使用用户检测参数关闭Socket连接，userId: {}", userId);
                 if (FormalTestManager.patternEnum.equals(PatternEnum.CONTRAST)) {
-                    if (!FormalTestManager.isRemoveSocket) {
+                    if (FormalTestManager.isRemoveSocket) {
-                        if (FormalTestManager.currentStep == SourceOperateCodeEnum.RECORD_WAVE_STEP1 || FormalTestManager.currentStep == SourceOperateCodeEnum.RECORD_WAVE_STEP2) {
+                        boolean channelActive = SocketManager.isChannelActive(preDetectionParam.getUserPageId() + CnSocketUtil.CONTRAST_DEV_TAG);
-                            CnSocketUtil.contrastSendquit(preDetectionParam.getUserPageId(), SourceOperateCodeEnum.QUIT_INIT_03, true);
+                        if (channelActive) {
-                        } else if (FormalTestManager.currentStep != SourceOperateCodeEnum.QUITE) {
-                            CnSocketUtil.contrastSendquit(preDetectionParam.getUserPageId(), SourceOperateCodeEnum.QUIT_INIT_02, true);
-                        } else {
                             SocketManager.removeUser(preDetectionParam.getUserPageId() + CnSocketUtil.CONTRAST_DEV_TAG);
                         }
                     } else {
-                        boolean channelActive = SocketManager.isChannelActive(preDetectionParam.getUserPageId() + CnSocketUtil.CONTRAST_DEV_TAG);
+                        if (FormalTestManager.currentStep == SourceOperateCodeEnum.RECORD_WAVE_STEP1) {
-                        if (channelActive) {
+                            CnSocketUtil.contrastSendquit(preDetectionParam.getUserPageId(), SourceOperateCodeEnum.QUIT_INIT_03, true);
+                        } else if (FormalTestManager.currentStep != SourceOperateCodeEnum.QUITE) {
+                            if (ObjectUtil.isNotNull(FormalTestManager.nonWaveDataSourceEnum)) {
+                                if (FormalTestManager.nonWaveDataSourceEnum == DataSourceEnum.REAL_DATA) {
+                                    CnSocketUtil.contrastSendquit(preDetectionParam.getUserPageId(), SourceOperateCodeEnum.QUIT_INIT_02, false);
+                                } else {
+                                    CnSocketUtil.contrastSendquit(preDetectionParam.getUserPageId(), SourceOperateCodeEnum.QUIT_INIT_01, false);
+                                }
+                                if (FormalTestManager.isWaveCheck) {
+                                    CnSocketUtil.contrastSendquit(preDetectionParam.getUserPageId(), SourceOperateCodeEnum.QUIT_INIT_03, true);
+                                }
+                            } else {
+                                if (FormalTestManager.isWaveCheck) {
+                                    CnSocketUtil.contrastSendquit(preDetectionParam.getUserPageId(), SourceOperateCodeEnum.QUIT_INIT_02, false);
+                                    CnSocketUtil.contrastSendquit(preDetectionParam.getUserPageId(), SourceOperateCodeEnum.QUIT_INIT_03, true);
+                                }
+                            }
+                        } else {
                             SocketManager.removeUser(preDetectionParam.getUserPageId() + CnSocketUtil.CONTRAST_DEV_TAG);
                         }
                     }

detection/src/main/java/com/njcn/gather/device/pojo/param/PqDevParam.java

@@ -6,14 +6,12 @@ import com.njcn.gather.pojo.constant.DetectionValidMessage;
 import com.njcn.web.pojo.annotation.DateTimeStrValid;
 import com.njcn.web.pojo.param.BaseParam;
 import io.swagger.annotations.ApiModelProperty;
-import io.swagger.models.auth.In;
 import lombok.Data;
 import lombok.EqualsAndHashCode;
 import org.hibernate.validator.constraints.Range;
 
 import javax.validation.Valid;
 import javax.validation.constraints.*;
-import java.time.LocalDate;
 import java.util.List;
 
 /**
@@ -137,6 +135,7 @@ public class PqDevParam {
 
     @ApiModelProperty("是否为导入设备")
     private Integer importFlag;
+
     /**
      * 更新操作实体
      */
@@ -197,6 +196,12 @@ public class PqDevParam {
 
         @ApiModelProperty("是否分配")
         private Integer assign;
+        @ApiModelProperty("关键词")
+        private String keywords;
+        @ApiModelProperty("主计划ID")
+        private String planId;
+        @ApiModelProperty("是否分配子计划")
+        private Integer assignSub;
     }
 
     @Data

detection/src/main/java/com/njcn/gather/device/pojo/po/PqStandardDev.java

@@ -1,5 +1,6 @@
 package com.njcn.gather.device.pojo.po;
 
+import com.baomidou.mybatisplus.annotation.TableField;
 import com.baomidou.mybatisplus.annotation.TableName;
 import com.njcn.db.mybatisplus.bo.BaseEntity;
 import lombok.Data;
@@ -72,5 +73,8 @@ public class PqStandardDev extends BaseEntity implements Serializable {
     private String devKey;
 
     private Integer state;
+
+    @TableField(exist = false)
+    private boolean disabled;
 }
 

detection/src/main/java/com/njcn/gather/device/service/impl/PqDevServiceImpl.java

@@ -13,6 +13,7 @@ import cn.hutool.core.util.StrUtil;
 import com.baomidou.mybatisplus.core.conditions.Wrapper;
 import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
 import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
+import com.baomidou.mybatisplus.extension.conditions.update.LambdaUpdateChainWrapper;
 import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
 import com.github.yulichang.wrapper.MPJLambdaWrapper;
@@ -395,12 +396,21 @@ public class PqDevServiceImpl extends ServiceImpl<PqDevMapper, PqDev> implements
                     .in(CollectionUtil.isNotEmpty(queryParam.getPlanIdList()), "pq_dev.Plan_Id", queryParam.getPlanIdList())
                     .isNotNull(DataStateEnum.ENABLE.getCode().equals(queryParam.getAssign()), "pq_dev.Plan_Id")
                     .isNull(DataStateEnum.DELETED.getCode().equals(queryParam.getAssign()), "pq_dev.Plan_Id")
+                    .eq(DataStateEnum.DELETED.getCode().equals(queryParam.getAssignSub()), "pq_dev.Plan_Id", queryParam.getPlanId())
+                    .ne(DataStateEnum.ENABLE.getCode().equals(queryParam.getAssignSub()), "pq_dev.Plan_Id", queryParam.getPlanId())
                     .between(ObjectUtil.isAllNotEmpty(queryParam.getSearchBeginTime(), queryParam.getSearchEndTime()), "pq_dev.Create_Date", queryParam.getSearchBeginTime(), queryParam.getSearchEndTime());
             if (StrUtil.isNotBlank(queryParam.getRegion())) {
                 queryWrapper.and(w -> w.like(StrUtil.isNotBlank(queryParam.getRegion()), "pq_dev.City_Name", queryParam.getRegion())
                         .or().like(StrUtil.isNotBlank(queryParam.getRegion()), "pq_dev.Gd_Name", queryParam.getRegion())
                         .or().like(StrUtil.isNotBlank(queryParam.getRegion()), "pq_dev.Sub_Name", queryParam.getRegion()));
             }
+            if (StrUtil.isNotBlank(queryParam.getKeywords())) {
+                queryWrapper.and(w -> w.like(StrUtil.isNotBlank(queryParam.getKeywords()), "pq_dev.City_Name", queryParam.getKeywords())
+                        .or().like(StrUtil.isNotBlank(queryParam.getKeywords()), "pq_dev.Gd_Name", queryParam.getKeywords())
+                        .or().like(StrUtil.isNotBlank(queryParam.getKeywords()), "pq_dev.Sub_Name", queryParam.getKeywords())
+                        .or().like(StrUtil.isNotBlank(queryParam.getKeywords()), "pq_dev.name", queryParam.getKeywords())
+                );
+            }
             //排序
             if (ObjectUtil.isAllNotEmpty(queryParam.getSortBy(), queryParam.getOrderBy())) {
                 queryWrapper.orderBy(true, queryParam.getOrderBy().equals(DbConstant.ASC), StrUtil.toUnderlineCase(queryParam.getSortBy()));
@@ -520,11 +530,21 @@ public class PqDevServiceImpl extends ServiceImpl<PqDevMapper, PqDev> implements
         Integer checkState = pqMonitorService.getDevCheckState(devId);
         Integer checkResult = pqMonitorService.getDevCheckResult(devId);
 
-        pqDevSubService.lambdaUpdate()
+        SysUser user = userService.getById(userId);
+
+        LambdaUpdateChainWrapper<PqDevSub> w = pqDevSubService.lambdaUpdate()
                 .set(PqDevSub::getCheckState, checkState)
                 .set(PqDevSub::getCheckResult, checkResult)
-                .set(StrUtil.isNotBlank(userId), PqDevSub::getCheckBy, userId)
+                .set(PqDevSub::getCheckTime, LocalDateTime.now())
-                .eq(PqDevSub::getDevId, devId).update();
+                .eq(PqDevSub::getDevId, devId);
+
+        if(ObjectUtil.isNotNull(user)){
+            w.set(PqDevSub::getCheckBy, user.getName());
+        }
+        if(checkState.equals(CheckStateEnum.CHECKED.getValue())){
+            w.set(PqDevSub::getReportState, DevReportStateEnum.NOT_GENERATED.getValue());
+        }
+        w.update();
 
         PqDevParam.QueryParam param = new PqDevParam.QueryParam();
         String planId = dev.getPlanId();
@@ -544,6 +564,10 @@ public class PqDevServiceImpl extends ServiceImpl<PqDevMapper, PqDev> implements
             set = pqDevVOList.stream().map(PqDevVO::getCheckState).collect(Collectors.toSet());
             if (set.contains(CheckStateEnum.UNCHECKED.getValue())) {
                 this.baseMapper.updatePlanTestState(planId, CheckStateEnum.CHECKING.getValue());
+            } else if (set.contains(CheckStateEnum.CHECKING.getValue())) {
+                this.baseMapper.updatePlanTestState(planId, CheckStateEnum.CHECKING.getValue());
+            } else {
+                this.baseMapper.updatePlanTestState(planId, CheckStateEnum.CHECKED.getValue());
             }
         }
     }

detection/src/main/java/com/njcn/gather/device/service/impl/PqStandardDevServiceImpl.java

@@ -18,6 +18,8 @@ import com.njcn.common.pojo.exception.BusinessException;
 import com.njcn.common.pojo.poi.PullDown;
 import com.njcn.common.utils.EncryptionUtil;
 import com.njcn.gather.device.mapper.PqStandardDevMapper;
+import com.njcn.gather.device.pojo.enums.CheckStateEnum;
+import com.njcn.gather.device.pojo.enums.CommonEnum;
 import com.njcn.gather.device.pojo.param.PqStandardDevParam;
 import com.njcn.gather.device.pojo.po.PqStandardDev;
 import com.njcn.gather.device.pojo.vo.PqStandardDevExcel;
@@ -316,27 +318,30 @@ public class PqStandardDevServiceImpl extends ServiceImpl<PqStandardDevMapper, P
             // 获取对应检测计划
             List<String> planIds = boundList.stream().map(AdPlanStandardDev::getPlanId).collect(Collectors.toList());
             IAdPlanService adPlanService = SpringUtil.getBean(IAdPlanService.class);
-            List<AdPlan> planList = adPlanService.listByIds(planIds);
+            List<AdPlan> planList = adPlanService.lambdaQuery().in(AdPlan::getId, planIds).eq(AdPlan::getState, DataStateEnum.ENABLE.getCode()).list();
             // 区分主计划和子计划
-            List<AdPlan> mainPlanList = planList.stream().filter(plan -> plan.getFatherPlanId() == null).collect(Collectors.toList());
+            List<AdPlan> mainPlanList = planList.stream().filter(plan -> plan.getFatherPlanId().equals(CommonEnum.FATHER_ID.getValue())).collect(Collectors.toList());
-            List<AdPlan> subPlanList = planList.stream().filter(plan -> plan.getFatherPlanId() != null).collect(Collectors.toList());
+            List<AdPlan> subPlanList = planList.stream().filter(plan -> !plan.getFatherPlanId().equals(CommonEnum.FATHER_ID.getValue())).collect(Collectors.toList());
             List<String> excludePlanIds = new ArrayList<>();
 
-            // 主计划直接排除
+            // 主计划未完成直接排除
             if (CollectionUtil.isNotEmpty(mainPlanList)) {
-                List<String> excludeMainPlanIds = mainPlanList.stream().filter(plan -> plan.getTestState() != 2).map(plan -> plan.getId()).collect(Collectors.toList());
+                List<String> excludeMainPlanIds = mainPlanList.stream().filter(plan -> !plan.getTestState().equals(CheckStateEnum.CHECKED.getValue())).map(AdPlan::getId).collect(Collectors.toList());
+                if (CollectionUtil.isNotEmpty(excludeMainPlanIds)) {
                     excludePlanIds.addAll(excludeMainPlanIds);
                 }
+
+            }
             // 子计划需要判断其主计划, 如果主计划未完成则排除
             if (CollectionUtil.isNotEmpty(subPlanList)) {
-                List<String> fatherPlanIds = subPlanList.stream().map(plan -> plan.getFatherPlanId()).collect(Collectors.toList());
+                List<String> fatherPlanIds = subPlanList.stream().map(AdPlan::getFatherPlanId).distinct().collect(Collectors.toList());
                 List<AdPlan> fatherPlanList = adPlanService.listByIds(fatherPlanIds);
                 List<String> excludeFatherPlanIds = fatherPlanList.stream()
-                        .filter(plan -> plan.getTestState() != 2)
+                        .filter(plan -> !plan.getTestState().equals(CheckStateEnum.CHECKED.getValue()))
-                        .map(plan -> plan.getId()).collect(Collectors.toList());
+                        .map(AdPlan::getId).collect(Collectors.toList());
                 List<String> excludeSubPlanIds = subPlanList.stream()
                         .filter(plan -> excludeFatherPlanIds.contains(plan.getFatherPlanId()))
-                        .map(plan -> plan.getId()).collect(Collectors.toList());
+                        .map(AdPlan::getId).collect(Collectors.toList());
                 excludePlanIds.addAll(excludeSubPlanIds);
             }
             if (CollectionUtil.isNotEmpty(excludePlanIds)) {
@@ -346,10 +351,12 @@ public class PqStandardDevServiceImpl extends ServiceImpl<PqStandardDevMapper, P
                 excludeStandardDevIds = excludeBoundList.stream().map(AdPlanStandardDev::getStandardDevId).collect(Collectors.toList());
             }
         }
-
+        List<PqStandardDev> list = this.lambdaQuery()
-        return this.lambdaQuery()
                 .eq(PqStandardDev::getState, DataStateEnum.ENABLE.getCode())
-                .notIn(CollectionUtil.isNotEmpty(excludeStandardDevIds), PqStandardDev::getId, excludeStandardDevIds)
                 .list();
+        for (PqStandardDev pqStandardDev : list) {
+            pqStandardDev.setDisabled(excludeStandardDevIds.contains(pqStandardDev.getId()));
+        }
+        return list;
     }
 }

detection/src/main/java/com/njcn/gather/monitor/service/impl/PqMonitorServiceImpl.java

@@ -148,9 +148,6 @@ public class PqMonitorServiceImpl extends ServiceImpl<PqMonitorMapper, PqMonitor
         Integer newMonitorResult = CheckResultEnum.UNCHECKED.getValue();
         AtomicReference<Integer> newWaveNum = new AtomicReference<>(-1);
         switch (dataSourceEnum) {
-            case REAL_DATA:
-                newMonitorResult = detectionDataDealService.getMonitorResult(monitorId, adTypes, dataSourceEnum.getValue(), num, null, code);
-                break;
             case WAVE_DATA:
                 Map<Integer, Integer> waveNumResultMap = detectionDataDealService.getWaveNumResultMap(monitorId, adTypes, num, code);
                 if (CollUtil.isEmpty(waveNumResultMap)) {
@@ -169,6 +166,7 @@ public class PqMonitorServiceImpl extends ServiceImpl<PqMonitorMapper, PqMonitor
                 }
                 break;
             default:
+                newMonitorResult = detectionDataDealService.getMonitorResult(monitorId, adTypes, dataSourceEnum.getValue(), num, null, code);
                 break;
         }
 
@@ -206,22 +204,28 @@ public class PqMonitorServiceImpl extends ServiceImpl<PqMonitorMapper, PqMonitor
 
             switch (dataSourceEnum) {
                 case REAL_DATA:
-                    monitor.setRealtimeResult(newMonitorResult);
                     monitor.setRealtimeNum(String.valueOf(num));
-                    monitor.setRecordedResult(null);
+                    monitor.setRealtimeResult(newMonitorResult);
                     monitor.setRecordedNum(null);
-                    monitor.setStatisticsResult(null);
+                    monitor.setRecordedResult(null);
                     monitor.setStatisticsNum(null);
+                    monitor.setStatisticsResult(null);
                     break;
                 case WAVE_DATA:
-                    monitor.setRealtimeResult(null);
                     monitor.setRealtimeNum(null);
-                    monitor.setRecordedResult(newMonitorResult);
+                    monitor.setRealtimeResult(null);
                     monitor.setRecordedNum(num + CnSocketUtil.SPLIT_TAG + newWaveNum.get());
-                    monitor.setStatisticsResult(null);
+                    monitor.setRecordedResult(newMonitorResult);
                     monitor.setStatisticsNum(null);
+                    monitor.setStatisticsResult(null);
                     break;
                 default:
+                    monitor.setRealtimeResult(null);
+                    monitor.setRealtimeNum(null);
+                    monitor.setRecordedResult(null);
+                    monitor.setRecordedNum(null);
+                    monitor.setStatisticsNum(String.valueOf(num));
+                    monitor.setStatisticsResult(newMonitorResult);
                     break;
             }
             monitor.setQualifiedNum(qualifiedNum);

detection/src/main/java/com/njcn/gather/plan/controller/AdPlanController.java

@@ -250,6 +250,7 @@ public class AdPlanController extends BaseController {
             List<String> planIdList = planList.stream().map(AdPlan::getId).collect(Collectors.toList());
             param.getPlanIdList().addAll(planIdList);
         }
+        param.setPlanId(plan.getId());
         Page<PqDevVO> pqDevVOPage = pqDevService.listPqDevs(param);
 
         List<AdPlan> planList = adPlanService.listByIds(param.getPlanIdList());

detection/src/main/java/com/njcn/gather/plan/service/AsyncPlanHandler.java

@@ -9,6 +9,7 @@ import cn.hutool.json.JSONConfig;
 import cn.hutool.json.JSONUtil;
 import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
+import com.njcn.common.pojo.enums.common.DataStateEnum;
 import com.njcn.common.pojo.enums.response.CommonResponseEnum;
 import com.njcn.gather.detection.pojo.po.AdPair;
 import com.njcn.gather.detection.service.IAdPariService;
@@ -39,6 +40,7 @@ import org.springframework.transaction.annotation.Transactional;
 import org.springframework.web.multipart.MultipartFile;
 
 import java.io.File;
+import java.io.IOException;
 import java.time.Duration;
 import java.time.LocalDateTime;
 import java.util.ArrayList;
@@ -89,6 +91,12 @@ public class AsyncPlanHandler {
         List<String> devIdList = devList.stream().map(PqDev::getId).collect(Collectors.toList());
         // 被检设备状态统计
         List<PqDevSub> devSubList = pqDevSubService.list(new LambdaQueryWrapper<PqDevSub>().in(PqDevSub::getDevId, devIdList));
+        for (PqDevSub devSub : devSubList) {
+            // 不导出报告，设置报告状态为未生成
+            if (ObjectUtil.isNull(report) || report.equals(DataStateEnum.DELETED.getCode())) {
+                devSub.setReportState(DataStateEnum.DELETED.getCode());
+            }
+        }
         planCheckDataVO.setDevSubList(devSubList);
         // 被检设备监测点信息
         List<PqMonitor> monitorList = pqMonitorService.list(new LambdaQueryWrapper<PqMonitor>().in(PqMonitor::getDevId, devIdList));
@@ -242,7 +250,14 @@ public class AsyncPlanHandler {
 
             // 将上传的zip文件保存到临时目录
             File zipFile = FileUtil.file(tempDir, file.getOriginalFilename());
-            file.transferTo(zipFile);
+            try {
+                // 直接获取文件字节，避免依赖Tomcat临时文件
+                byte[] fileBytes = file.getBytes();
+                FileUtil.writeBytes(fileBytes, zipFile);
+            } catch (IOException e) {
+                log.error("保存上传文件失败", e);
+                throw e;
+            }
             progress.addAndGet(1);
             sseClient.sendMessage(uid, planId, HttpResultUtil.assembleResult(CommonResponseEnum.SUCCESS.getCode(), progress, "开始解压文件，请耐心等待..."));
 
@@ -310,11 +325,13 @@ public class AsyncPlanHandler {
             adPlanService.updateById(subPlan);
             progress.addAndGet(1);
             sseClient.sendMessage(uid, planId, HttpResultUtil.assembleResult(CommonResponseEnum.SUCCESS.getCode(), progress, "开始同步计划设备信息，请耐心等待..."));
-
+            // 更新监测点数据
-            // 批量更新被检设备信息
+            List<PqMonitor> monitorList = planCheckDataVO.getMonitorList();
+            pqMonitorService.updateBatchById(monitorList);
+            // 批量更新被检设备信息，不需要更新
             // 不更新导入标志
-            devList.forEach(dev -> dev.setImportFlag(null));
+            /*devList.forEach(dev -> dev.setImportFlag(null));
-            pqDevService.updateBatchById(devList);
+            pqDevService.updateBatchById(devList);*/
 
             List<PqDevSub> devSubList = planCheckDataVO.getDevSubList();
             for (PqDevSub devSub : devSubList) {
@@ -325,7 +342,7 @@ public class AsyncPlanHandler {
 
             // 同步检测数据
             List<AdPair> pairList = planCheckDataVO.getPairList();
-            adPairService.updateBatchById(pairList);
+            adPairService.saveOrUpdateBatch(pairList);
             // 主计划
             AdPlan plan = adPlanService.getById(planId);
             if (CollUtil.isNotEmpty(docxFiles)) {

detection/src/main/java/com/njcn/gather/plan/service/impl/AdPlanServiceImpl.java

@@ -193,8 +193,18 @@ public class AdPlanServiceImpl extends ServiceImpl<AdPlanMapper, AdPlan> impleme
         adPlanVO.setSourceName(pqSourceList.stream().map(PqSource::getName).collect(Collectors.toList()));
 
         PqDevParam.QueryParam queryParam1 = new PqDevParam.QueryParam();
+        if (adPlan.getFatherPlanId().equals(CommonEnum.FATHER_ID.getValue())) {
+            List<String> planIds = this.lambdaQuery()
+                    .eq(AdPlan::getFatherPlanId, adPlan.getId())
+                    .eq(AdPlan::getState, DataStateEnum.ENABLE.getCode())
+                    .select(AdPlan::getId)
+                    .list()
+                    .stream().map(AdPlan::getId).collect(Collectors.toList());
+            planIds.add(adPlan.getId());
+            queryParam1.setPlanIdList(planIds);
+        } else {
             queryParam1.setPlanIdList(Collections.singletonList(adPlan.getId()));
-
+        }
         List<PqDevVO> pqDevVOList = pqDevMapper.selectByQueryParam(queryParam1);
         if (CollUtil.isNotEmpty(pqDevVOList)) {
             long count = pqDevVOList.stream().filter(pqDev -> CheckStateEnum.CHECKED.getValue().equals(pqDev.getCheckState())).count();
@@ -355,7 +365,6 @@ public class AdPlanServiceImpl extends ServiceImpl<AdPlanMapper, AdPlan> impleme
             }
             this.updateBindStandardDev(param.getId(), param.getStandardDevIds());
             List<AdPlan> list = new ArrayList<>();
-            AdPlan fatherPlan = this.getById(fatherPlanId);
             // 原始绑定被检设备
             List<PqDev> oldDevList = pqDevService.list(new QueryWrapper<PqDev>().eq("Plan_Id", param.getId()).eq("State", DataStateEnum.ENABLE.getCode()));
             List<String> oldDevIds = oldDevList.stream().map(PqDev::getId).collect(Collectors.toList());
@@ -371,8 +380,7 @@ public class AdPlanServiceImpl extends ServiceImpl<AdPlanMapper, AdPlan> impleme
 
                 // 把排除绑定到主计划
                 fatherNowDevIds.addAll(unionDevIds);
-                fatherPlan.setTestState(pqDevService.bind(fatherPlanId, fatherNowDevIds));
+                pqDevService.bind(fatherPlanId, fatherNowDevIds);
-                list.add(fatherPlan);
 
             } else {
                 if (CollUtil.isNotEmpty(oldDevIds)) {
@@ -380,10 +388,23 @@ public class AdPlanServiceImpl extends ServiceImpl<AdPlanMapper, AdPlan> impleme
                     List<String> fatherNowDevIds = fatherNowDevList.stream().map(PqDev::getId).collect(Collectors.toList());
                     fatherNowDevIds.addAll(oldDevIds);
                     // 把原始都绑定到主计划
-                    fatherPlan.setTestState(pqDevService.bind(fatherPlanId, fatherNowDevIds));
+                    pqDevService.bind(fatherPlanId, fatherNowDevIds);
-                    list.add(fatherPlan);
                 }
             }
+            // 非未检测状态
+            if (!plan1.getTestState().equals(CheckStateEnum.UNCHECKED.getValue())) {
+                PqDevParam.QueryParam queryParam = new PqDevParam.QueryParam();
+                queryParam.setPlanIdList(Collections.singletonList(plan1.getId()));
+                List<PqDevVO> pqDevVOS = pqDevService.listByPlanId(queryParam);
+                long checkedCount = pqDevVOS.stream().filter(pqDevVO -> pqDevVO.getCheckState().equals(CheckStateEnum.CHECKED.getValue())).count();
+                if (checkedCount == pqDevVOS.size()) {
+                    plan1.setTestState(CheckStateEnum.CHECKED.getValue());
+                } else if (checkedCount > 0) {
+                    plan1.setTestState(CheckStateEnum.CHECKING.getValue());
+                }
+            }
+
+
             list.add(plan1);
             return this.updateBatchById(list);
         }
@@ -602,6 +623,12 @@ public class AdPlanServiceImpl extends ServiceImpl<AdPlanMapper, AdPlan> impleme
         }
         DictData dictData = dictDataService.getById(patternId);
         if (PatternEnum.CONTRAST.getValue().equals(dictData.getCode())) {
+            String datasourceId = adPlan.getDatasourceId();
+            if (datasourceId.contains(DataSourceEnum.REAL_DATA.getValue())
+                    || datasourceId.contains(DataSourceEnum.MINUTE_STATISTICS_CP95.getValue())
+                    || datasourceId.contains(DataSourceEnum.MINUTE_STATISTICS_AVG.getValue())
+                    || datasourceId.contains(DataSourceEnum.MINUTE_STATISTICS_MAX.getValue())
+                    || datasourceId.contains(DataSourceEnum.MINUTE_STATISTICS_MIN.getValue())) {
                 String[] split = adPlan.getTestItem().split(StrUtil.COMMA);
                 List<DictTree> dictTreeList = dictTreeService.list(new QueryWrapper<DictTree>().in("id", split).eq("state", DataStateEnum.DELETED.getCode()));
 
@@ -612,6 +639,8 @@ public class AdPlanServiceImpl extends ServiceImpl<AdPlanMapper, AdPlan> impleme
                     map.put("scriptName", dictTree.getName());
                     result.add(map);
                 }
+            }
+
             if (StrUtil.isBlank(scriptType)) {
                 if (adPlan.getDatasourceId().contains(DataSourceEnum.WAVE_DATA.getValue())) {
                     Map<String, String> map = new HashMap<>();
@@ -911,8 +940,25 @@ public class AdPlanServiceImpl extends ServiceImpl<AdPlanMapper, AdPlan> impleme
         // 0-解绑、1-绑定
         if (param.getBindFlag().equals(1)) {
             pqDevService.lambdaUpdate().set(PqDev::getPlanId, plan.getId()).in(PqDev::getId, param.getDevIds()).update();
+            // 绑定被检设备，若检测计划已检测完成，则修改为检测中
+            if (plan.getTestState().equals(CheckStateEnum.CHECKED.getValue())) {
+                plan.setTestState(CheckStateEnum.CHECKING.getValue());
+                this.updateById(plan);
+            }
         } else {
             pqDevService.lambdaUpdate().set(PqDev::getPlanId, plan.getFatherPlanId()).in(PqDev::getId, param.getDevIds()).update();
+            // 解绑被检设备，若检测计划检测中，且所有设备已检测完成，则修改为检测完成
+            if (plan.getTestState().equals(CheckStateEnum.CHECKING.getValue())) {
+                PqDevParam.QueryParam queryParam = new PqDevParam.QueryParam();
+                queryParam.setPlanIdList(Collections.singletonList(plan.getId()));
+                List<PqDevVO> pqDevVOS = pqDevService.listByPlanId(queryParam);
+                long checkedCount = pqDevVOS.stream().filter(pqDevVO -> pqDevVO.getCheckState().equals(CheckStateEnum.CHECKED.getValue())).count();
+                if (checkedCount == pqDevVOS.size()) {
+                    plan.setTestState(CheckStateEnum.CHECKED.getValue());
+                    this.updateById(plan);
+                }
+
+            }
         }
         return true;
     }
@@ -1769,7 +1815,12 @@ public class AdPlanServiceImpl extends ServiceImpl<AdPlanMapper, AdPlan> impleme
             // 更新检测计划信息
             plan.setImportFlag(1);
             plan.setFatherPlanId(CommonEnum.FATHER_ID.getValue());
-            saveOrUpdate(plan);
+            AdPlan oldPlan = this.getById(plan.getId());
+            // 不存在，则入库
+            if (oldPlan == null) {
+                this.save(plan);
+            }
+
 
             List<PqDev> devList = subPlanMetaDataVO.getDevList();
             List<PqStandardDev> standardDevList = subPlanMetaDataVO.getStandardDevList();
@@ -1781,9 +1832,33 @@ public class AdPlanServiceImpl extends ServiceImpl<AdPlanMapper, AdPlan> impleme
             // 批量更新被检设备信息
             // 设置导入标志为 1
             devList.forEach(dev -> dev.setImportFlag(1));
-            pqDevService.saveOrUpdateBatch(devList);
+            // 排除已存在的，再入库
-            devList.forEach(dev -> {
+            List<String> devIds = devList.stream().map(PqDev::getId).collect(Collectors.toList());
+            List<PqDevSub> pqDevSubs = pqDevSubService.lambdaQuery().in(PqDevSub::getDevId, devIds).list();
+            Map<String, Integer> hadDevMaps = pqDevSubs.stream().collect(Collectors.toMap(PqDevSub::getDevId, PqDevSub::getCheckState));
+            List<PqDev> updateDevList = new ArrayList<>();
+            // 更新被检设备
+            for (Map.Entry<String, Integer> entry : hadDevMaps.entrySet()) {
+                String devId = entry.getKey();
+                Integer checkState = entry.getValue();
+                if (checkState.equals(CheckStateEnum.UNCHECKED.getValue())) {
+                    devList.stream().filter(dev -> dev.getId().equals(devId))
+                            .findFirst().ifPresent(dev -> updateDevList.add(dev));
+                }
+            }
+            if (CollUtil.isNotEmpty(updateDevList)) {
+                pqDevService.updateBatchById(updateDevList);
+                // 更新监测点数据
+                for (PqDev dev : updateDevList) {
                     pqMonitorService.saveOrUpdateBatch(dev.getMonitorList());
+                }
+            }
+            // 新增被检设备
+            List<PqDev> saveDevList = devList.stream().filter(dev -> !hadDevMaps.keySet().contains(dev.getId())).collect(Collectors.toList());
+            if (CollUtil.isNotEmpty(saveDevList)) {
+                pqDevService.saveBatch(saveDevList);
+                saveDevList.forEach(dev -> {
+                    pqMonitorService.saveBatch(dev.getMonitorList());
                     // 新增时默认设置
                     PqDevSub pqDevSub = new PqDevSub();
                     pqDevSub.setDevId(dev.getId());
@@ -1792,17 +1867,24 @@ public class AdPlanServiceImpl extends ServiceImpl<AdPlanMapper, AdPlan> impleme
                     pqDevSub.setCheckState(CheckStateEnum.UNCHECKED.getValue());
                     pqDevSub.setReportState(DevReportStateEnum.UNCHECKED.getValue());
                     pqDevSub.setCheckResult(CheckResultEnum.UNCHECKED.getValue());
-                Integer count = pqDevSubService.lambdaQuery().eq(PqDevSub::getDevId, dev.getId()).count();
-                if (count.intValue() == 0) {
                     pqDevSubService.save(pqDevSub);
-                } else {
-                    pqDevSubService.update(pqDevSub, new LambdaUpdateWrapper<PqDevSub>().eq(PqDevSub::getDevId, dev.getId()));
-                }
                 });
-            List<String> devIds = devList.stream().map(PqDev::getId).collect(Collectors.toList());
+            }
-            // 守时检测
-            pqDevService.updatePqDevTimeCheckResult(devIds, TimeCheckResultEnum.UNKNOWN);
 
+            // 移除未检测的被检设备
+            List<String> uncheckedDevIds = pqDevSubs.stream()
+                    .filter(pqDevSub -> pqDevSub.getCheckState().equals(CheckStateEnum.UNCHECKED.getValue()))
+                    .map(PqDevSub::getDevId)
+                    .collect(Collectors.toList());
+            List<String> removeDevIds = uncheckedDevIds.stream()
+                    .filter(devId -> !devIds.contains(devId))
+                    .collect(Collectors.toList());
+
+            if (CollUtil.isNotEmpty(removeDevIds)) {
+                pqDevService.removeByIds(removeDevIds);
+                pqDevSubService.remove(new LambdaQueryWrapper<PqDevSub>().in(PqDevSub::getDevId, removeDevIds));
+                pqMonitorService.remove(new LambdaQueryWrapper<PqMonitor>().in(PqMonitor::getDevId, removeDevIds));
+            }
             // 批量更新标准设备信息
             pqStandardDevService.saveOrUpdateBatch(standardDevList);
             List<String> standardDevIds = standardDevList.stream().map(PqStandardDev::getId).collect(Collectors.toList());
@@ -2045,6 +2127,7 @@ public class AdPlanServiceImpl extends ServiceImpl<AdPlanMapper, AdPlan> impleme
 
     /**
      * 比对模式下计划的检测项获取
+     *
      * @param planId 计划ID
      * @return 检测项
      */

detection/src/main/java/com/njcn/gather/report/pojo/enums/PowerIndexEnum.java

@@ -26,7 +26,8 @@ public enum PowerIndexEnum {
     HI("HI", "谐波电流"),
     HSV("HSV", "间谐波电压"),
     HSI("HSI", "间谐波电流"),
-    VOLTAGE("VOLTAGE", "电压暂降、暂升及短时中断");
+    VOLTAGE("VOLTAGE", "电压暂降、暂升及短时中断"),
+    PST("PST", "短时间闪变");
 
     private String key;
 

detection/src/main/java/com/njcn/gather/result/service/impl/ResultServiceImpl.java

@@ -30,7 +30,6 @@ import com.njcn.gather.detection.pojo.vo.DetectionData;
 import com.njcn.gather.detection.service.IAdPariService;
 import com.njcn.gather.detection.service.impl.DetectionServiceImpl;
 import com.njcn.gather.detection.util.socket.CnSocketUtil;
-import com.njcn.gather.detection.util.socket.FormalTestManager;
 import com.njcn.gather.device.pojo.enums.CommonEnum;
 import com.njcn.gather.device.pojo.enums.PatternEnum;
 import com.njcn.gather.device.pojo.po.PqDev;
@@ -1615,7 +1614,12 @@ public class ResultServiceImpl implements IResultService {
 
         List<PqMonitor> pqMonitorList = pqMonitorService.lambdaQuery().eq(PqMonitor::getDevId, devId).isNotNull(PqMonitor::getResultType).list();
         List<MonitorResultVO> list = new ArrayList<>();
+        if (CollUtil.isEmpty(pqMonitorList)) {
+            return list;
+        }
         MonitorResultVO result;
+        // 根据通道号排序
+        pqMonitorList.sort(Comparator.comparing(PqMonitor::getNum));
         for (PqMonitor pqMonitor : pqMonitorList) {
             result = new MonitorResultVO();
             result.setMonitorId(pqMonitor.getDevId() + CnSocketUtil.SPLIT_TAG + pqMonitor.getNum());
@@ -1675,38 +1679,84 @@ public class ResultServiceImpl implements IResultService {
         }
         AdPlan finalPlan = plan;
         // 实时数据结果
-        List<ContrastNonHarmonicResult> nonHarmonicResults = contrastNonHarmonicService.listAllResultData(String.valueOf(finalPlan.getCode()), null, null, false, monitorId, null);
+        List<ContrastNonHarmonicResult> realNonHarmonicResults = contrastNonHarmonicService.listAllResultData(String.valueOf(finalPlan.getCode()), null, null, false, monitorId, null);
-        Map<Integer, List<ContrastNonHarmonicResult>> numMap = nonHarmonicResults.stream()
+        Map<Integer, List<ContrastNonHarmonicResult>> numNonHarmonicMap = realNonHarmonicResults.stream()
                 .sorted(Comparator.comparing(ContrastNonHarmonicResult::getNum))
                 .collect(Collectors.groupingBy(ContrastNonHarmonicResult::getNum, LinkedHashMap::new, Collectors.toList()));
 
+        List<ContrastHarmonicResult> realHarmonicResults = contrastHarmonicService.listAllResultData(String.valueOf(finalPlan.getCode()), null, null, false, monitorId, null);
+        Map<Integer, List<ContrastHarmonicResult>> numHarmonicMap = realHarmonicResults.stream()
+                .sorted(Comparator.comparing(ContrastHarmonicResult::getNum))
+                .collect(Collectors.groupingBy(ContrastHarmonicResult::getNum, LinkedHashMap::new, Collectors.toList()));
 
-        numMap.forEach((num, resultList) -> {
+        Map<Integer, List<Integer>> numResutMap = new TreeMap<>();
+        numNonHarmonicMap.forEach((num, resultList) -> {
+            numResutMap.put(num, resultList.stream().map(ContrastNonHarmonicResult::getResultFlag).distinct().collect(Collectors.toList()));
+        });
+        numHarmonicMap.forEach((num, resultList) -> {
+            List<Integer> list = numResutMap.getOrDefault(num, new ArrayList<>());
+            list.addAll(resultList.stream().map(ContrastHarmonicResult::getResultFlag).distinct().collect(Collectors.toList()));
+            numResutMap.put(num, list);
+        });
+
+        numResutMap.forEach((num, resultList) -> {
             List<DataSourceResultVO> dataSourceResultVOList = new ArrayList<>();
-
             DataSourceResultVO realDataSourceResultVO = new DataSourceResultVO();
             realDataSourceResultVO.setDataSourceCode(DataSourceEnum.REAL_DATA.getValue());
             realDataSourceResultVO.setDataSourceName(DataSourceEnum.REAL_DATA.getMsg());
-            List<Integer> resultFlagList = resultList.stream().map(ContrastNonHarmonicResult::getResultFlag).distinct().collect(Collectors.toList());
+            realDataSourceResultVO.setCheckResult(StorageUtil.getInteger(resultList));
-            realDataSourceResultVO.setCheckResult(StorageUtil.getInteger(resultFlagList));
             dataSourceResultVOList.add(realDataSourceResultVO);
 
+            result.put(num, dataSourceResultVOList);
+        });
+
+        Map<Integer, Map<Integer, List<Integer>>> waveNumMap = new TreeMap<>();
+
         // 录波数据结果
-            List<ContrastNonHarmonicResult> waveNonHarmonicResults = contrastNonHarmonicService.listAllResultData(String.valueOf(finalPlan.getCode()), num, null, true, monitorId, null);
+        List<ContrastNonHarmonicResult> waveNonHarmonicResults = contrastNonHarmonicService.listAllResultData(String.valueOf(finalPlan.getCode()), null, null, true, monitorId, null);
-            Map<Integer, List<ContrastNonHarmonicResult>> waveNumMap = waveNonHarmonicResults.stream()
+        Map<Integer, List<ContrastNonHarmonicResult>> waveNumNonHarmonicMap = waveNonHarmonicResults.stream()
+                .sorted(Comparator.comparing(ContrastNonHarmonicResult::getNum))
+                .collect(Collectors.groupingBy(ContrastNonHarmonicResult::getNum, LinkedHashMap::new, Collectors.toList()));
+        List<ContrastHarmonicResult> waveHarmonicResults = contrastHarmonicService.listAllResultData(String.valueOf(finalPlan.getCode()), null, null, true, monitorId, null);
+        Map<Integer, List<ContrastHarmonicResult>> waveNumHarmonicMap = waveHarmonicResults.stream()
+                .sorted(Comparator.comparing(ContrastHarmonicResult::getNum))
+                .collect(Collectors.groupingBy(ContrastHarmonicResult::getNum, LinkedHashMap::new, Collectors.toList()));
+
+        waveNumNonHarmonicMap.forEach((num, resultList) -> {
+            LinkedHashMap<Integer, List<ContrastNonHarmonicResult>> collect = resultList.stream()
                     .sorted(Comparator.comparing(ContrastNonHarmonicResult::getWaveNum))
                     .collect(Collectors.groupingBy(ContrastNonHarmonicResult::getWaveNum, LinkedHashMap::new, Collectors.toList()));
 
-            waveNumMap.forEach((waveNum, resultList1) -> {
+            Map<Integer, List<Integer>> map = new TreeMap<>();
+            collect.forEach((waveNum, resultList1) -> {
+                map.put(waveNum, resultList1.stream().map(ContrastNonHarmonicResult::getResultFlag).distinct().collect(Collectors.toList()));
+            });
+            waveNumMap.put(num, map);
+        });
+
+        waveNumHarmonicMap.forEach((num, resultList) -> {
+            Map<Integer, List<Integer>> map = waveNumMap.getOrDefault(num, new TreeMap<>());
+
+            LinkedHashMap<Integer, List<ContrastHarmonicResult>> collect = resultList.stream().sorted(Comparator.comparing(ContrastHarmonicResult::getWaveNum))
+                    .collect(Collectors.groupingBy(ContrastHarmonicResult::getWaveNum, LinkedHashMap::new, Collectors.toList()));
+            collect.forEach((waveNum, resultList1) -> {
+                List<Integer> list = map.getOrDefault(waveNum, new ArrayList<>());
+                list.addAll(resultList1.stream().map(ContrastHarmonicResult::getResultFlag).distinct().collect(Collectors.toList()));
+                map.put(waveNum, list);
+            });
+            waveNumMap.put(num, map);
+        });
+
+        waveNumMap.forEach((num, map) -> {
+            List<DataSourceResultVO> orDefault = result.getOrDefault(num, new ArrayList<>());
+            map.forEach((waveNum, resultList) -> {
                 DataSourceResultVO waveDataSourceResultVO = new DataSourceResultVO();
                 waveDataSourceResultVO.setDataSourceCode(DataSourceEnum.WAVE_DATA.getValue() + CnSocketUtil.SPLIT_TAG + waveNum);
                 waveDataSourceResultVO.setDataSourceName(DataSourceEnum.WAVE_DATA.getMsg() + StrUtil.SPACE + waveNum);
-                List<Integer> tempResultFlagList = resultList1.stream().map(ContrastNonHarmonicResult::getResultFlag).distinct().collect(Collectors.toList());
+                waveDataSourceResultVO.setCheckResult(StorageUtil.getInteger(resultList));
-                waveDataSourceResultVO.setCheckResult(StorageUtil.getInteger(tempResultFlagList));
+                orDefault.add(waveDataSourceResultVO);
-                dataSourceResultVOList.add(waveDataSourceResultVO);
             });
-
+            result.put(num, orDefault);
-            result.put(num, dataSourceResultVOList);
         });
 
         return result;
@@ -2006,6 +2056,7 @@ public class ResultServiceImpl implements IResultService {
 
     /**
      * 判断值是否为零
+     *
      * @param value 字符串值
      * @return 是否为零
      */
@@ -2023,6 +2074,7 @@ public class ResultServiceImpl implements IResultService {
 
     /**
      * 生成谐波类特殊情况描述
+     *
      * @param zeroFilteredMap    双零过滤的次数和相别
      * @param unComparableMap    无法比较的次数和相别
      * @param unqualifiedMap     不符合的次数和相别
@@ -2143,6 +2195,7 @@ public class ResultServiceImpl implements IResultService {
 
     /**
      * 获取显示用的谐波次数
+     *
      * @param harmNum         原始次数（2-50）
      * @param isInterHarmonic 是否为间谐波
      * @return 显示用的次数字符串
@@ -2162,6 +2215,7 @@ public class ResultServiceImpl implements IResultService {
 
     /**
      * 格式化谐波次数列表
+     *
      * @param harmNumbers     谐波次数列表
      * @param isInterHarmonic 是否为间谐波
      * @return 格式化的字符串，如"2、3、5"或"2-5、7、9-11"（间谐波为"1.5、2.5、3.5"）
@@ -2984,13 +3038,35 @@ public class ResultServiceImpl implements IResultService {
 
         AdPlan plan = adPlanService.getById(planId);
 
+        String dataSourceId = plan.getDatasourceId();
+        String[] dataSourceIds = dataSourceId.split(StrUtil.COMMA);
+
+        DataSourceEnum nonWaveDataSourceEnum = DataSourceEnum.REAL_DATA;
+        for (String ds : dataSourceIds) {
+            switch (DataSourceEnum.valueOf(ds)) {
+                case MINUTE_STATISTICS_MIN:
+                    nonWaveDataSourceEnum = DataSourceEnum.MINUTE_STATISTICS_MIN;
+                    break;
+                case MINUTE_STATISTICS_MAX:
+                    nonWaveDataSourceEnum = DataSourceEnum.MINUTE_STATISTICS_MAX;
+                    break;
+                case MINUTE_STATISTICS_AVG:
+                    nonWaveDataSourceEnum = DataSourceEnum.MINUTE_STATISTICS_AVG;
+                    break;
+                case MINUTE_STATISTICS_CP95:
+                    nonWaveDataSourceEnum = DataSourceEnum.MINUTE_STATISTICS_CP95;
+                    break;
+            }
+        }
+        DataSourceEnum finalNonWaveDataSourceEnum = nonWaveDataSourceEnum;
+
         BiMap<String, String> testItemMap = HashBiMap.create();
         List<String> testItemIds = Arrays.asList(plan.getTestItem().split(","));
         List<DictTree> dictTreeList = dictTreeService.getDictTreeById(testItemIds);
         List<String> fatherIdList = dictTreeList.stream().map(DictTree::getId).collect(Collectors.toList());
         List<DictTree> childDictTreeList = dictTreeService.listByFatherIds(fatherIdList);
         if (CollUtil.isNotEmpty(childDictTreeList)) {
-            List<String> collect1 = SocketContrastResponseService.testItemCodeMap.values().stream().flatMap(Collection::stream).map(x -> x.split("\\$")[1]).collect(Collectors.toList());
+            List<String> collect1 = SocketContrastResponseService.testItemCodeMap.values().stream().flatMap(Collection::stream).collect(Collectors.toList());
             testItemMap.putAll(childDictTreeList.stream().filter(x -> collect1.contains(x.getCode())).collect(Collectors.toMap(obj -> DetectionCodeEnum.REAL_PREFIX.getCode() + obj.getCode(), obj -> obj.getId())));
         }
 
@@ -3015,6 +3091,7 @@ public class ResultServiceImpl implements IResultService {
                 .update();
         List<AdPair> adPairList = adPairService.listByDevIds(Arrays.asList(deviceId));
         Map<Integer, List<AdPair>> numAdPairsMap = adPairList.stream().collect(Collectors.groupingBy(AdPair::getNum, Collectors.toList()));
+
         numAdPairsMap.forEach((num, pairList) -> {
             BiMap<String, String> parsIp = HashBiMap.create();
             BiMap<String, String> parsId = HashBiMap.create();
@@ -3040,11 +3117,11 @@ public class ResultServiceImpl implements IResultService {
             List<DevData> devData = contrastToList(devNonHarmonicRawDataList, devHarmonicRawDataList, testItemMap);
             List<DevData> standardDevData = contrastToList(stdDevNonHarmonicRawDataList, stdDevHarmonicRawDataList, testItemMap);
 
-            detectionServiceImpl.processing(devData, standardDevData, parsIp, devIdMapComm, testItemMap.keySet().stream().collect(Collectors.toList()), errorSysId, dataRule, numMap, code, null);
+            detectionServiceImpl.processing(devData, standardDevData, parsIp, devIdMapComm, testItemMap.keySet().stream().collect(Collectors.toList()), errorSysId, dataRule, numMap, code, null, finalNonWaveDataSourceEnum);
 
             parsId.forEach((devMonitorId, stdDevMonitorId) -> {
                 String[] split = devMonitorId.split(CnSocketUtil.SPLIT_TAG);
-                pqMonitorService.updateMonitorResult(devMonitorId, null, DataSourceEnum.REAL_DATA, num, null, oldCode);
+                pqMonitorService.updateMonitorResult(devMonitorId, null, finalNonWaveDataSourceEnum, num, null, oldCode);
                 pqDevService.updateResult(split[0], null);
             });
 
@@ -3057,12 +3134,12 @@ public class ResultServiceImpl implements IResultService {
 
                 devData = contrastToList(devNonHarmonicRawDataList, devHarmonicRawDataList, testItemMap);
                 standardDevData = contrastToList(stdDevNonHarmonicRawDataList, stdDevHarmonicRawDataList, testItemMap);
-                detectionServiceImpl.processing(devData, standardDevData, parsIp, devIdMapComm, testItemMap.keySet().stream().collect(Collectors.toList()), errorSysId, dataRule, numMap, oldCode, i);
+                detectionServiceImpl.processing(devData, standardDevData, parsIp, devIdMapComm, testItemMap.keySet().stream().collect(Collectors.toList()), errorSysId, dataRule, numMap, oldCode, i, DataSourceEnum.WAVE_DATA);
             }
 
             parsId.forEach((devMonitorId, stdDevMonitorId) -> {
                 String[] split = devMonitorId.split(CnSocketUtil.SPLIT_TAG);
-                pqMonitorService.updateMonitorResult(devMonitorId, null, DataSourceEnum.WAVE_DATA, num, adPlanTestConfig.getWaveRecord(), oldCode);
+                pqMonitorService.updateMonitorResult(devMonitorId, null, finalNonWaveDataSourceEnum, num, adPlanTestConfig.getWaveRecord(), oldCode);
                 pqDevService.updateResult(split[0], null);
             });
         });

pom.xml

@@ -13,7 +13,7 @@
         <module>user</module>
         <module>detection</module>
         <module>storage</module>
-        <module>event_smart</module>
+<!--        <module>event_smart</module>-->
         <module>tools</module>
     </modules>
     <packaging>pom</packaging>

storage/src/main/java/com/njcn/gather/storage/service/impl/DetectionDataServiceImpl.java

@@ -166,9 +166,12 @@ public class DetectionDataServiceImpl extends ReplenishMybatisServiceImpl<Detect
             DynamicTableNameHandler.setTableName("ad_non_harmonic_result_" + code);
             LambdaQueryWrapper<ContrastNonHarmonicResult> wrapper1 = new LambdaQueryWrapper<ContrastNonHarmonicResult>()
                     .in(CollUtil.isNotEmpty(adType), ContrastNonHarmonicResult::getAdType, adType);
+            wrapper1.and(w -> {
                 for (String id : ids) {
-                wrapper1.like(ContrastNonHarmonicResult::getDevMonitorId, id);
+                    w.or().like(ContrastNonHarmonicResult::getDevMonitorId, id);
                 }
+            });
+
             List<ContrastNonHarmonicResult> nonHarmonicResultList = contrastNonHarmonicService.list(wrapper1);
             Map<String, List<ContrastNonHarmonicResult>> chnMap1 = nonHarmonicResultList.stream().collect(Collectors.groupingBy(x -> x.getDevMonitorId().split("_")[1], Collectors.toList()));
             chnMap1.forEach((chn, vList) -> {
@@ -181,9 +184,12 @@ public class DetectionDataServiceImpl extends ReplenishMybatisServiceImpl<Detect
             DynamicTableNameHandler.setTableName("ad_harmonic_result_" + code);
             LambdaQueryWrapper<ContrastHarmonicResult> wrapper2 = new LambdaQueryWrapper<ContrastHarmonicResult>()
                     .in(CollUtil.isNotEmpty(adType), ContrastHarmonicResult::getAdType, adType);
+            wrapper2.and(w -> {
                 for (String id : ids) {
-                wrapper2.like(ContrastHarmonicResult::getDevMonitorId, id);
+                    w.like(ContrastHarmonicResult::getDevMonitorId, id);
                 }
+            });
+
             List<ContrastHarmonicResult> harmonicResultList = contrastHarmonicService.list(wrapper2);
             Map<String, List<ContrastHarmonicResult>> chnMap2 = harmonicResultList.stream().collect(Collectors.groupingBy(x -> x.getDevMonitorId().split("_")[1], Collectors.toList()));
             chnMap2.forEach((chn, vList) -> {