Merge remote-tracking branch 'origin/master'

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/pom.xml

@@ -139,6 +139,12 @@
             <artifactId>report-generator</artifactId>
             <version>1.0.0</version>
         </dependency>
+        <!--激活工具-->
+        <dependency>
+            <groupId>com.njcn.gather</groupId>
+            <artifactId>activate-tool</artifactId>
+            <version>1.0.0</version>
+        </dependency>
     </dependencies>
 
 

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();
@@ -1371,7 +1371,7 @@ public class SocketDevResponseService {
                             checkDataParam.setIsValueTypeName(false);
                             List<String> valueType = iPqScriptCheckDataService.getValueType(checkDataParam);
 
-                            iPqDevService.updateResult( param.getDevIds(), valueType, param.getCode(), param.getUserId(), param.getTemperature(), param.getHumidity());
+                            iPqDevService.updateResult(param.getDevIds(), valueType, param.getCode(), param.getUserId(), param.getTemperature(), param.getHumidity());
                             CnSocketUtil.quitSend(param);
                         }
                         successComm.clear();

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","关闭设备通讯初始化"),
@@ -67,6 +67,8 @@ public enum SourceOperateCodeEnum {
     SERVER_ERROR("server_error","服务端主动关闭连接,请稍后再试"),
     DEVICE_ERROR("device_error","设备主动关闭连接,请稍后再试"),
 
+    FLICKER_DATA_CHECK("flicker_data_check","闪变数据校验"),
+
 
 
 

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

@@ -42,7 +42,9 @@ 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,"统计数据校验失败"),
+    FLICKER_DATA_START(25007,"开始接收闪变数据")
 
 
 

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();
@@ -1610,12 +1612,12 @@ public class DetectionServiceImpl {
 //                                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.F.getKey(), isQualified(devDataList, standardDevDataList, devIdMapComm, pqErrSysDtls, true, fUn , DetectionCodeEnum.PST.getCode(), dataRule, num, code, oneConfig.getScale(), waveNum, DataSourceEnum.MINUTE_STATISTICS_AVG));
                         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 = "";
@@ -1840,6 +1852,9 @@ public class DetectionServiceImpl {
             }
 
             Map<String, List<Map<Double, List<Double>>>> devMap = devHarmListMap(devDataList, standardDevDataList, fundCode, harmCode, harmonicFlag, dataRule);
+            if (ObjectUtil.isNull(devMap)) {
+                return 4;
+            }
             ContrastHarmonicResult result = new ContrastHarmonicResult();
             result.setWaveNum(waveNum);
 
@@ -1849,14 +1864,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 +1918,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()));
@@ -2090,9 +2109,12 @@ public class DetectionServiceImpl {
                 fund2 = first2.get();
             }
 
-            List<DevData.SqlDataHarmDTO> devHarmList = dev.get(i).getSqlDataHarm().stream().filter(x -> x.getDesc().equals(harmCode)).collect(Collectors.toList());
+            List<DevData.SqlDataHarmDTO> devHarmList = dev.get(i).getSqlDataHarm().stream().filter(x -> harmCode.equals(x.getDesc())).collect(Collectors.toList());
-            List<DevData.SqlDataHarmDTO> stdDevHarmList = standardDev.get(i).getSqlDataHarm().stream().filter(x -> x.getDesc().equals(harmCode)).collect(Collectors.toList());
+            List<DevData.SqlDataHarmDTO> stdDevHarmList = standardDev.get(i).getSqlDataHarm().stream().filter(x -> harmCode.equals(x.getDesc())).collect(Collectors.toList());
 
+            if (CollUtil.isEmpty(devHarmList) || CollUtil.isEmpty(stdDevHarmList)) {
+                return null;
+            }
 //            // 如果角型接法中，不存在线电压谐波电压含有率，则取相电压谐波电压含有率进行计算
 //            if (CollUtil.isEmpty(devHarmList)) {
 //                if (DetectionCodeEnum.PV2_50.getCode().equals(harmCode)) {

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());
-        socketMsg.setOperateCode(SourceOperateCodeEnum.DEV_INIT_GATHER_02.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,24 +128,33 @@ 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);
+                if (devSeconds.compareTo(standardSeconds) == 0) {
+                    return true;
+                }
 
-            // 方式1：将时间戳转换为秒级精度进行比较（处理跨秒边界情况）
+                // 方式2：毫秒级时间差小于容差值也认为是对齐的（处理精确对齐）
-            BigDecimal devSeconds = BigDecimal.valueOf(devMillis).divide(BigDecimal.valueOf(MILLIS_TO_SECONDS), 0, RoundingMode.HALF_UP);
+                if (Math.abs(devMillis - standardMillis) < TIME_ALIGNMENT_TOLERANCE_MS) {
-            BigDecimal standardSeconds = BigDecimal.valueOf(standardMillis).divide(BigDecimal.valueOf(MILLIS_TO_SECONDS), 0, RoundingMode.HALF_UP);
+                    return true;
-            if (devSeconds.compareTo(standardSeconds) == 0) {
+                }
-                return true;
             }
-
+            if (type == 2) { //统计数据
-            // 方式2：毫秒级时间差小于容差值也认为是对齐的（处理精确对齐）
+                BigDecimal devSeconds = BigDecimal.valueOf(devMillis).divide(BigDecimal.valueOf(MILLIS_TO_MINUTES), 0, RoundingMode.HALF_UP);
-            if (Math.abs(devMillis - standardMillis) < TIME_ALIGNMENT_TOLERANCE_MS) {
+                BigDecimal standardSeconds = BigDecimal.valueOf(standardMillis).divide(BigDecimal.valueOf(MILLIS_TO_MINUTES), 0, RoundingMode.HALF_UP);
-                return true;
+                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,31 @@ public class FormalTestManager {
      */
     public static List<DevLineTestResult> preNumTestResultList = new ArrayList<>();
 
+    /**
+     * 定时器
+     */
+    public static ScheduledExecutorService scheduler;
+
+    /**
+     * 定时器任务
+     */
+    public static ScheduledFuture<?> scheduledFuture;
+
+
+    public static boolean isWaveCheck;
+
+    public static List<String> pstDataType;
+
+    public static boolean isPstData;
+
+    /**
+     * 是否在检测中
+     */
+    public static boolean isTesting;
+
+    public static boolean realProtocol;
+
+    public static boolean statisticsProtocol;
+
+    public static boolean voltageProtocol;
 }

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);
+//                CnSocketUtil.contrastSendquit(param.getUserPageId(), SourceOperateCodeEnum.QUIT_INIT_03, true);
-            } else {
+//            } else {
-                CnSocketUtil.contrastSendquit(param.getUserPageId(), SourceOperateCodeEnum.QUIT_INIT_02, true);
+//                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);
         }
     }
 
@@ -85,18 +88,35 @@ public class NettyContrastClientHandler extends SimpleChannelInboundHandler<Stri
     public void userEventTriggered(ChannelHandlerContext ctx, Object evt) {
         if (evt instanceof IdleStateEvent) { //IdleState.在一段时间内没有收到任何消息时，会触发该事件
             if (((IdleStateEvent) evt).state() == IdleState.READER_IDLE) {
-                System.out.println(LocalDateTime.now() + "contrastClientHandler触发读超时函数**************************************");
+                if (FormalTestManager.isTesting) {
-                SocketManager.contrastClockMap.put(DataSourceEnum.REAL_DATA, SocketManager.contrastClockMap.get(DataSourceEnum.REAL_DATA) + 60L);
+                    System.out.println(LocalDateTime.now() + "contrastClientHandler触发读超时函数**************************************");
 
-                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 (FormalTestManager.isPstData) {
-                        timeoutSend();
+                            if (time > 60 * 10) {
+                                if (DataSourceEnum.REAL_DATA == FormalTestManager.nonWaveDataSourceEnum) {
+                                    CnSocketUtil.contrastSendquit(param.getUserPageId(), SourceOperateCodeEnum.QUIT_INIT_02, true);
+                                }
+                                if (FormalTestManager.isWaveCheck) {
+                                    CnSocketUtil.contrastSendquit(param.getUserPageId(), SourceOperateCodeEnum.QUIT_INIT_03, true);
+                                }
+                                CnSocketUtil.contrastSendquit(param.getUserPageId(), SourceOperateCodeEnum.QUIT_INIT_01, true);
+                                timeoutSend(SourceOperateCodeEnum.QUIT_INIT_01);
+                            }
+                        } else if (DataSourceEnum.REAL_DATA == FormalTestManager.nonWaveDataSourceEnum) {
+                            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_01, true);
+                            timeoutSend(SourceOperateCodeEnum.QUIT_INIT_01);
+                        }
                     }
                 }
-
             }
         }
     }
@@ -126,8 +146,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 +156,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,37 @@ 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, false);
+                        } 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);
+                                    if (FormalTestManager.statisticsProtocol) {
+                                        CnSocketUtil.contrastSendquit(preDetectionParam.getUserPageId(), SourceOperateCodeEnum.QUIT_INIT_01, false);
+                                    }
+                                } else {
+                                    CnSocketUtil.contrastSendquit(preDetectionParam.getUserPageId(), SourceOperateCodeEnum.QUIT_INIT_01, false);
+                                }
+                                if (FormalTestManager.isWaveCheck) {
+                                    CnSocketUtil.contrastSendquit(preDetectionParam.getUserPageId(), SourceOperateCodeEnum.QUIT_INIT_03, false);
+                                }
+                            } else {
+                                if (FormalTestManager.statisticsProtocol) {
+                                    CnSocketUtil.contrastSendquit(preDetectionParam.getUserPageId(), SourceOperateCodeEnum.QUIT_INIT_01, false);
+                                }
+                                if (FormalTestManager.isWaveCheck) {
+                                    CnSocketUtil.contrastSendquit(preDetectionParam.getUserPageId(), SourceOperateCodeEnum.QUIT_INIT_02, false);
+                                    CnSocketUtil.contrastSendquit(preDetectionParam.getUserPageId(), SourceOperateCodeEnum.QUIT_INIT_03, false);
+                                }
+                            }
+                        } 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());
-                excludePlanIds.addAll(excludeMainPlanIds);
+                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/err/service/impl/PqErrSysServiceImpl.java

@@ -9,6 +9,7 @@ import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
 import com.njcn.common.pojo.enums.common.DataStateEnum;
 import com.njcn.common.pojo.exception.BusinessException;
+import com.njcn.gather.detection.pojo.enums.DetectionCodeEnum;
 import com.njcn.gather.err.mapper.PqErrSysMapper;
 import com.njcn.gather.err.pojo.param.PqErrSysDtlsParam;
 import com.njcn.gather.err.pojo.param.PqErrSysParam;
@@ -18,6 +19,7 @@ import com.njcn.gather.err.pojo.vo.PqErrSysDtlsVO;
 import com.njcn.gather.err.service.IPqErrSysDtlsService;
 import com.njcn.gather.err.service.IPqErrSysService;
 import com.njcn.gather.pojo.enums.DetectionResponseEnum;
+import com.njcn.gather.report.pojo.enums.PowerIndexEnum;
 import com.njcn.gather.system.dictionary.pojo.po.DictData;
 import com.njcn.gather.system.dictionary.pojo.po.DictTree;
 import com.njcn.gather.system.dictionary.service.IDictDataService;
@@ -219,7 +221,9 @@ public class PqErrSysServiceImpl extends ServiceImpl<PqErrSysMapper, PqErrSys> i
             List<DictTree> parentDictTreeList = dictTreeService.listByIds(pids);
             Map<String, String> map = new HashMap<>();
             parentDictTreeList.forEach(dictTree -> {
-                map.put(dictTree.getId(), dictTree.getName());
+                if(!dictTree.getCode().equals(PowerIndexEnum.VOLTAGE.getKey())&&!dictTree.getCode().equals(PowerIndexEnum.P.getKey())){
+                    map.put(dictTree.getId(), dictTree.getName());
+                }
             });
             return map;
         }

detection/src/main/java/com/njcn/gather/monitor/pojo/param/PqMonitorParam.java

@@ -52,7 +52,7 @@ public class PqMonitorParam {
     private Integer statInterval;
 
     @ApiModelProperty(value = "谐波系统监测点id")
-    @NotBlank(message = DetectionValidMessage.MONITOR_ID_NOT_BLANK)
+//    @NotBlank(message = DetectionValidMessage.MONITOR_ID_NOT_BLANK)
     private String harmSysId;
 
     @ApiModelProperty(value = "是否做检测")

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

@@ -148,12 +148,9 @@ 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)){
+                if (CollUtil.isEmpty(waveNumResultMap)) {
                     return true;
                 }
                 waveNumResultMap.forEach((key, value) -> {
@@ -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();
-        queryParam1.setPlanIdList(Collections.singletonList(adPlan.getId()));
+        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,16 +623,24 @@ public class AdPlanServiceImpl extends ServiceImpl<AdPlanMapper, AdPlan> impleme
         }
         DictData dictData = dictDataService.getById(patternId);
         if (PatternEnum.CONTRAST.getValue().equals(dictData.getCode())) {
-            String[] split = adPlan.getTestItem().split(StrUtil.COMMA);
+            String datasourceId = adPlan.getDatasourceId();
-            List<DictTree> dictTreeList = dictTreeService.list(new QueryWrapper<DictTree>().in("id", split).eq("state", DataStateEnum.DELETED.getCode()));
+            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()).orderByAsc("sort"));
 
-            for (DictTree dictTree : dictTreeList) {
+                for (DictTree dictTree : dictTreeList) {
-                Map<String, String> map = new HashMap<>();
+                    Map<String, String> map = new HashMap<>();
-                map.put("id", dictTree.getId());
+                    map.put("id", dictTree.getId());
-                map.put("code", dictTree.getCode());
+                    map.put("code", dictTree.getCode());
-                map.put("scriptName", dictTree.getName());
+                    map.put("scriptName", dictTree.getName());
-                result.add(map);
+                    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,28 +1832,59 @@ public class AdPlanServiceImpl extends ServiceImpl<AdPlanMapper, AdPlan> impleme
             // 批量更新被检设备信息
             // 设置导入标志为 1
             devList.forEach(dev -> dev.setImportFlag(1));
-            pqDevService.saveOrUpdateBatch(devList);
+            // 排除已存在的，再入库
-            devList.forEach(dev -> {
-                pqMonitorService.saveOrUpdateBatch(dev.getMonitorList());
-                // 新增时默认设置
-                PqDevSub pqDevSub = new PqDevSub();
-                pqDevSub.setDevId(dev.getId());
-                pqDevSub.setTimeCheckResult(TimeCheckResultEnum.UNKNOWN.getValue());
-                pqDevSub.setFactorCheckResult(FactorCheckResultEnum.UNKNOWN.getValue());
-                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());
-            // 守时检测
+            List<PqDevSub> pqDevSubs = pqDevSubService.lambdaQuery().in(PqDevSub::getDevId, devIds).list();
-            pqDevService.updatePqDevTimeCheckResult(devIds, TimeCheckResultEnum.UNKNOWN);
+            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());
+                    pqDevSub.setTimeCheckResult(TimeCheckResultEnum.UNKNOWN.getValue());
+                    pqDevSub.setFactorCheckResult(FactorCheckResultEnum.UNKNOWN.getValue());
+                    pqDevSub.setCheckState(CheckStateEnum.UNCHECKED.getValue());
+                    pqDevSub.setReportState(DevReportStateEnum.UNCHECKED.getValue());
+                    pqDevSub.setCheckResult(CheckResultEnum.UNCHECKED.getValue());
+                    pqDevSubService.save(pqDevSub);
+                });
+            }
 
+            // 移除未检测的被检设备
+            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 检测项
      */
@@ -2055,7 +2138,7 @@ public class AdPlanServiceImpl extends ServiceImpl<AdPlanMapper, AdPlan> impleme
         String pattern = adPlan.getPattern();
         DictData dictData = dictDataService.getDictDataById(pattern);
         if (ObjectUtil.isNotNull(dictData)) {
-            if(dictData.getCode().equalsIgnoreCase("Contrast")){
+            if (dictData.getCode().equalsIgnoreCase("Contrast")) {
                 String[] items = adPlan.getTestItem().split(",");
                 scriptList = new ArrayList<>(Arrays.asList(items));
             }

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;
@@ -100,6 +99,8 @@ import java.util.function.Function;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
+import static com.njcn.gather.plan.pojo.enums.DataSourceEnum.*;
+
 /**
  * @author caozehui
  * @data 2024-12-30
@@ -112,6 +113,7 @@ public class ResultServiceImpl implements IResultService {
     private final IAdPlanService adPlanService;
     private final IAdPlanTestConfigService adPlanTestConfigService;
     private final IPqDevService pqDevService;
+    private final IPqStandardDevService pqStandardDevService;
     private final SimAndDigNonHarmonicService simAndDigNonHarmonicService;
     private final SimAndDigHarmonicService simAndDigHarmonicService;
     private final ContrastHarmonicService contrastHarmonicService;
@@ -1615,7 +1617,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 +1682,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);
-            List<ContrastNonHarmonicResult> waveNonHarmonicResults = contrastNonHarmonicService.listAllResultData(String.valueOf(finalPlan.getCode()), num, null, true, monitorId, null);
+        });
-            Map<Integer, List<ContrastNonHarmonicResult>> waveNumMap = waveNonHarmonicResults.stream()
+
+        Map<Integer, Map<Integer, List<Integer>>> waveNumMap = new TreeMap<>();
+
+        // 录波数据结果
+        List<ContrastNonHarmonicResult> waveNonHarmonicResults = contrastNonHarmonicService.listAllResultData(String.valueOf(finalPlan.getCode()), null, null, true, monitorId, null);
+        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;
@@ -1945,13 +1998,13 @@ public class ResultServiceImpl implements IResultService {
                                     if ("无法比较".equals(resultTemp)) {
                                         String numOfDataStr = singlePhaseData.get(ItemReportKeyEnum.NUM_OF_DATA.getKey());
                                         unComparableMap.computeIfAbsent(harmNum, k -> new LinkedHashMap<>())
-                                                      .computeIfAbsent(numOfDataStr, k -> new ArrayList<>())
+                                                .computeIfAbsent(numOfDataStr, k -> new ArrayList<>())
-                                                      .add(phase.toUpperCase() + "相");
+                                                .add(phase.toUpperCase() + "相");
                                     } else if ("不符合".equals(resultTemp)) {
                                         String numOfDataStr = singlePhaseData.get(ItemReportKeyEnum.NUM_OF_DATA.getKey());
                                         unqualifiedMap.computeIfAbsent(harmNum, k -> new LinkedHashMap<>())
-                                                     .computeIfAbsent(numOfDataStr, k -> new ArrayList<>())
+                                                .computeIfAbsent(numOfDataStr, k -> new ArrayList<>())
-                                                     .add(phase.toUpperCase() + "相");
+                                                .add(phase.toUpperCase() + "相");
                                     }
                                 }
                             }
@@ -1983,7 +2036,7 @@ public class ResultServiceImpl implements IResultService {
 
             // 生成specialCase描述
             String specialCase = generateHarmonicSpecialCase(zeroFilteredMap, unComparableMap, unqualifiedMap,
-                                                            totalDataPoints, zeroFilteredPoints, isInterHarmonic);
+                    totalDataPoints, zeroFilteredPoints, isInterHarmonic);
 
             // 设置检测结果
             String overallResult;
@@ -2006,6 +2059,7 @@ public class ResultServiceImpl implements IResultService {
 
     /**
      * 判断值是否为零
+     *
      * @param value 字符串值
      * @return 是否为零
      */
@@ -2023,12 +2077,13 @@ public class ResultServiceImpl implements IResultService {
 
     /**
      * 生成谐波类特殊情况描述
-     * @param zeroFilteredMap 双零过滤的次数和相别
+     *
-     * @param unComparableMap 无法比较的次数和相别
+     * @param zeroFilteredMap    双零过滤的次数和相别
-     * @param unqualifiedMap 不符合的次数和相别
+     * @param unComparableMap    无法比较的次数和相别
-     * @param totalDataPoints 总数据点数
+     * @param unqualifiedMap     不符合的次数和相别
+     * @param totalDataPoints    总数据点数
      * @param zeroFilteredPoints 双零过滤的数据点数
-     * @param isInterHarmonic 是否为间谐波
+     * @param isInterHarmonic    是否为间谐波
      * @return 特殊情况描述
      */
     private String generateHarmonicSpecialCase(Map<Integer, List<String>> zeroFilteredMap,
@@ -2070,8 +2125,8 @@ public class ResultServiceImpl implements IResultService {
                     List<String> phases = dataEntry.getValue();
                     String phaseKey = String.join("、", phases);
                     groupedUnComparable.computeIfAbsent(numOfData, k -> new LinkedHashMap<>())
-                                      .computeIfAbsent(phaseKey, k -> new ArrayList<>())
+                            .computeIfAbsent(phaseKey, k -> new ArrayList<>())
-                                      .add(harmNum);
+                            .add(harmNum);
                 }
             }
 
@@ -2112,7 +2167,7 @@ public class ResultServiceImpl implements IResultService {
                         harmPhaseDesc = "第" + displayHarmNum + "次谐波" + String.join("、", phases);
                     }
                     groupedByNumOfData.computeIfAbsent(numOfData, k -> new ArrayList<>())
-                                     .add(harmPhaseDesc);
+                            .add(harmPhaseDesc);
                 }
             }
 
@@ -2124,7 +2179,7 @@ public class ResultServiceImpl implements IResultService {
                 // 合并描述：第4次谐波A相、B相、C相、第32次谐波A相、第44次谐波C相
                 specialCaseDesc.append(String.join("、", harmPhaseList));
                 specialCaseDesc.append("收集有效组数为").append(numOfData)
-                              .append("组，误差计算结果不符合误差标准要求。");
+                        .append("组，误差计算结果不符合误差标准要求。");
             }
         }
 
@@ -2143,7 +2198,8 @@ public class ResultServiceImpl implements IResultService {
 
     /**
      * 获取显示用的谐波次数
-     * @param harmNum 原始次数（2-50）
+     *
+     * @param harmNum         原始次数（2-50）
      * @param isInterHarmonic 是否为间谐波
      * @return 显示用的次数字符串
      */
@@ -2162,7 +2218,8 @@ public class ResultServiceImpl implements IResultService {
 
     /**
      * 格式化谐波次数列表
-     * @param harmNumbers 谐波次数列表
+     *
+     * @param harmNumbers     谐波次数列表
      * @param isInterHarmonic 是否为间谐波
      * @return 格式化的字符串，如"2、3、5"或"2-5、7、9-11"（间谐波为"1.5、2.5、3.5"）
      */
@@ -2349,10 +2406,10 @@ public class ResultServiceImpl implements IResultService {
     /**
      * 解析非谐波数据
      *
-     * @param valueJson JSON格式的数据
+     * @param valueJson     JSON格式的数据
-     * @param phase     相别标识
+     * @param phase         相别标识
-     * @param numOfData 收集组数
+     * @param numOfData     收集组数
-     * @param scriptCode 脚本代码，用于判断是否需要特殊格式化
+     * @param scriptCode    脚本代码，用于判断是否需要特殊格式化
      * @param decimalPlaces 小数位数，null则不格式化
      * @return 解析后的数据列表
      */
@@ -2476,11 +2533,11 @@ public class ResultServiceImpl implements IResultService {
     /**
      * 解析谐波相数据
      *
-     * @param jsonData  JSON格式的数据
+     * @param jsonData      JSON格式的数据
-     * @param phase     相别标识
+     * @param phase         相别标识
-     * @param harmNum   谐波次数
+     * @param harmNum       谐波次数
-     * @param numOfData 收集组数
+     * @param numOfData     收集组数
-     * @param scriptCode 脚本代码，用于判断是否需要特殊格式化
+     * @param scriptCode    脚本代码，用于判断是否需要特殊格式化
      * @param decimalPlaces 小数位数，null则不格式化
      * @return 解析后的数据列表
      */
@@ -2651,7 +2708,7 @@ public class ResultServiceImpl implements IResultService {
         if (CollUtil.isNotEmpty(contrastHarmonicResults)) {
             ContrastHarmonicResult contrastHarmonicResult = contrastHarmonicResults.get(0);
             List<Double> harmonicNum = null;
-            if (DicDataEnum.HV.getCode().equals(dictTree.getCode()) || DicDataEnum.HI.getCode().equals(dictTree.getCode())) {
+            if (DicDataEnum.HV.getCode().equals(dictTree.getCode()) || DicDataEnum.HI.getCode().equals(dictTree.getCode()) || DicDataEnum.HP.getCode().equals(dictTree.getCode())) {
                 harmonicNum = Stream.iterate(2.0, n -> n + 1).limit(49).collect(Collectors.toList());
             }
             if (DicDataEnum.HSV.getCode().equals(dictTree.getCode()) || DicDataEnum.HSI.getCode().equals(dictTree.getCode())) {
@@ -2735,7 +2792,7 @@ public class ResultServiceImpl implements IResultService {
 
         if (CollUtil.isNotEmpty(devHarmonicRawDataList) && CollUtil.isNotEmpty(stdDevHarmonicRawDataList)) {
             List<Double> harmonicNum = null;
-            if (DicDataEnum.HV.getCode().equals(dictTree.getCode()) || DicDataEnum.HI.getCode().equals(dictTree.getCode())) {
+            if (DicDataEnum.HV.getCode().equals(dictTree.getCode()) || DicDataEnum.HI.getCode().equals(dictTree.getCode()) || DicDataEnum.HP.getCode().equals(dictTree.getCode())) {
                 harmonicNum = Stream.iterate(2.0, n -> n + 1).limit(49).collect(Collectors.toList());
             }
             if (DicDataEnum.HSV.getCode().equals(dictTree.getCode()) || DicDataEnum.HSI.getCode().equals(dictTree.getCode())) {
@@ -2984,13 +3041,36 @@ 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) {
+            DataSourceEnum dataSourceEnum = DataSourceEnum.ofByValue(ds);
+            switch (dataSourceEnum) {
+                case MINUTE_STATISTICS_MIN:
+                    nonWaveDataSourceEnum = MINUTE_STATISTICS_MIN;
+                    break;
+                case MINUTE_STATISTICS_MAX:
+                    nonWaveDataSourceEnum = MINUTE_STATISTICS_MAX;
+                    break;
+                case MINUTE_STATISTICS_AVG:
+                    nonWaveDataSourceEnum = DataSourceEnum.MINUTE_STATISTICS_AVG;
+                    break;
+                case MINUTE_STATISTICS_CP95:
+                    nonWaveDataSourceEnum = 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 +3095,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();
@@ -3030,6 +3111,7 @@ public class ResultServiceImpl implements IResultService {
                 parsId.put(dev.getId() + CnSocketUtil.SPLIT_TAG + split1[1], standardDev.getId() + CnSocketUtil.SPLIT_TAG + split2[1]);
                 numMap.put(devMonitorId, num);
                 numMap.put(adPair.getStdDevMonitorId(), num);
+                devIdMapComm.put(standardDev.getIp(), standardDev.getId());
             });
 
             List<ContrastNonHarmonicResult> devNonHarmonicRawDataList = contrastNonHarmonicService.listAllRawData(oldCode, num, null, false, 0, deviceId, null);
@@ -3037,14 +3119,14 @@ public class ResultServiceImpl implements IResultService {
             List<ContrastHarmonicResult> devHarmonicRawDataList = contrastHarmonicService.listAllRawData(oldCode, num, null, false, 0, deviceId, null);
             List<ContrastHarmonicResult> stdDevHarmonicRawDataList = contrastHarmonicService.listAllRawData(oldCode, num, null, false, 1, deviceId, null);
 
-            List<DevData> devData = contrastToList(devNonHarmonicRawDataList, devHarmonicRawDataList, testItemMap);
+            List<DevData> devData = contrastToList(devNonHarmonicRawDataList, devHarmonicRawDataList, testItemMap, 0);
-            List<DevData> standardDevData = contrastToList(stdDevNonHarmonicRawDataList, stdDevHarmonicRawDataList, testItemMap);
+            List<DevData> standardDevData = contrastToList(stdDevNonHarmonicRawDataList, stdDevHarmonicRawDataList, testItemMap, 1);
 
-            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);
             });
 
@@ -3055,14 +3137,14 @@ public class ResultServiceImpl implements IResultService {
                 devHarmonicRawDataList = contrastHarmonicService.listAllRawData(oldCode, num, i, true, 0, deviceId, null);
                 stdDevHarmonicRawDataList = contrastHarmonicService.listAllRawData(oldCode, num, i, true, 1, deviceId, null);
 
-                devData = contrastToList(devNonHarmonicRawDataList, devHarmonicRawDataList, testItemMap);
+                devData = contrastToList(devNonHarmonicRawDataList, devHarmonicRawDataList, testItemMap, 0);
-                standardDevData = contrastToList(stdDevNonHarmonicRawDataList, stdDevHarmonicRawDataList, testItemMap);
+                standardDevData = contrastToList(stdDevNonHarmonicRawDataList, stdDevHarmonicRawDataList, testItemMap, 1);
-                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);
             });
         });
@@ -3153,58 +3235,79 @@ public class ResultServiceImpl implements IResultService {
         return info;
     }
 
-    private List<DevData> contrastToList(List<ContrastNonHarmonicResult> nonHarm, List<ContrastHarmonicResult> harm, BiMap<String, String> testItemMap) {
+    private List<DevData> contrastToList(List<ContrastNonHarmonicResult> nonHarm, List<ContrastHarmonicResult> harm, BiMap<String, String> testItemMap, Integer flag) {
         List<DevData> info = new ArrayList<>();
-        if (CollUtil.isNotEmpty(nonHarm)) {
+
-            Map<String, List<ContrastNonHarmonicResult>> devMonitorIdMap = nonHarm.stream().collect(Collectors.groupingBy(ContrastNonHarmonicResult::getDevMonitorId, Collectors.toList()));
+        Map<String, List<ContrastNonHarmonicResult>> devMonitorIdMap1 = null;
-            devMonitorIdMap.forEach((devMonitorId, value) -> {
+        if (flag == 0) {
+            devMonitorIdMap1 = nonHarm.stream().collect(Collectors.groupingBy(ContrastNonHarmonicResult::getDevMonitorId, Collectors.toList()));
+        } else {
+            devMonitorIdMap1 = nonHarm.stream().collect(Collectors.groupingBy(ContrastNonHarmonicResult::getStdDevMonitorId, Collectors.toList()));
+        }
+        devMonitorIdMap1.forEach((devMonitorId, value) -> {
+            Map<LocalDateTime, List<ContrastNonHarmonicResult>> timeListMap = value.stream().collect(Collectors.groupingBy(ContrastNonHarmonicResult::getTimeId, Collectors.toList()));
+            timeListMap.forEach((time, value1) -> {
                 DevData devData = new DevData();
                 String[] split = devMonitorId.split(CnSocketUtil.SPLIT_TAG);
-                PqDev dev = pqDevService.getById(split[0]);
+                if (flag == 0) {
-                devData.setId(dev.getIp() + CnSocketUtil.SPLIT_TAG + split[1]);
+                    PqDev dev = pqDevService.getById(split[0]);
-                Map<LocalDateTime, List<ContrastNonHarmonicResult>> timeListMap = value.stream().collect(Collectors.groupingBy(ContrastNonHarmonicResult::getTimeId, Collectors.toList()));
+                    devData.setId(dev.getIp() + CnSocketUtil.SPLIT_TAG + split[1]);
-                timeListMap.forEach((time, value1) -> {
+                } else {
-                    List<DevData.SqlDataDTO> sqlData = new ArrayList<>();
+                    PqStandardDev standardDev = pqStandardDevService.getById(split[0]);
-                    devData.setTime(time.format(DateTimeFormatter.ofPattern(DatePattern.ISO8601_PATTERN)));
+                    devData.setId(standardDev.getIp() + CnSocketUtil.SPLIT_TAG + split[1]);
+                }
+                devData.setTime(time.format(DateTimeFormatter.ofPattern(DatePattern.ISO8601_PATTERN)));
+                List<DevData.SqlDataDTO> sqlData = new ArrayList<>();
 
-                    value1.forEach(x -> {
+                value1.forEach(x -> {
-                        DevData.SqlDataDTO sqlDataDTO = new DevData.SqlDataDTO();
+                    DevData.SqlDataDTO sqlDataDTO = new DevData.SqlDataDTO();
-                        DevData.SqlDataDTO.ListDTO listDTO = new DevData.SqlDataDTO.ListDTO();
+                    DevData.SqlDataDTO.ListDTO listDTO = new DevData.SqlDataDTO.ListDTO();
-                        listDTO.setA(StrUtil.isNotBlank(x.getAValue()) ? Double.valueOf(x.getAValue()) : null);
+                    listDTO.setA(StrUtil.isNotBlank(x.getAValue()) ? Double.valueOf(x.getAValue()) : null);
-                        listDTO.setB(StrUtil.isNotBlank(x.getBValue()) ? Double.valueOf(x.getBValue()) : null);
+                    listDTO.setB(StrUtil.isNotBlank(x.getBValue()) ? Double.valueOf(x.getBValue()) : null);
-                        listDTO.setC(StrUtil.isNotBlank(x.getCValue()) ? Double.valueOf(x.getCValue()) : null);
+                    listDTO.setC(StrUtil.isNotBlank(x.getCValue()) ? Double.valueOf(x.getCValue()) : null);
-                        listDTO.setT(StrUtil.isNotBlank(x.getTValue()) ? Double.valueOf(x.getTValue()) : null);
+                    listDTO.setT(StrUtil.isNotBlank(x.getTValue()) ? Double.valueOf(x.getTValue()) : null);
-                        sqlDataDTO.setType(x.getDataType());
+                    sqlDataDTO.setType(x.getDataType());
-                        sqlDataDTO.setDesc(testItemMap.inverse().get(x.getAdType()).replace(DetectionCodeEnum.REAL_PREFIX.getCode(), ""));
+                    sqlDataDTO.setDesc(testItemMap.inverse().get(x.getAdType()).replace(DetectionCodeEnum.REAL_PREFIX.getCode(), ""));
-                        sqlDataDTO.setList(listDTO);
+                    sqlDataDTO.setList(listDTO);
-                        sqlData.add(sqlDataDTO);
+                    sqlData.add(sqlDataDTO);
-                    });
-                    devData.setSqlData(sqlData);
                 });
+                devData.setSqlData(sqlData);
                 info.add(devData);
             });
+        });
+
+        Map<String, List<ContrastHarmonicResult>> devMonitorIdMap2 = null;
+        if (flag == 0) {
+            devMonitorIdMap2 = harm.stream().collect(Collectors.groupingBy(ContrastHarmonicResult::getDevMonitorId, Collectors.toList()));
+        } else {
+            devMonitorIdMap2 = harm.stream().collect(Collectors.groupingBy(ContrastHarmonicResult::getStdDevMonitorId, Collectors.toList()));
         }
-        if (CollUtil.isNotEmpty(harm)) {
-            Map<String, List<ContrastHarmonicResult>> devMonitorIdMap = harm.stream().collect(Collectors.groupingBy(ContrastHarmonicResult::getDevMonitorId, Collectors.toList()));
-            devMonitorIdMap.forEach((devMonitorId, value) -> {
-                DevData devData = new DevData();
-                String[] split = devMonitorId.split(CnSocketUtil.SPLIT_TAG);
-                PqDev dev = pqDevService.getById(split[0]);
-                devData.setId(dev.getIp() + CnSocketUtil.SPLIT_TAG + split[1]);
-                Map<LocalDateTime, List<ContrastHarmonicResult>> timeListMap = value.stream().collect(Collectors.groupingBy(ContrastHarmonicResult::getTimeId, Collectors.toList()));
 
-                timeListMap.forEach((time, value1) -> {
+        devMonitorIdMap2.forEach((devMonitorId, value) -> {
+            Map<LocalDateTime, List<ContrastHarmonicResult>> timeListMap = value.stream().collect(Collectors.groupingBy(ContrastHarmonicResult::getTimeId, Collectors.toList()));
+
+            timeListMap.forEach((time, value1) -> {
+                DevData devData = info.stream().filter(x -> x.getTime().equals(time.format(DateTimeFormatter.ofPattern(DatePattern.ISO8601_PATTERN)))).findFirst().orElse(null);
+                if (ObjectUtil.isNotNull(devData)) {
+                    String[] split = devMonitorId.split(CnSocketUtil.SPLIT_TAG);
+                    if (flag == 0) {
+                        PqDev dev = pqDevService.getById(split[0]);
+                        devData.setId(dev.getIp() + CnSocketUtil.SPLIT_TAG + split[1]);
+                    } else {
+                        PqStandardDev standardDev = pqStandardDevService.getById(split[0]);
+                        devData.setId(standardDev.getIp() + CnSocketUtil.SPLIT_TAG + split[1]);
+                    }
+
                     devData.setTime(time.format(DateTimeFormatter.ofPattern(DatePattern.ISO8601_PATTERN)));
-                    List<DevData.SqlDataDTO> sqlData = new ArrayList<>();
+                    List<DevData.SqlDataDTO> sqlData = devData.getSqlData();
                     List<DevData.SqlDataHarmDTO> sqlDataHarm = new ArrayList<>();
-
                     value1.forEach(x -> {
                         DevData.SqlDataHarmDTO dataHarmDTO = new DevData.SqlDataHarmDTO();
                         dataHarmDTO.setType(x.getDataType());
                         String desc = testItemMap.inverse().get(x.getAdType()).replace(DetectionCodeEnum.REAL_PREFIX.getCode(), "");
                         dataHarmDTO.setDesc(desc);
                         boolean notContainBaseHarm = false;
-                        if (DetectionCodeEnum.V2_50.getCode().equals(desc) || DetectionCodeEnum.PV2_50.getCode().equals(desc) || DetectionCodeEnum.I2_50.getCode().equals(desc)) {
+                        if (DetectionCodeEnum.V2_50.getCode().equals(desc) || DetectionCodeEnum.PV2_50.getCode().equals(desc) || DetectionCodeEnum.I2_50.getCode().equals(desc) || DetectionCodeEnum.P2_50.getCode().equals(desc)) {
                             dataHarmDTO.setNum(49);
                             notContainBaseHarm = true;
                         }
@@ -3239,12 +3342,13 @@ public class ResultServiceImpl implements IResultService {
                             }
                         }
                     });
+
                     devData.setSqlDataHarm(sqlDataHarm);
                     devData.setSqlData(sqlData);
-                });
+                }
-                info.add(devData);
             });
-        }
+        });
+
         return info;
     }
 
@@ -3273,7 +3377,7 @@ public class ResultServiceImpl implements IResultService {
     /**
      * 格式化数值，保留指定的小数位数
      *
-     * @param value 原始数值
+     * @param value         原始数值
      * @param decimalPlaces 小数位数
      * @return 格式化后的字符串
      */
@@ -3314,7 +3418,7 @@ public class ResultServiceImpl implements IResultService {
     /**
      * 格式化误差范围字符串，支持处理"-0.05~0.05"格式并转换为"±0.05"格式
      *
-     * @param errorRange 误差范围字符串
+     * @param errorRange    误差范围字符串
      * @param decimalPlaces 小数位数
      * @return 格式化后的误差范围
      */

entrance/src/main/resources/application.yml

@@ -6,12 +6,12 @@ spring:
   datasource:
     druid:
       driver-class-name: com.mysql.cj.jdbc.Driver
-#      url: jdbc:mysql://192.168.1.24:13306/pqs9100?useUnicode=true&characterEncoding=utf-8&useSSL=true&serverTimezone=Asia/Shanghai&rewriteBatchedStatements=true
+      url: jdbc:mysql://192.168.1.24:13306/pqs9100_client1?useUnicode=true&characterEncoding=utf-8&useSSL=true&serverTimezone=Asia/Shanghai&rewriteBatchedStatements=true
-#      username: root
-#      password: njcnpqs
-      url: jdbc:mysql://localhost:13306/pqs9100member?useUnicode=true&characterEncoding=utf-8&useSSL=true&serverTimezone=Asia/Shanghai&rewriteBatchedStatements=true
       username: root
       password: njcnpqs
+      #      url: jdbc:mysql://localhost:3306/pqs91001?useUnicode=true&characterEncoding=utf-8&useSSL=true&serverTimezone=CTT
+      #      username: root
+      #      password: root
       #初始化建立物理连接的个数、最小、最大连接数
       initial-size: 5
       min-idle: 5
@@ -118,3 +118,7 @@ power-quality:
     harmonic-times: 50   # 谐波次数
     ib-add: false        # 电流基波叠加标志
     uharm-add: false     # 电压谐波叠加标志
+# 激活配置
+activate:
+  private-key: "MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQCcUyYhVqczGxblL+o/xZzF/8nf+LjrfUE/dS1aRHM7uMDD0cgCArhjtfneFePrMxt+Z7W8yNBzSarub8qsfhaVNikV7Es7oaeTygfjQXTi2n4AFkir3fM07J08RpWhl5M8f8uWTCuvFUYAw00gq55typqmnbkmJa2VIUy/iQf+cMCP7abz4/jNhUzUR3qA7TV4oMRgTdIEDUp63YF8dOC+JH8XxYrCVeHXV6fLCwmesdMzl0lB2VTEKMfLbXhOmF5g7P9y/16VCcN8UBuZlbyYfn+GAxJOSbeHi5HshOKfoSuD7Jz+3WQZpNavOWjIFExKIU38/CvnJCOP7XBCqpSTAgMBAAECggEAYeWokWRE3TpvwiOZnUpR/aVMdVi75a3ROL5XIpqPV61B+t/bU3cEpl0GF9C5pUeiRi0IoStZb3mI9D1KPW/REKyUWkhabQO1gFYbTnRlkNOn6MILzKX4cwJjDaZeeo4EBPU7N+qHyOOXrU6hdH5FfxhMdV983ajm5eeuupxER1C2kAcIklTeVpTX6EKOgZb5LBp5ssOVm2P42pOauvcRozRcvZmqnErXmukv0H4l3EVNt4rHpTn9riHUC63e8JfiYzVaF6zuNUxv6nHEft0/SRMw11XSTnNfDzcKqgjz6ksFBS/6eQQYKESk+ONC53HUuYHFAknkwsPupDCT2W8FIQKBgQDLHT/xCU3nxGr4vFKBDNaO2D5oK20ECbBO4oDvLWWmQG7f+6TsMy8PgVdMnoL4RfqGlwFAKEpS6KVFHnBVqnNEhcdy9uCI7x7Xx8UnyUtxj1EDTm76uta9Ki9OrlqB6tImDM9+Ya3vGktW37ht4WOx2OsJRhG1dbf6RLwFlH7DWwKBgQDFBxvi5I1BR6hg6Tj7xd2SqOT2Y+BED3xuSYENhWbmMhLJDResaB7mjztbxlYaY2mOE0holWm2uDmVFFhMh4jYXik4hYH8nmDzq9mDpZCZ9pyjYqnAP8THoAa8EbgrUWB8A6BPH4iL3KbMnBfBKY0pIr2xrvnjQjNBAgta7KDRKQKBgCe6oe4wxrdF2TKsC2tIqpMoQxS3Icy/ZGgZr+SYuaBKTCWtoDW/UT40K3JGMxIDBhzbXphBCUCsVt9tM8Xd4EwP6tJW7dZ7B0pnve2pVwNwaAVAiz6p2yUHIle+jN+Koe5lZRSwYIg7WW81tWpwwsJfzqFyvjYDP6hJV4mz4ROvAoGAaRcdnKvjXApomShMqJ4lTPChD3q+SA8qg3jZSOj6tZXHx00gb2kp8jg7pPvpOTIFPy6x1Ha9aCRjMk0ju84fA6lVuzwa1S907wOehUVuF3Eeo1cgy9Y3k3KbpPyeixxgpkUY4JslLdSHc2NemD0dee951qhJyRmqVOZOQDUuoeECgYEAqBw2cAFk3vM97WY06TSldGA8ajVHx3BYRjj+zl62NTQthy8fw3tqxb3c5e8toOmZWKjZvDhg2TRLhsDDQWEYg3LZG87REqVIjgEPcpjNLidjygGX8n3JF2o0O5I/EMvl0s/+LVQONfduOBvhwDqr8QNisbLsyneiAq7umewMolo="
+  public-key: "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAnFMmIVanMxsW5S/qP8Wcxf/J3/i4631BP3UtWkRzO7jAw9HIAgK4Y7X53hXj6zMbfme1vMjQc0mq7m/KrH4WlTYpFexLO6Gnk8oH40F04tp+ABZIq93zNOydPEaVoZeTPH/LlkwrrxVGAMNNIKuebcqapp25JiWtlSFMv4kH/nDAj+2m8+P4zYVM1Ed6gO01eKDEYE3SBA1Ket2BfHTgviR/F8WKwlXh11enywsJnrHTM5dJQdlUxCjHy214TpheYOz/cv9elQnDfFAbmZW8mH5/hgMSTkm3h4uR7ITin6Erg+yc/t1kGaTWrzloyBRMSiFN/Pwr5yQjj+1wQqqUkwIDAQAB"

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);
-            for (String id : ids) {
+            wrapper1.and(w -> {
-                wrapper1.like(ContrastNonHarmonicResult::getDevMonitorId, id);
+                for (String id : ids) {
-            }
+                    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);
-            for (String id : ids) {
+            wrapper2.and(w -> {
-                wrapper2.like(ContrastHarmonicResult::getDevMonitorId, id);
+                for (String id : ids) {
-            }
+                    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) -> {

tools/activate-tool/pom.xml

@@ -0,0 +1,50 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <parent>
+        <groupId>com.njcn.gather</groupId>
+        <artifactId>CN_Gather</artifactId>
+        <version>1.0.0</version>
+    </parent>
+
+    <artifactId>activate-tool</artifactId>
+
+    <properties>
+        <maven.compiler.source>8</maven.compiler.source>
+        <maven.compiler.target>8</maven.compiler.target>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+    </properties>
+
+    <dependencies>
+        <dependency>
+            <groupId>com.njcn</groupId>
+            <artifactId>njcn-common</artifactId>
+            <version>0.0.1</version>
+        </dependency>
+
+        <dependency>
+            <groupId>com.njcn</groupId>
+            <artifactId>spingboot2.3.12</artifactId>
+            <version>2.3.12</version>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.springframework.boot</groupId>
+                <artifactId>spring-boot-maven-plugin</artifactId>
+                <configuration>
+                    <excludes>
+                        <exclude>
+                            <groupId>org.projectlombok</groupId>
+                            <artifactId>lombok</artifactId>
+                        </exclude>
+                    </excludes>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+</project>

tools/activate-tool/src/main/java/com/njcn/gather/tool/active/config/ActivateProperties.java

@@ -0,0 +1,33 @@
+package com.njcn.gather.tool.active.config;
+
+import cn.hutool.system.SystemUtil;
+import lombok.Data;
+import org.springframework.boot.context.properties.ConfigurationProperties;
+
+import java.io.File;
+
+@Data
+@ConfigurationProperties(prefix = "activate")
+public class ActivateProperties {
+    private final String LICENSE_FILE_NAME = "license.key";
+
+    /**
+     * RSA公钥
+     */
+    private String publicKey;
+    /**
+     * RSA私钥
+     */
+    private String privateKey;
+
+    /**
+     * 密钥文件所在目录，默认为当前项目目录
+     */
+    private String licenseDir = System.getProperty(SystemUtil.USER_DIR);
+
+    public String getLicenseFilePath() {
+        return licenseDir + File.separator + LICENSE_FILE_NAME;
+    }
+
+
+}

tools/activate-tool/src/main/java/com/njcn/gather/tool/active/controller/ActivateController.java

@@ -0,0 +1,110 @@
+package com.njcn.gather.tool.active.controller;
+
+import cn.hutool.core.net.NetUtil;
+import cn.hutool.core.util.StrUtil;
+import cn.hutool.json.JSONUtil;
+import com.njcn.common.pojo.annotation.OperateInfo;
+import com.njcn.common.pojo.enums.common.LogEnum;
+import com.njcn.common.pojo.enums.response.CommonResponseEnum;
+import com.njcn.common.pojo.response.HttpResult;
+import com.njcn.common.utils.LogUtil;
+import com.njcn.gather.tool.active.service.ActivateService;
+import com.njcn.gather.tool.active.vo.ActivationCodePlaintext;
+import com.njcn.gather.tool.active.vo.ApplicationCodePlaintext;
+import com.njcn.web.controller.BaseController;
+import com.njcn.web.utils.HttpResultUtil;
+import io.swagger.annotations.*;
+import lombok.Data;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+@Slf4j
+@Api(tags = "设备激活管理")
+@RestController
+@RequestMapping("/activate")
+@RequiredArgsConstructor
+public class ActivateController extends BaseController {
+
+    private final ActivateService activateService;
+
+    @OperateInfo(info = LogEnum.BUSINESS_COMMON)
+    @ApiOperation("生成设备申请码")
+    @ApiImplicitParam(name = "data", value = "生成设备申请码参数", required = true)
+    @PostMapping("/generateApplicationCode")
+    public HttpResult generateApplicationCode(@RequestBody ApplicationCodePlaintext data) {
+        String methodDescribe = getMethodDescribe("generateApplicationCode");
+        LogUtil.njcnDebug(log, "{}，生成设备申请码：{}", methodDescribe, JSONUtil.toJsonStr(data));
+        String applicationCode = activateService.generateApplicationCode(data);
+        return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, applicationCode, methodDescribe);
+    }
+
+    @OperateInfo(info = LogEnum.BUSINESS_COMMON)
+    @ApiOperation("验证设备激活码")
+    @ApiImplicitParam(name = "params", value = "验证设备激活码参数", required = true)
+    @PostMapping("/verifyActivationCode")
+    public HttpResult verifyActivationCode(@RequestBody VerifyActivationCodeParams params) {
+        String methodDescribe = getMethodDescribe("verifyActivationCode");
+        LogUtil.njcnDebug(log, "{}，验证设备激活码\"：{}", methodDescribe, JSONUtil.toJsonStr(params));
+        ActivationCodePlaintext activationCodePlaintext = activateService.verifyActivationCode(params.getActivationCode());
+        return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, activationCodePlaintext, methodDescribe);
+    }
+
+    @OperateInfo(info = LogEnum.BUSINESS_COMMON)
+    @ApiOperation("获取许可信息")
+    @PostMapping("/getLicense")
+    public HttpResult getLicense() {
+        String methodDescribe = getMethodDescribe("checkLicense");
+        LogUtil.njcnDebug(log, "{}，获取许可信息", methodDescribe);
+        ActivationCodePlaintext activationCodePlaintext = activateService.readLicenseFile();
+        String macAddress = NetUtil.getLocalMacAddress();
+        if (activationCodePlaintext == null) {
+            activationCodePlaintext = new ActivationCodePlaintext();
+            activationCodePlaintext.setMacAddress(macAddress);
+            activationCodePlaintext.init();
+        } else {
+            // 校验mac地址
+            String licenseMacAddress = activationCodePlaintext.getMacAddress();
+            if (StrUtil.isNotEmpty(licenseMacAddress)) {
+                if (!StrUtil.equals(licenseMacAddress, macAddress)) {
+                    log.error("mac地址不匹配，无效的许可文件，本机mac:{},许可mac:{}", macAddress, licenseMacAddress);
+                    methodDescribe = "mac地址不匹配，无效的许可文件";
+                    activationCodePlaintext = new ActivationCodePlaintext();
+                    activationCodePlaintext.setMacAddress(macAddress);
+                    activationCodePlaintext.init();
+                }
+            }
+        }
+
+
+        return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, activationCodePlaintext, methodDescribe);
+    }
+
+    @ApiModel("验证设备激活码参数")
+    @Data
+    public static class VerifyActivationCodeParams {
+        @ApiModelProperty(value = "激活码")
+        private String activationCode;
+    }
+
+
+    @ApiOperation("生成设备激活码")
+    @ApiImplicitParam(name = "params", value = "参数", required = true, dataType = "ApplicationCodeParams")
+    @PostMapping("/generateActivationCode")
+    public HttpResult generateActivationCode(@RequestBody ApplicationCodeParams params) {
+        String activationCode = activateService.generateActivationCode(params.getApplicationCode(), params.getPermanently());
+        return HttpResultUtil.assembleResult(CommonResponseEnum.SUCCESS.getCode(), activationCode, "");
+    }
+
+    @ApiModel("生成设备激活码参数")
+    @Data
+    public static class ApplicationCodeParams {
+        @ApiModelProperty(value = "设备申请码", required = true)
+        private String applicationCode;
+        @ApiModelProperty(value = "是否永久激活", example = "1", required = true)
+        private int permanently;
+    }
+}

tools/activate-tool/src/main/java/com/njcn/gather/tool/active/service/ActivateService.java

@@ -0,0 +1,42 @@
+package com.njcn.gather.tool.active.service;
+
+import com.njcn.gather.tool.active.vo.ActivationCodePlaintext;
+import com.njcn.gather.tool.active.vo.ApplicationCodePlaintext;
+
+public interface ActivateService {
+
+
+    /**
+     * 生成设备申请码
+     *
+     * @param data
+     * @return
+     */
+    String generateApplicationCode(ApplicationCodePlaintext data);
+
+    /**
+     * 验证激活码
+     *
+     * @param activationCode
+     * @return
+     */
+    ActivationCodePlaintext verifyActivationCode(String activationCode);
+
+    /**
+     * 读取授权文件
+     *
+     * @return
+     */
+    ActivationCodePlaintext readLicenseFile();
+
+    /**
+     * 生成设备激活码
+     *
+     * @param applicationCode 申请码
+     * @param permanently     是否永久激活
+     * @return
+     */
+    String generateActivationCode(String applicationCode, int permanently);
+
+
+}

tools/activate-tool/src/main/java/com/njcn/gather/tool/active/service/impl/ActivateServiceImpl.java

@@ -0,0 +1,185 @@
+package com.njcn.gather.tool.active.service.impl;
+
+import cn.hutool.core.io.FileUtil;
+import cn.hutool.core.net.NetUtil;
+import cn.hutool.core.util.StrUtil;
+import cn.hutool.json.JSONUtil;
+import com.njcn.common.pojo.enums.response.CommonResponseEnum;
+import com.njcn.common.pojo.exception.BusinessException;
+import com.njcn.common.utils.RSAUtil;
+import com.njcn.gather.tool.active.config.ActivateProperties;
+import com.njcn.gather.tool.active.service.ActivateService;
+import com.njcn.gather.tool.active.vo.ActivationCodePlaintext;
+import com.njcn.gather.tool.active.vo.ActivationModule;
+import com.njcn.gather.tool.active.vo.ApplicationCodePlaintext;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.boot.context.properties.EnableConfigurationProperties;
+import org.springframework.stereotype.Service;
+
+@EnableConfigurationProperties(ActivateProperties.class)
+@RequiredArgsConstructor
+@Slf4j
+@Service
+public class ActivateServiceImpl implements ActivateService {
+
+    private final ActivateProperties props;
+
+    @Override
+    public String generateApplicationCode(ApplicationCodePlaintext data) {
+        // 获取当前设备MAC地址
+        String macAddress = NetUtil.getLocalMacAddress();
+        log.debug("当前设备MAC地址：{}", macAddress);
+        data.setMacAddress(macAddress);
+        String plaintext = JSONUtil.toJsonStr(data);
+        // RSA 加密
+        try {
+            return RSAUtil.encrypt(plaintext, RSAUtil.stringToPublicKey(props.getPublicKey()));
+        } catch (Exception e) {
+            log.error("申请码加密失败", e);
+            throw new BusinessException(CommonResponseEnum.FAIL, "申请码生成失败");
+        }
+    }
+
+    @Override
+    public ActivationCodePlaintext verifyActivationCode(String activationCode) {
+        String plaintext;
+        try {
+            plaintext = RSAUtil.decrypt(activationCode, RSAUtil.stringToPrivateKey(props.getPrivateKey()));
+        } catch (Exception e) {
+            log.error("授权码解密失败", e);
+            throw new BusinessException(CommonResponseEnum.FAIL, "无效的激活码");
+        }
+        log.info("新授权码解密：{}", JSONUtil.toJsonStr(plaintext));
+        ActivationCodePlaintext activationCodePlaintext = JSONUtil.toBean(plaintext, ActivationCodePlaintext.class);
+        String macAddress = NetUtil.getLocalMacAddress();
+        if (!StrUtil.equals(activationCodePlaintext.getMacAddress(), macAddress)) {
+            log.error("mac地址不匹配");
+            throw new BusinessException(CommonResponseEnum.FAIL, "无效的激活码");
+        }
+        return addOrUpdateLicenseFile(activationCodePlaintext, activationCode);
+    }
+
+    @Override
+    public ActivationCodePlaintext readLicenseFile() {
+        String licenseFilePath = props.getLicenseFilePath();
+        log.info("读取授权文件，{}", licenseFilePath);
+        if (FileUtil.exist(licenseFilePath)) {
+            String content = FileUtil.readUtf8String(licenseFilePath);
+            String plaintext;
+            try {
+                plaintext = RSAUtil.decrypt(content, RSAUtil.stringToPrivateKey(props.getPrivateKey()));
+            } catch (Exception e) {
+                log.error("授权文件内容解密失败", e);
+                throw new BusinessException(CommonResponseEnum.FAIL, "许可信息读取失败");
+            }
+            return JSONUtil.toBean(plaintext, ActivationCodePlaintext.class);
+        }
+        return null;
+    }
+
+    @Override
+    public String generateActivationCode(String applicationCode, int permanently) {
+        // RSA 解密
+        String plaintext;
+        try {
+            plaintext = RSAUtil.decrypt(applicationCode, RSAUtil.stringToPrivateKey(props.getPrivateKey()));
+        } catch (Exception e) {
+            log.error("申请码解密失败", e);
+            throw new BusinessException(CommonResponseEnum.FAIL, "无效的申请码");
+        }
+        ActivationCodePlaintext activationCodePlaintext = JSONUtil.toBean(plaintext, ActivationCodePlaintext.class);
+        if (activationCodePlaintext == null) {
+            log.error("申请码内容为空");
+            throw new BusinessException(CommonResponseEnum.FAIL, "无效的申请码");
+        }
+        // 激活码明文
+        ActivationModule contrast = activationCodePlaintext.getContrast();
+        ActivationModule simulate = activationCodePlaintext.getSimulate();
+        ActivationModule digital = activationCodePlaintext.getDigital();
+        if (contrast.isApply()) {
+            contrast.setPermanently(permanently);
+            activationCodePlaintext.setContrast(contrast);
+        }
+        if (simulate.isApply()) {
+            simulate.setPermanently(permanently);
+            activationCodePlaintext.setSimulate(simulate);
+        }
+        if (digital.isApply()) {
+            digital.setPermanently(permanently);
+            activationCodePlaintext.setDigital(digital);
+        }
+        // RSA 加密
+        String jsonStr = JSONUtil.toJsonStr(activationCodePlaintext);
+        log.info("生成激活码明文：{}", jsonStr);
+        try {
+            return RSAUtil.encrypt(jsonStr, RSAUtil.stringToPublicKey(props.getPublicKey()));
+        } catch (Exception e) {
+            log.error("生成激活码失败", e);
+            throw new BusinessException(CommonResponseEnum.FAIL, "生成激活码失败");
+        }
+    }
+
+    /**
+     * 添加或更新授权文件
+     *
+     * @param newActivationCodePlaintext 新授权码明文
+     * @param activationCode             授权码
+     * @return 最新授权码明文
+     */
+    private ActivationCodePlaintext addOrUpdateLicenseFile(ActivationCodePlaintext newActivationCodePlaintext, String activationCode) {
+
+        log.info("新授权码明文：{}", JSONUtil.toJsonStr(newActivationCodePlaintext));
+        ActivationModule newContrast = newActivationCodePlaintext.getContrast();
+        ActivationModule newDigital = newActivationCodePlaintext.getDigital();
+        ActivationModule newSimulate = newActivationCodePlaintext.getSimulate();
+        boolean verifyStatus = false;
+        if (newContrast.isApply() && newContrast.isPermanently()) {
+            verifyStatus = true;
+        }
+        if (newDigital.isApply() && newDigital.isPermanently()) {
+            verifyStatus = true;
+        }
+        if (newSimulate.isApply() && newSimulate.isPermanently()) {
+            verifyStatus = true;
+        }
+        if (!verifyStatus) {
+            log.error("授权码格式错误");
+            throw new BusinessException(CommonResponseEnum.FAIL, "无效的激活码");
+        }
+        String licenseFilePath = props.getLicenseFilePath();
+        log.info("授权文件路径：{}", licenseFilePath);
+        ActivationCodePlaintext oldActivationCodePlaintext = this.readLicenseFile();
+        if (oldActivationCodePlaintext == null) {
+            // 如果文件不存在，创建新文件
+            FileUtil.touch(licenseFilePath);
+            // 写入授权文件
+            FileUtil.writeUtf8String(activationCode, licenseFilePath);
+            return newActivationCodePlaintext;
+        } else {
+            log.info("旧授权码明文：{}", JSONUtil.toJsonStr(oldActivationCodePlaintext));
+            oldActivationCodePlaintext.setMacAddress(newActivationCodePlaintext.getMacAddress());
+            if (newContrast.isApply()) {
+                oldActivationCodePlaintext.setContrast(newContrast);
+            }
+            if (newDigital.isApply()) {
+                oldActivationCodePlaintext.setDigital(newDigital);
+            }
+            if (newSimulate.isApply()) {
+                oldActivationCodePlaintext.setSimulate(newSimulate);
+            }
+            log.info("最新授权码明文：{}", JSONUtil.toJsonStr(oldActivationCodePlaintext));
+            String updateContent;
+            // 重新加密
+            try {
+                updateContent = RSAUtil.encrypt(JSONUtil.toJsonStr(oldActivationCodePlaintext), RSAUtil.stringToPublicKey(props.getPublicKey()));
+            } catch (Exception e) {
+                log.error("授权文件内容加密失败", e);
+                throw new BusinessException(CommonResponseEnum.FAIL, "激活失败，请联系管理员");
+            }
+            FileUtil.writeUtf8String(updateContent, licenseFilePath);
+            return oldActivationCodePlaintext;
+        }
+    }
+
+}

tools/activate-tool/src/main/java/com/njcn/gather/tool/active/vo/ActivationCodePlaintext.java

@@ -0,0 +1,35 @@
+package com.njcn.gather.tool.active.vo;
+
+import lombok.Data;
+
+@Data
+public class ActivationCodePlaintext {
+    /**
+     * mac地址
+     */
+    private String macAddress;
+
+    /**
+     * 模拟式模块
+     */
+    private ActivationModule simulate;
+
+    /**
+     * 数字式模块
+     */
+    private ActivationModule digital;
+
+    /**
+     * 比对式模块
+     */
+    private ActivationModule contrast;
+
+
+    public void init() {
+        simulate = new ActivationModule();
+        digital = new ActivationModule();
+        contrast = new ActivationModule();
+    }
+
+
+}

tools/activate-tool/src/main/java/com/njcn/gather/tool/active/vo/ActivationModule.java

@@ -0,0 +1,20 @@
+package com.njcn.gather.tool.active.vo;
+
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+
+@EqualsAndHashCode(callSuper = true)
+@Data
+public class ActivationModule extends ApplicationModule {
+
+    /**
+     * 是否永久授权
+     */
+    private int permanently;
+
+    public boolean isPermanently() {
+        return permanently == 1;
+    }
+
+
+}

tools/activate-tool/src/main/java/com/njcn/gather/tool/active/vo/ApplicationCodePlaintext.java

@@ -0,0 +1,35 @@
+package com.njcn.gather.tool.active.vo;
+
+import io.swagger.annotations.ApiModel;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+
+@ApiModel("申请码明文")
+@Data
+public class ApplicationCodePlaintext {
+    /**
+     * mac地址
+     */
+    @ApiModelProperty(value = "mac地址", hidden = true)
+    private String macAddress;
+
+    /**
+     * 模拟式模块
+     */
+    @ApiModelProperty("模拟式模块")
+    private ApplicationModule simulate;
+
+    /**
+     * 数字式模块
+     */
+    @ApiModelProperty("数字式模块")
+    private ApplicationModule digital;
+
+    /**
+     * 比对式模块
+     */
+    @ApiModelProperty("比对式模块")
+    private ApplicationModule contrast;
+
+
+}

tools/activate-tool/src/main/java/com/njcn/gather/tool/active/vo/ApplicationModule.java

@@ -0,0 +1,17 @@
+package com.njcn.gather.tool.active.vo;
+
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+
+@Data
+public class ApplicationModule {
+    /**
+     * 是否申请 1是 0否
+     */
+    @ApiModelProperty(value = "是否申请 1是 0否")
+    private int apply;
+
+    public boolean isApply() {
+        return apply == 1;
+    }
+}

tools/pom.xml

@@ -18,6 +18,7 @@
     <modules>
         <module>report-generator</module>
         <module>wave-comtrade</module>
+        <module>activate-tool</module>
     </modules>
 
 </project>