合并装置模块和检测计划模块

detection/src/main/java/com/njcn/gather/script/controller/PqScriptController.java

@@ -0,0 +1,157 @@
+package com.njcn.gather.script.controller;
+
+import cn.hutool.core.util.StrUtil;
+import com.alibaba.fastjson.JSON;
+import com.alibaba.fastjson.serializer.SerializerFeature;
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import com.njcn.common.pojo.annotation.OperateInfo;
+import com.njcn.common.pojo.constant.OperateType;
+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.script.pojo.param.PqScriptIssueParam;
+import com.njcn.gather.script.pojo.param.PqScriptParam;
+import com.njcn.gather.script.pojo.po.PqScript;
+import com.njcn.gather.script.pojo.po.PqScriptDtls;
+import com.njcn.gather.script.pojo.po.SourceIssue;
+import com.njcn.gather.script.service.IPqScriptDtlsService;
+import com.njcn.gather.script.service.IPqScriptService;
+import com.njcn.web.controller.BaseController;
+import com.njcn.web.utils.HttpResultUtil;
+import io.swagger.annotations.Api;
+import io.swagger.annotations.ApiImplicitParam;
+import io.swagger.annotations.ApiOperation;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.validation.annotation.Validated;
+import org.springframework.web.bind.annotation.*;
+
+import javax.servlet.http.HttpServletRequest;
+import java.util.List;
+import java.util.Map;
+
+
+/**
+ * @author caozehui
+ * @date 2024-11-18
+ */
+@Slf4j
+@Api(tags = "检测脚本管理")
+@RestController
+@RequestMapping("/pqScript")
+@RequiredArgsConstructor
+public class PqScriptController extends BaseController {
+    private final IPqScriptService pqScriptService;
+    private final IPqScriptDtlsService pqScriptDtlsService;
+
+    @OperateInfo
+    @PostMapping("/list")
+    @ApiOperation("分页查询检测脚本")
+    @ApiImplicitParam(name = "queryParam", value = "查询参数", required = true)
+    public HttpResult<Page<PqScript>> list(@RequestBody @Validated PqScriptParam.QueryParam param) {
+        String methodDescribe = getMethodDescribe("list");
+        LogUtil.njcnDebug(log, "{}，查询数据为：{}", methodDescribe, param);
+        Page<PqScript> result = pqScriptService.listPqScript(param);
+        return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, result, methodDescribe);
+    }
+
+    @OperateInfo(operateType = OperateType.ADD)
+    @PostMapping("/add")
+    @ApiOperation("新增检测脚本")
+    @ApiImplicitParam(name = "pqDevParam", value = "检测脚本", required = true)
+    public HttpResult<Object> add(@RequestBody @Validated PqScriptParam param) {
+        String methodDescribe = getMethodDescribe("add");
+        LogUtil.njcnDebug(log, "{}，新增数据为：{}", methodDescribe, param);
+        boolean result = pqScriptService.addPqScript(param);
+        if (result) {
+            return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, null, methodDescribe);
+        } else {
+            return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.FAIL, null, methodDescribe);
+        }
+    }
+
+    @OperateInfo(operateType = OperateType.UPDATE)
+    @PostMapping("/update")
+    @ApiOperation("修改检测脚本")
+    @ApiImplicitParam(name = "updateParam", value = "检测脚本", required = true)
+    public HttpResult<Object> update(@RequestBody @Validated PqScriptParam.UpdateParam param) {
+        String methodDescribe = getMethodDescribe("update");
+        LogUtil.njcnDebug(log, "{}，修改数据为：{}", methodDescribe, param);
+        boolean result = pqScriptService.updatePqScript(param);
+        if (result) {
+            return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, null, methodDescribe);
+        } else {
+            return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.FAIL, null, methodDescribe);
+        }
+    }
+
+    @OperateInfo(operateType = OperateType.DELETE)
+    @PostMapping("/delete")
+    @ApiOperation("删除检测脚本")
+    @ApiImplicitParam(name = "ids", value = "检测脚本id", required = true)
+    public HttpResult<Object> delete(@RequestBody List<String> ids) {
+        String methodDescribe = getMethodDescribe("delete");
+        LogUtil.njcnDebug(log, "{}，删除ID数据为：{}", methodDescribe, String.join(StrUtil.COMMA, ids));
+        boolean result = pqScriptService.deletePqScript(ids);
+        if (result) {
+            return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, null, methodDescribe);
+        } else {
+            return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.FAIL, null, methodDescribe);
+        }
+    }
+
+    @OperateInfo
+    @GetMapping("getScriptDtlsByScriptId")
+    @ApiOperation("根据脚本id查询检测脚本详情")
+    @ApiImplicitParam(name = "id", value = "检测脚本id", required = true)
+    public HttpResult<List<PqScriptDtls>> getScriptDtlsByScriptId(@RequestParam("id") String id) {
+        String methodDescribe = getMethodDescribe("list");
+        LogUtil.njcnDebug(log, "{}，查询数据为：{}", methodDescribe, id);
+        List<PqScriptDtls> result = pqScriptDtlsService.listPqScriptDtlByScriptId(id);
+        return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, result, methodDescribe);
+    }
+
+    @OperateInfo(operateType = OperateType.UPDATE)
+    @GetMapping("/upgradeToTemplate")
+    @ApiOperation("升级为模板")
+    @ApiImplicitParam(name = "id", value = "检测脚本id", required = true)
+    public HttpResult<Object> upgradeToTemplate(@RequestParam("id") String id, HttpServletRequest request) {
+        String methodDescribe = getMethodDescribe("upgradeToTemplate");
+        LogUtil.njcnDebug(log, "{}，升级ID数据为：{}", methodDescribe, id);
+        boolean result = pqScriptService.upgradeToTemplate(id);
+        if (result) {
+            return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, null, methodDescribe);
+        } else {
+            return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.FAIL, null, methodDescribe);
+        }
+    }
+
+    @OperateInfo
+    @GetMapping("/getAll")
+    @ApiOperation("获取指定模式下的所有检测脚本")
+    @ApiImplicitParam(name = "patternId", value = "模式Id", required = true)
+    public HttpResult<List<Map<String, Object>>> getAllPqScript(@RequestParam("patternId") String patternId) {
+        String methodDescribe = getMethodDescribe("getAllPqScript");
+        LogUtil.njcnDebug(log, "{}，查询数据为：{}", methodDescribe, patternId);
+        List<Map<String, Object>> result = pqScriptService.listAllPqScript(patternId);
+        return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, result, methodDescribe);
+    }
+
+
+    @OperateInfo
+    @PostMapping("dls")
+    @ApiOperation("根据脚本id查询检测脚本详情")
+    @ApiImplicitParam(name = "id", value = "检测脚本id", required = true)
+    public HttpResult<List<SourceIssue>> dls(@RequestBody PqScriptIssueParam param) {
+        String methodDescribe = getMethodDescribe("list");
+        LogUtil.njcnDebug(log, "{}，查询数据为：{}", methodDescribe, param);
+        List<SourceIssue> sourceIssues = pqScriptDtlsService.listSourceIssue(param);
+        for (SourceIssue sourceIssue : sourceIssues) {
+            String jsonString = JSON.toJSONString(sourceIssue,SerializerFeature.WriteNullStringAsEmpty);
+            System.out.println();
+        }
+        String jsonString =sourceIssues.get(0).toString();
+        return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, sourceIssues, methodDescribe);
+    }
+}
+

detection/src/main/java/com/njcn/gather/script/mapper/PqScriptCheckDataMapper.java

@@ -0,0 +1,15 @@
+package com.njcn.gather.script.mapper;
+
+import com.github.yulichang.base.MPJBaseMapper;
+import com.njcn.gather.script.pojo.po.PqScriptCheckData;
+
+/**
+ * @Description:
+ * @Author: wr
+ * @Date: 2024/12/27 9:29
+ */
+public interface PqScriptCheckDataMapper extends MPJBaseMapper<PqScriptCheckData> {
+
+
+}
+

detection/src/main/java/com/njcn/gather/script/mapper/PqScriptDtlsMapper.java

@@ -0,0 +1,13 @@
+package com.njcn.gather.script.mapper;
+
+import com.github.yulichang.base.MPJBaseMapper;
+import com.njcn.gather.script.pojo.po.PqScriptDtls;
+
+/**
+ * @author caozehui
+ * @date 2024-11-18
+ */
+public interface PqScriptDtlsMapper extends MPJBaseMapper<PqScriptDtls> {
+
+}
+

detection/src/main/java/com/njcn/gather/script/mapper/PqScriptMapper.java

@@ -0,0 +1,22 @@
+package com.njcn.gather.script.mapper;
+
+import com.github.yulichang.base.MPJBaseMapper;
+import com.njcn.gather.script.pojo.po.PqScript;
+import org.apache.ibatis.annotations.Param;
+
+/**
+ * @author caozehui
+ * @date 2024-11-18
+ */
+public interface PqScriptMapper extends MPJBaseMapper<PqScript> {
+
+    /**
+     * 获取检测脚本信息(先获取检测脚本类型是否相对值  true相对值 false绝对值（相对值要乘额定值,绝对值不需要处理))
+     * @param scriptId
+     * @return: com.njcn.gather.device.script.pojo.po.PqScript
+     * @Author: wr
+     * @Date: 2024/12/16 18:08
+     */
+    Boolean selectScriptIsValueType(@Param("scriptId") String scriptId);
+}
+

detection/src/main/java/com/njcn/gather/script/mapper/mapping/PqScriptCheckDataMapper.xml

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+<mapper namespace="com.njcn.gather.script.mapper.PqScriptCheckDataMapper">
+
+
+</mapper>
+

detection/src/main/java/com/njcn/gather/script/mapper/mapping/PqScriptDtlsMapper.xml

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+<mapper namespace="com.njcn.gather.script.mapper.PqScriptDtlsMapper">
+
+
+</mapper>
+

detection/src/main/java/com/njcn/gather/script/mapper/mapping/PqScriptMapper.xml

@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+<mapper namespace="com.njcn.gather.script.mapper.PqScriptMapper">
+
+
+    <select id="selectScriptIsValueType" resultType="java.lang.Boolean">
+        SELECT
+            IF((SELECT CODE FROM sys_dict_data WHERE id = Value_Type) = 'Ratio', 'true', 'false')
+        FROM
+            pq_script
+        where
+            State=1
+        and Id = #{scriptId}
+    </select>
+</mapper>
+

detection/src/main/java/com/njcn/gather/script/pojo/enums/ResultUnitEnum.java

@@ -0,0 +1,36 @@
+package com.njcn.gather.script.pojo.enums;
+
+import lombok.Getter;
+
+/**
+ * @author caozehui
+ * @data 2024/11/9
+ */
+@Getter
+public enum ResultUnitEnum {
+
+    FREQ_UNIT("Hz", "频率"),
+    V_RELATIVE_UNIT("%Un", "电压"),
+    V_ABSOLUTELY_UNIT("V", "电压"),
+    I_RELATIVE_UNIT("%In", "电流"),
+    I_ABSOLUTELY_UNIT("A", "电流"),
+    HV_UNIT("%", "谐波电压"),
+    HI_UNIT("%", "谐波电流"),
+    HP_UNIT("W", "谐波有功功率"),
+    HSV_UNIT("%", "间谐波电压"),
+    HSI_UNIT("%", "间谐波电流"),
+    VOLTAGE_MAG_UNIT("周波", "暂态持续时间"),
+    VOLTAGE_DUR_UNIT("%", "暂态深度"),
+    IMBV_UNIT("%", "电压不平衡度"),
+    IMBA_UNIT("%", "电流不平衡度"),
+
+    ;
+
+    private String unit;
+    private String name;
+
+    ResultUnitEnum(String unit, String name) {
+        this.unit = unit;
+        this.name = name;
+    }
+}

detection/src/main/java/com/njcn/gather/script/pojo/param/PqScriptCheckDataParam.java

@@ -0,0 +1,20 @@
+package com.njcn.gather.script.pojo.param;
+
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+
+
+@Data
+public class PqScriptCheckDataParam {
+
+
+    @ApiModelProperty("检测脚本ID")
+    private String scriptId;
+
+    @ApiModelProperty("总检测脚本中的测试项序号")
+    private Integer index;
+
+    @ApiModelProperty("检测指标类型(true:code(I$real) ，false展示id ，默认false)")
+    private Boolean isValueTypeName=false;
+
+}

detection/src/main/java/com/njcn/gather/script/pojo/param/PqScriptIssueParam.java

@@ -0,0 +1,33 @@
+package com.njcn.gather.script.pojo.param;
+
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+
+import java.util.List;
+
+
+/**
+ * @Description:
+ * @Author: wr
+ * @Date: 2024/12/16 16:00
+ */
+@Data
+public class PqScriptIssueParam {
+
+    @ApiModelProperty("检测脚本Id")
+    private String scriptId;
+
+    @ApiModelProperty("检测计划id")
+    private String planId;
+
+    @ApiModelProperty("终端id集合")
+    private List<String> devIds;
+
+    @ApiModelProperty()
+    private String isPhaseSequence;
+
+    @ApiModelProperty("源id")
+    private String sourceId;
+
+    private List<Integer> indexList;
+}

detection/src/main/java/com/njcn/gather/script/pojo/param/PqScriptParam.java

@@ -0,0 +1,82 @@
+package com.njcn.gather.script.pojo.param;
+
+import com.njcn.common.pojo.constant.PatternRegex;
+import com.njcn.gather.device.pojo.constant.DevValidMessage;
+import com.njcn.gather.system.pojo.constant.SystemValidMessage;
+import com.njcn.web.pojo.annotation.DateTimeStrValid;
+import com.njcn.web.pojo.param.BaseParam;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+
+import javax.validation.constraints.*;
+
+/**
+ * @author caozehui
+ * @data 2024/11/18
+ */
+@Data
+public class PqScriptParam {
+
+    @ApiModelProperty("名称")
+    @NotBlank(message = DevValidMessage.NAME_NOT_BLANK)
+    private String name;
+
+    @ApiModelProperty("类型")
+    @NotNull(message = DevValidMessage.SCRIPT_TYPE_NOT_BLANK)
+    @Min(value = 0, message = DevValidMessage.SCRIPT_TYPE_FORMAT_ERROR)
+    @Max(value = 1, message = DevValidMessage.SCRIPT_TYPE_FORMAT_ERROR)
+    private Integer type;
+
+    /**
+     * 检测脚本模式，字典表（数字、模拟、比对）
+     */
+    @ApiModelProperty("模式")
+    @NotBlank(message = DevValidMessage.PATTERN_NOT_BLANK)
+    @Pattern(regexp = PatternRegex.SYSTEM_ID, message = DevValidMessage.PATTERN_FORMAT_ERROR)
+    private String pattern;
+
+    /**
+     * 检测脚本值类型（在非比对模式情况下，分为相对值检测脚本和绝对值检测脚本）
+     */
+    @ApiModelProperty("值类型")
+    private String valueType;
+
+    @ApiModelProperty("参照标准名称")
+    @NotBlank(message = DevValidMessage.STANDARD_NAME_NOT_BLANK)
+    @Pattern(regexp = PatternRegex.ERR_SYS_NAME, message = DevValidMessage.STANDARD_NAME_FORMAT_ERROR)
+    private String standardName;
+
+
+    @ApiModelProperty("标准推行时间")
+    @NotBlank(message = DevValidMessage.STANDARD_TIME_NOT_BLANK)
+    @DateTimeStrValid(format = "yyyy", message = DevValidMessage.STANDARD_TIME_FORMAT_ERROR)
+    private String standardTime;
+
+    @Data
+    @EqualsAndHashCode(callSuper = true)
+    public static class QueryParam extends BaseParam {
+        @ApiModelProperty("名称")
+        private String name;
+
+        @ApiModelProperty("类型")
+        private Integer type;
+
+        @ApiModelProperty("值类型")
+        private String valueType;
+
+        @ApiModelProperty("模式")
+        @NotBlank(message = DevValidMessage.PATTERN_NOT_BLANK)
+        @Pattern(regexp = PatternRegex.SYSTEM_ID, message = DevValidMessage.PATTERN_FORMAT_ERROR)
+        private String pattern;
+    }
+
+    @Data
+    @EqualsAndHashCode(callSuper = true)
+    public static class UpdateParam extends PqScriptParam {
+        @ApiModelProperty("检测脚本ID")
+        @NotBlank(message = DevValidMessage.ID_NOT_BLANK)
+        @Pattern(regexp = PatternRegex.SYSTEM_ID, message = SystemValidMessage.ID_FORMAT_ERROR)
+        private String id;
+    }
+}

detection/src/main/java/com/njcn/gather/script/pojo/po/PqScript.java

@@ -0,0 +1,71 @@
+package com.njcn.gather.script.pojo.po;
+
+import com.baomidou.mybatisplus.annotation.TableName;
+import com.fasterxml.jackson.annotation.JsonFormat;
+import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
+import com.fasterxml.jackson.databind.annotation.JsonSerialize;
+import com.fasterxml.jackson.datatype.jsr310.deser.LocalDateDeserializer;
+import com.fasterxml.jackson.datatype.jsr310.deser.LocalDateTimeDeserializer;
+import com.fasterxml.jackson.datatype.jsr310.ser.LocalDateSerializer;
+import com.fasterxml.jackson.datatype.jsr310.ser.LocalDateTimeSerializer;
+import com.njcn.db.mybatisplus.bo.BaseEntity;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+
+import java.io.Serializable;
+import java.time.LocalDate;
+import java.util.Date;
+
+/**
+ * @author caozehui
+ * @date 2024-11-18
+ */
+@Data
+@EqualsAndHashCode(callSuper = true)
+@TableName("pq_script")
+public class PqScript extends BaseEntity implements Serializable {
+    private static final long serialVersionUID = -61550003510158595L;
+    /**
+     * 检测脚本ID
+     */
+    private String id;
+
+    /**
+     * 检测脚本名称
+     */
+    private String name;
+
+    /**
+     * 检测脚本类型,字典表（脚本还是模板）
+     */
+    private Integer type;
+
+    /**
+     * 检测脚本模式，字典表（数字、模拟、比对）
+     */
+    private String pattern;
+
+    /**
+     * 检测脚本值类型（在非比对模式情况下，分为相对值检测脚本和绝对值检测脚本）
+     */
+    private String valueType;
+
+    /**
+     * 参照标准名称
+     */
+    private String standardName;
+
+    /**
+     * 标准推行时间
+     */
+    @JsonFormat(pattern = "yyyy")
+    @JsonDeserialize(using = LocalDateDeserializer.class)
+    @JsonSerialize(using = LocalDateSerializer.class)
+    private LocalDate standardTime;
+
+    /**
+     * 状态：0-删除 1-正常
+     */
+    private Integer state;
+}
+

detection/src/main/java/com/njcn/gather/script/pojo/po/PqScriptCheckData.java

@@ -0,0 +1,72 @@
+package com.njcn.gather.script.pojo.po;
+
+import com.baomidou.mybatisplus.annotation.TableField;
+import com.baomidou.mybatisplus.annotation.TableId;
+import com.baomidou.mybatisplus.annotation.TableName;
+import lombok.Data;
+
+import java.io.Serializable;
+
+@Data
+@TableName(value = "pq_script_checkdata")
+public class PqScriptCheckData implements Serializable {
+
+
+    private static final long serialVersionUID = 1L;
+    /**
+     * 检测脚本参考设定值ID
+     */
+    @TableId
+    private String id;
+
+    /**
+     * 检测脚本ID
+     */
+    private String scriptId;
+
+    /**
+     * 总检测脚本中的测试项序号
+     */
+    private Integer index;
+
+    /**
+     * 检测指标类型，与数据字典关联（例如电压有效值、谐波电压含有率等）
+     */
+    private String valueType;
+
+    @TableField(exist = false)
+    private String valueTypeCode;
+
+    /**
+     * 数据类型，来源于字典表，包括实时数据(3s)、分钟统计数据(1min/3min/5min/10min)等
+     */
+    private String dataType;
+
+    /**
+     * 相别,字典表
+     */
+    private String phase;
+
+    /**
+     * 值
+     */
+    private Double value;
+
+    /**
+     * (间)谐波次数
+     */
+    @TableField("HarmNum")
+    private Double harmNum;
+
+    /**
+     * 状态：0-不启用 1-启用
+     */
+    private Integer enable;
+
+    /**
+     * 是否参与误差比较：0-不参与 1-参与
+     */
+    @TableField("Error_Flag")
+    private Integer errorFlag;
+
+}

detection/src/main/java/com/njcn/gather/script/pojo/po/PqScriptDtls.java

@@ -0,0 +1,111 @@
+package com.njcn.gather.script.pojo.po;
+
+import com.baomidou.mybatisplus.annotation.TableField;
+import com.baomidou.mybatisplus.annotation.TableName;
+import lombok.Data;
+
+import java.io.Serializable;
+
+/**
+ * @author caozehui
+ * @date 2024-11-18
+ */
+@Data
+@TableName("pq_script_dtls")
+public class PqScriptDtls implements Serializable {
+
+    private static final long serialVersionUID = 111579281505485316L;
+    /**
+     * 检测脚本子表ID
+     */
+    private String id;
+
+    /**
+     * 检测脚本ID
+     */
+    @TableField("Script_Id")
+    private String scriptId;
+
+    /**
+     * 总检测脚本中的测试项序号
+     */
+    @TableField("Index")
+    private Integer index;
+
+    /**
+     * 检测脚本类型
+     */
+    @TableField("Script_Type")
+    private String scriptType;
+
+    /**
+     * 检测脚本类型
+     */
+    @TableField(exist = false)
+    private String scriptCode;
+
+    /**
+     * 表明指标类型（例如：Freq频率下的影响、Base额定下的影响、VOL电压下的影响）
+     */
+    @TableField("Script_SubType")
+    private String scriptSubType;
+
+    /**
+     * 表明指标类型（例如：VOL电压、CUR电流、Freq频率...）
+     */
+    @TableField("Value_Type")
+    private String valueType;
+
+    /**
+     * 相别,字典表
+     */
+    private String phase;
+
+    /**
+     * 值
+     */
+    private Double value;
+
+    /**
+     * 相角
+     */
+    private Double angle;
+
+    /**
+     * （间）谐波次数
+     */
+    @TableField("HarmNum")
+    private Double harmNum;
+
+    /**
+     * 暂态幅度（%）
+     */
+    @TableField("TransValue")
+    private Double transValue;
+
+    /**
+     * 持续时间（周波）
+     */
+    @TableField("RetainTime")
+    private Double retainTime;
+
+    /**
+     * 变动频度（次/min）
+     */
+    @TableField("ChagFre")
+    private Double chagFre;
+
+    /**
+     * 变动量（%）
+     */
+    @TableField("ChagValue")
+    private Double chagValue;
+
+    /**
+     * 状态：0-不启用 1-启用
+     */
+    @TableField("Enable")
+    private Integer enable;
+
+}
+

detection/src/main/java/com/njcn/gather/script/pojo/po/SourceIssue.java

@@ -0,0 +1,305 @@
+package com.njcn.gather.script.pojo.po;
+
+import com.alibaba.fastjson.annotation.JSONField;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import java.util.List;
+
+/**
+ * @author wr
+ * @description
+ * @date 2024/12/16 11:24
+ */
+@NoArgsConstructor
+@Data
+public class SourceIssue {
+
+    /**
+     * 检测小项dtls Id
+     */
+    private String id;
+
+    /**
+     * 源ID
+     */
+    @JSONField(name = "sourceId", ordinal = 1)
+    private String sourceId;
+
+    /**
+     * 检测脚本
+     */
+    @JSONField(serialize = false)
+    private String scriptId;
+
+    /**
+     * 总检测下的检测脚本序号
+     */
+    @JSONField(serialize = false)
+    private Integer index;
+
+    /**
+     * 装置下发参数
+     */
+    @JSONField(serialize = false)
+    private List<String> devValueTypeList;
+
+
+    @JSONField(serialize = false)
+    private String desc;
+
+
+    /**
+     * 检测类型
+     */
+    @JSONField(name = "type", ordinal = 2)
+    private String type;
+
+    /**
+     * 多量响量
+     */
+    @JSONField(name = "subType", ordinal = 3)
+    private String subType;
+
+    /**
+     * 被检设备额定电压
+     */
+    @JSONField(name = "fUn", ordinal = 4)
+    private Double fUn;
+
+    /**
+     * 被检设备额定电流
+     */
+    @JSONField(name = "fIn", ordinal = 5)
+    private Double fIn;
+
+    /**
+     * 频率
+     */
+    @JSONField(name = "fFreq", ordinal = 6)
+    private Double fFreq;
+
+    /**
+     * 通道信息
+     */
+    @JSONField(name = "channelList", ordinal = 7)
+    private List<ChannelListDTO> channelList;
+
+    @NoArgsConstructor
+    @Data
+    public static class ChannelListDTO {
+
+        /**
+         * 通道使能标志
+         */
+        @JSONField(name = "channelFlag", ordinal = 1)
+        private Boolean channelFlag;
+
+        /**
+         * 谐波使能标志
+         */
+        @JSONField(name = "harmFlag", ordinal = 2)
+        private Boolean harmFlag;
+
+        /**
+         * 间谐波使能标志
+         */
+        @JSONField(name = "inHarmFlag", ordinal = 3)
+        private Boolean inHarmFlag;
+
+        /**
+         * 暂态使能标志
+         */
+        @JSONField(name = "dipFlag", ordinal = 4)
+        private Boolean dipFlag;
+
+        /**
+         * 闪变使能标志
+         */
+        @JSONField(name = "flickerFlag", ordinal = 5)
+        private Boolean flickerFlag;
+
+        /**
+         * 通道信息 枚举类型，包括{Ua, Ub, Uc, Ux, Ia, Ib, Ic, Ix ,NULL}
+         */
+        @JSONField(name = "channelType", ordinal = 6)
+        private String channelType;
+
+        /**
+         * 幅值
+         */
+        @JSONField(name = "fAmp", ordinal = 7)
+        private Double fAmp;
+
+        /**
+         * 相角
+         */
+        @JSONField(name = "fPhase", ordinal = 8)
+        private Double fPhase;
+
+        /**
+         * 谐波叠加列表
+         */
+        @JSONField(name = "harmList", ordinal = 9)
+        private List<HarmModel> harmList;
+
+        /**
+         * 间谐波叠加列表
+         */
+        @JSONField(name = "inharmList", ordinal = 10)
+        private List<InharmModel> inharmList;
+
+        /**
+         * 暂态数据
+         */
+        @JSONField(name = "dipData", ordinal = 11)
+        private DipDataDTO dipData;
+
+        /**
+         * 闪变数据
+         */
+        @JSONField(name = "flickerData", ordinal = 12)
+        private FlickerDataDTO flickerData;
+
+
+        /**
+         * 谐波叠加列表
+         */
+        @NoArgsConstructor
+        @Data
+        public static class HarmModel {
+
+            /**
+             * 谐波次数
+             */
+            @JSONField(name = "harm", ordinal = 1)
+            private Double harm;
+
+            /**
+             * 谐波含有率
+             */
+            @JSONField(name = "fAmp", ordinal = 2)
+            private Double fAmp;
+
+            /**
+             * 谐波相角
+             */
+            @JSONField(name = "fPhase", ordinal = 3)
+            private Double fPhase;
+
+        }
+
+        /**
+         * 间谐波叠加列表
+         */
+        @NoArgsConstructor
+        @Data
+        public static class InharmModel {
+
+            /**
+             * 间谐波次数
+             */
+            @JSONField(name = "inharm", ordinal = 1)
+            private Double inharm;
+
+            /**
+             * 间谐波含有率
+             */
+            @JSONField(name = "fAmp", ordinal = 2)
+            private Double fAmp;
+
+            /**
+             * 间谐波相角
+             */
+            @JSONField(name = "fPhase", ordinal = 3)
+            private Double fPhase;
+
+        }
+
+
+        /**
+         * 暂态数据
+         */
+        @NoArgsConstructor
+        @Data
+        public static class DipDataDTO {
+
+            /**
+             * 暂态幅值（%）
+             */
+            @JSONField(name = "fTransValue", ordinal = 1)
+            private Double fTransValue;
+
+            /**
+             * 暂态前时间（s）
+             */
+            @JSONField(name = "fPreTime", ordinal = 2)
+            private Double fPreTime;
+
+            /**
+             * 写入时间（s）
+             */
+            @JSONField(name = "fRampIn", ordinal = 3)
+            private Double fRampIn;
+
+            /**
+             * 暂态持续时间（s）
+             */
+            @JSONField(name = "fRetainTime", ordinal = 4)
+            private Double fRetainTime;
+
+            @JSONField(serialize = false)
+            private Double retainTime;
+
+            /**
+             * 写出时间（s）
+             */
+            @JSONField(name = "fRampOut", ordinal = 5)
+            private Double fRampOut;
+
+            /**
+             * 暂态后时间（s）
+             */
+            @JSONField(name = "fAfterTime", ordinal = 6)
+            private Double fAfterTime;
+        }
+
+        /**
+         * 闪变数据
+         */
+        @NoArgsConstructor
+        @Data
+        public static class FlickerDataDTO {
+
+            /**
+             * 波动类型
+             */
+            @JSONField(name = "waveFluType", ordinal = 1)
+            private Object waveFluType;
+
+            /**
+             * 闪变调制波形类型
+             */
+            @JSONField(name = "waveType", ordinal = 2)
+            private Object waveType;
+
+            /**
+             * 占空比
+             */
+            @JSONField(name = "fDutyCycle", ordinal = 3)
+            private Double fDutyCycle;
+
+            /**
+             * 变动次数
+             */
+            @JSONField(name = "fChagFre", ordinal = 4)
+            private Double fChagFre;
+
+            /**
+             * 变动量
+             */
+            @JSONField(name = "fChagValue", ordinal = 5)
+            private Double fChagValue;
+        }
+    }
+}

detection/src/main/java/com/njcn/gather/script/pojo/vo/PqScriptCheckDataVO.java

@@ -0,0 +1,34 @@
+package com.njcn.gather.script.pojo.vo;
+
+import lombok.Data;
+
+import java.io.Serializable;
+
+@Data
+public class PqScriptCheckDataVO implements Serializable {
+
+
+    private static final long serialVersionUID = 1L;
+
+    /**
+     * 总检测脚本中的测试项序号
+     */
+    private String valueTypeId;
+
+    /**
+     * 检测指标类型，与数据字典关联（例如电压有效值、谐波电压含有率等）
+     */
+    private String valueTypeCode;
+
+    /**
+     * 数据类型，来源于字典表，包括实时数据(3s)、分钟统计数据(1min/3min/5min/10min)等
+     */
+    private String dataType;
+
+
+
+
+
+
+
+}

detection/src/main/java/com/njcn/gather/script/service/IPqScriptCheckDataService.java

@@ -0,0 +1,37 @@
+package com.njcn.gather.script.service;
+
+import com.baomidou.mybatisplus.extension.service.IService;
+import com.njcn.gather.script.pojo.param.PqScriptCheckDataParam;
+import com.njcn.gather.script.pojo.po.PqScriptCheckData;
+
+import java.util.List;
+import java.util.Map;
+
+
+/**
+ * @Description:
+ * @Author: wr
+ * @Date: 2024/12/27 9:29
+ */
+public interface IPqScriptCheckDataService extends IService<PqScriptCheckData> {
+
+
+    /**
+     * 获取检测指标类型
+     * @param param
+     * @return
+     */
+    List<String> getValueType(PqScriptCheckDataParam param);
+
+
+
+    Map<String,String> getValueTypeMap(String scriptId);
+
+    /**
+     * 获取监测脚本code
+     * @param param
+     * @return
+     */
+    List<PqScriptCheckData> listCheckDataCode(PqScriptCheckDataParam param);
+
+}

detection/src/main/java/com/njcn/gather/script/service/IPqScriptDtlsService.java

@@ -0,0 +1,72 @@
+package com.njcn.gather.script.service;
+
+import com.baomidou.mybatisplus.extension.service.IService;
+import com.njcn.gather.script.pojo.param.PqScriptIssueParam;
+import com.njcn.gather.script.pojo.po.PqScriptDtls;
+import com.njcn.gather.script.pojo.po.SourceIssue;
+
+import java.util.List;
+
+/**
+ * @author caozehui
+ * @date 2024-11-18
+ */
+public interface IPqScriptDtlsService extends IService<PqScriptDtls> {
+
+    /**
+     * 保存脚本详情
+     *
+     * @param pqScriptDtls 脚本详情
+     * @return 成功返回true，失败返回false
+     */
+    boolean savePqScriptDtls(PqScriptDtls pqScriptDtls);
+
+    /**
+     * 根据id删除脚本详情
+     *
+     * @param ids 脚本详情ids
+     * @return 成功返回true，失败返回false
+     */
+    boolean deletePqScriptDtlsByIds(List<String> ids);
+
+    /**
+     * 根据脚本id删除脚本详情
+     *
+     * @param scriptIds 脚本id
+     * @return 成功返回true，失败返回false
+     */
+    boolean deletePqScriptDtlsByScriptId(List<String> scriptIds);
+
+    /**
+     * 修改脚本详情
+     *
+     * @param pqScriptDtls 脚本详情
+     * @return 成功返回true，失败返回false
+     */
+    boolean updatePqScriptDtls(PqScriptDtls pqScriptDtls);
+
+    /**
+     * 根据脚本id查询脚本详情
+     *
+     * @param scriptId 脚本id
+     * @return 脚本详情列表
+     */
+    List<PqScriptDtls> listPqScriptDtlByScriptId(String scriptId);
+
+    /**
+     * 根据计划绑定检测脚本id获取全部检测脚本
+     *
+     * @param param
+     * @return
+     */
+    List<SourceIssue> listSourceIssue(PqScriptIssueParam param);
+
+    /**
+     * 根据脚本类型、脚本id获取index列表
+     *
+     * @param scriptType 脚本类型
+     * @param scriptId   脚本id
+     * @return index列表
+     */
+    List<Integer> getIndexList(String scriptType, String scriptId);
+}

detection/src/main/java/com/njcn/gather/script/service/IPqScriptService.java

@@ -0,0 +1,80 @@
+package com.njcn.gather.script.service;
+
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import com.baomidou.mybatisplus.extension.service.IService;
+import com.njcn.gather.script.pojo.param.PqScriptParam;
+import com.njcn.gather.script.pojo.po.PqScript;
+
+import java.util.List;
+import java.util.Map;
+
+/**
+ * @author caozehui
+ * @date 2024-11-18
+ */
+public interface IPqScriptService extends IService<PqScript> {
+
+    /**
+     * 分页查询检测脚本
+     *
+     * @param param 查询参数
+     * @return
+     */
+    Page<PqScript> listPqScript(PqScriptParam.QueryParam param);
+
+    /**
+     * 根据检测脚本id获取检测脚本
+     *
+     * @param id 检测脚本id
+     * @return 检测脚本
+     */
+    PqScript getPqScriptById(String id);
+
+    /**
+     * 新增检测脚本
+     *
+     * @param param 检测脚本
+     * @return 成功返回true, 失败返回false
+     */
+    boolean addPqScript(PqScriptParam param);
+
+    /**
+     * 删除检测脚本
+     *
+     * @param param 检测脚本id
+     * @return 成功返回true, 失败返回false
+     */
+    boolean updatePqScript(PqScriptParam.UpdateParam param);
+
+    /**
+     * 批量删除检测脚本
+     *
+     * @param ids 检测脚本id列表
+     * @return 成功返回true, 失败返回false
+     */
+    boolean deletePqScript(List<String> ids);
+
+    /**
+     * 将脚本升级为模板
+     *
+     * @param id 脚本id
+     * @return 成功返回true, 失败返回false
+     */
+    boolean upgradeToTemplate(String id);
+
+    /**
+     * 获取指定模式下所有检测脚本
+     *
+     * @param patternId 模式id
+     * @return 检测脚本列表
+     */
+    List<Map<String, Object>> listAllPqScript(String patternId);
+
+    /**
+     * 根据脚本名称查询脚本
+     *
+     * @param name 脚本名称
+     * @return 脚本列表
+     */
+    PqScript getPqScriptByName(String name);
+}

detection/src/main/java/com/njcn/gather/script/service/impl/PqScriptCheckDataServiceImpl.java

@@ -0,0 +1,103 @@
+package com.njcn.gather.script.service.impl;
+
+import cn.hutool.core.collection.CollUtil;
+import cn.hutool.core.util.ObjectUtil;
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.github.yulichang.wrapper.MPJLambdaWrapper;
+import com.njcn.common.pojo.enums.common.DataStateEnum;
+import com.njcn.gather.script.mapper.PqScriptCheckDataMapper;
+import com.njcn.gather.script.pojo.param.PqScriptCheckDataParam;
+import com.njcn.gather.script.pojo.po.PqScriptCheckData;
+import com.njcn.gather.script.service.IPqScriptCheckDataService;
+import com.njcn.gather.system.dictionary.mapper.DictTreeMapper;
+import com.njcn.gather.system.dictionary.pojo.po.DictTree;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+
+/**
+ * @Description:
+ * @Author: wr
+ * @Date: 2024/12/27 9:29
+ */
+@Slf4j
+@Service
+@RequiredArgsConstructor
+public class PqScriptCheckDataServiceImpl extends ServiceImpl<PqScriptCheckDataMapper, PqScriptCheckData> implements IPqScriptCheckDataService {
+
+    private final String V="real$V2-50";
+    private final String SV="real$SV_1-49";
+    private final String I="real$I2-50";
+    private final String IV="real$SI_1-49";
+
+    private final DictTreeMapper dictTreeMapper;
+
+    @Override
+    public List<String> getValueType(PqScriptCheckDataParam param) {
+        MPJLambdaWrapper<PqScriptCheckData> queryWrapper = new MPJLambdaWrapper<>();
+        queryWrapper.selectAll(PqScriptCheckData.class)
+                .leftJoin(DictTree.class, DictTree::getId, PqScriptCheckData::getValueType)
+                .eq(PqScriptCheckData::getScriptId, param.getScriptId())
+                .eq(ObjectUtil.isNotNull(param.getIndex()),PqScriptCheckData::getIndex, param.getIndex())
+                .eq(PqScriptCheckData::getEnable, DataStateEnum.ENABLE.getCode());
+        if (param.getIsValueTypeName()) {
+            queryWrapper.selectAs(DictTree::getCode, PqScriptCheckData::getValueType);
+        }
+        List<PqScriptCheckData> pqScriptCheckData = this.getBaseMapper().selectJoinList(PqScriptCheckData.class, queryWrapper);
+        if(CollUtil.isNotEmpty(pqScriptCheckData)){
+            if (param.getIsValueTypeName()) {
+                List<String> checkData = pqScriptCheckData.stream().map(x -> x.getDataType() + "$" + x.getValueType()).distinct().collect(Collectors.toList());
+                if(!checkData.contains("real$U1")){
+                    if(checkData.contains(V)||checkData.contains(SV)){
+                        checkData.add("real$U1");
+                    }
+                }
+                if(!checkData.contains("real$I1")){
+                    if(checkData.contains(I)||checkData.contains(IV)){
+                        checkData.add("real$I1");
+                    }
+                }
+                return checkData;
+            } else {
+                return pqScriptCheckData.stream().map(PqScriptCheckData::getValueType).distinct().collect(Collectors.toList());
+            }
+        }
+        return new ArrayList<>();
+    }
+
+    @Override
+    public Map<String,String> getValueTypeMap(String scriptId) {
+        LambdaQueryWrapper<PqScriptCheckData> queryWrapper = new LambdaQueryWrapper<>();
+        queryWrapper.select(PqScriptCheckData::getValueType)
+                .eq(PqScriptCheckData::getScriptId, scriptId)
+                .eq(PqScriptCheckData::getEnable, DataStateEnum.ENABLE.getCode());
+        List<PqScriptCheckData> pqScriptCheckData = this.baseMapper.selectList(queryWrapper);
+        List<String> valueTypeList = pqScriptCheckData.stream().map(PqScriptCheckData::getValueType).distinct().collect(Collectors.toList());
+        LambdaQueryWrapper<DictTree> dictTreeLambdaQueryWrapper = new LambdaQueryWrapper<>();
+        dictTreeLambdaQueryWrapper.in(DictTree::getId,valueTypeList).eq(DictTree::getState,DataStateEnum.DELETED.getCode());
+        List<DictTree> dictTreeList = dictTreeMapper.selectList(dictTreeLambdaQueryWrapper);
+        Map<String,String> map = dictTreeList.stream().collect(Collectors.toMap(DictTree::getCode,DictTree::getId));
+        return map;
+    }
+
+    @Override
+    public List<PqScriptCheckData> listCheckDataCode(PqScriptCheckDataParam param) {
+        MPJLambdaWrapper<PqScriptCheckData> queryWrapper = new MPJLambdaWrapper<>();
+        queryWrapper.selectAll(PqScriptCheckData.class)
+                .leftJoin(DictTree.class, DictTree::getId, PqScriptCheckData::getValueType)
+                .selectAs(DictTree::getCode, PqScriptCheckData::getValueTypeCode)
+                .eq(PqScriptCheckData::getScriptId, param.getScriptId())
+                .eq(PqScriptCheckData::getIndex, param.getIndex())
+                .eq(PqScriptCheckData::getEnable, DataStateEnum.ENABLE.getCode());
+        return this.getBaseMapper().selectJoinList(PqScriptCheckData.class, queryWrapper);
+    }
+
+
+}

detection/src/main/java/com/njcn/gather/script/service/impl/PqScriptDtlsServiceImpl.java

@@ -0,0 +1,406 @@
+package com.njcn.gather.script.service.impl;
+
+import cn.hutool.core.collection.CollUtil;
+import cn.hutool.core.util.NumberUtil;
+import cn.hutool.core.util.StrUtil;
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.github.yulichang.wrapper.MPJLambdaWrapper;
+import com.njcn.common.pojo.enums.common.DataStateEnum;
+import com.njcn.gather.device.pojo.po.PqDev;
+import com.njcn.gather.device.service.IPqDevService;
+import com.njcn.gather.device.pojo.enums.CommonEnum;
+import com.njcn.gather.script.mapper.PqScriptDtlsMapper;
+import com.njcn.gather.script.mapper.PqScriptMapper;
+import com.njcn.gather.script.pojo.param.PqScriptCheckDataParam;
+import com.njcn.gather.script.pojo.param.PqScriptIssueParam;
+import com.njcn.gather.script.pojo.po.PqScript;
+import com.njcn.gather.script.pojo.po.PqScriptCheckData;
+import com.njcn.gather.script.pojo.po.PqScriptDtls;
+import com.njcn.gather.script.pojo.po.SourceIssue;
+import com.njcn.gather.script.service.IPqScriptCheckDataService;
+import com.njcn.gather.script.service.IPqScriptDtlsService;
+import com.njcn.gather.script.util.ScriptDtlsDesc;
+import com.njcn.gather.system.dictionary.pojo.po.DictTree;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.math.BigDecimal;
+import java.util.*;
+import java.util.stream.Collectors;
+
+/**
+ * @author caozehui
+ * @date 2024-11-18
+ */
+@Slf4j
+@Service
+@RequiredArgsConstructor
+public class PqScriptDtlsServiceImpl extends ServiceImpl<PqScriptDtlsMapper, PqScriptDtls> implements IPqScriptDtlsService {
+
+    private final static String FREQ = "Freq";
+    private final static String VOL = "VOL";
+    private final static String CUR = "CUR";
+    private final static String HARM_V = "Harm_V";
+    private final static String HARM_I = "Harm_I";
+    private final static String INHARM_V = "InHarm_V";
+    private final static String INHARM_I = "InHarm_I";
+    private final static String DIP = "Dip";
+    private final static String FLICKER = "Flicker";
+    @Value("${Dip.fPreTime}")
+    private Double fPreTime;
+    @Value("${Dip.fRampIn}")
+    private Double fRampIn;
+    @Value("${Dip.fRampOut}")
+    private Double fRampOut;
+    @Value("${Dip.fAfterTime}")
+    private Double fAfterTime;
+    @Value("${Flicker.waveFluType}")
+    private String waveFluType;
+    @Value("${Flicker.waveType}")
+    private String waveType;
+    @Value("${Flicker.fDutyCycle}")
+    private Double fDutyCycle;
+
+
+    private final IPqDevService pqDevService;
+    private final PqScriptMapper pqScriptMapper;
+    private final IPqScriptCheckDataService pqScriptCheckDataService;
+
+    @Override
+    @Transactional(rollbackFor = {Exception.class})
+    public boolean savePqScriptDtls(PqScriptDtls pqScriptDtls) {
+        return this.save(pqScriptDtls);
+    }
+
+    @Override
+    @Transactional(rollbackFor = {Exception.class})
+    public boolean deletePqScriptDtlsByIds(List<String> ids) {
+        LambdaQueryWrapper<PqScriptDtls> queryWrapper = new LambdaQueryWrapper<>();
+        queryWrapper.in(PqScriptDtls::getId, ids);
+        return this.remove(queryWrapper);
+    }
+
+    @Override
+    @Transactional(rollbackFor = {Exception.class})
+    public boolean deletePqScriptDtlsByScriptId(List<String> scriptIds) {
+        LambdaQueryWrapper<PqScriptDtls> queryWrapper = new LambdaQueryWrapper<>();
+        queryWrapper.in(PqScriptDtls::getScriptId, scriptIds);
+        return this.remove(queryWrapper);
+    }
+
+    @Override
+    @Transactional(rollbackFor = {Exception.class})
+    public boolean updatePqScriptDtls(PqScriptDtls pqScriptDtls) {
+        return this.updateById(pqScriptDtls);
+    }
+
+    @Override
+    public List<PqScriptDtls> listPqScriptDtlByScriptId(String scriptId) {
+        MPJLambdaWrapper<PqScriptDtls> queryWrapper = new MPJLambdaWrapper<>();
+        queryWrapper.selectAll(PqScriptDtls.class)
+                .leftJoin(PqScript.class, PqScript::getId, PqScriptDtls::getScriptId)
+                .eq(PqScript::getState, DataStateEnum.ENABLE.getCode())
+                .eq(StrUtil.isNotBlank(scriptId), PqScriptDtls::getScriptId, scriptId);
+        return this.getBaseMapper().selectJoinList(PqScriptDtls.class, queryWrapper);
+    }
+
+    @Override
+    public List<SourceIssue> listSourceIssue(PqScriptIssueParam param) {
+        List<SourceIssue> sourceIssues = new ArrayList<>();
+        //校验终端额定电压电流是否相同
+        List<PqDev> list = pqDevService.list(new LambdaQueryWrapper<PqDev>()
+                .eq(PqDev::getPlanId, param.getPlanId())
+                .in(PqDev::getId, param.getDevIds())
+                .eq(PqDev::getState, DataStateEnum.ENABLE.getCode())
+        );
+        //额定电压信息
+        Set<Double> voltSet = list.stream().map(PqDev::getDevVolt).collect(Collectors.toSet());
+        //额定电流信息
+        Set<Double> currSet = list.stream().map(PqDev::getDevCurr).collect(Collectors.toSet());
+        if (voltSet.size() == 1 && currSet.size() == 1) {
+            Double volt = voltSet.stream().collect(Collectors.toList()).stream().findFirst().get();
+            Double curr = currSet.stream().collect(Collectors.toList()).stream().findFirst().get();
+            List<PqScriptDtls> pqScriptDtls = this.pqScriptDtls(param.getScriptId(), param.getIsPhaseSequence(), volt, curr, param.getIndexList());
+            Boolean isValueType = pqScriptMapper.selectScriptIsValueType(param.getScriptId());
+            if (CollUtil.isNotEmpty(pqScriptDtls)) {
+                /**
+                 * 1.获取全部检测点脚本
+                 * 2.根据检测脚本Index,进行分组来确定是第几行数据，理论上基本数据只有七条
+                 * 3.根据见树形字典在区分大类下面有多少小类
+                 * 3.组装所有检测格式
+                 */
+                Map<Integer, List<PqScriptDtls>> scriptDtlsMap = pqScriptDtls.stream()
+                        .sorted(Comparator.comparing(PqScriptDtls::getIndex))
+                        .collect(Collectors.groupingBy(PqScriptDtls::getIndex, LinkedHashMap::new, Collectors.toList()));
+                scriptDtlsMap.forEach((key, value) -> {
+                    /**
+                     * 分组获取有多少小类
+                     *  VOL-Base:额定工作条件下的检测
+                     *  VOL-Freq:频率对电压测量的影响
+                     *  VOL-Harm:谐波对电压测量的影响
+                     */
+                    List<PqScriptDtls> freq = value.stream().filter(x -> FREQ.equals(x.getValueType())).collect(Collectors.toList());
+                    if (CollUtil.isNotEmpty(freq)) {
+                        PqScriptDtls freqDtls = freq.get(0);
+                        SourceIssue issue = new SourceIssue();
+                        issue.setId(freqDtls.getId());
+                        issue.setSourceId(param.getSourceId());
+                        issue.setType(freqDtls.getScriptCode());
+                        issue.setIndex(freqDtls.getIndex());
+                        String scriptSubType = freqDtls.getScriptSubType();
+                        issue.setSubType(StrUtil.isBlank(scriptSubType) ? scriptSubType : scriptSubType.replace("Base", "NULL"));
+                        PqScriptCheckDataParam checkDataParam = new PqScriptCheckDataParam();
+                        checkDataParam.setScriptId(freqDtls.getScriptId());
+                        checkDataParam.setIndex(freqDtls.getIndex());
+                        checkDataParam.setIsValueTypeName(true);
+                        issue.setDevValueTypeList(pqScriptCheckDataService.getValueType(checkDataParam));
+                        issue.setDesc(ScriptDtlsDesc.getStringBuffer(value, isValueType).toString());
+                        issue.setScriptId(freqDtls.getScriptId());
+                        issue.setFUn(volt);
+                        issue.setFIn(curr);
+                        issue.setFFreq(freqDtls.getValue());
+                        List<SourceIssue.ChannelListDTO> channelListDTOS = new ArrayList<>();
+
+                        //1.通道电压(ABC)
+                        List<PqScriptDtls> volList = value.stream().filter(x -> VOL.equals(x.getValueType()))
+                                .sorted(Comparator.comparing(PqScriptDtls::getPhase))
+                                .collect(Collectors.toList());
+                        //谐波电压,间谐波
+                        List<PqScriptDtls> dtlsVList = value.stream().filter(x -> HARM_V.equals(x.getValueType()) ||
+                                        INHARM_V.equals(x.getValueType()) ||
+                                        DIP.equals(x.getValueType()) ||
+                                        FLICKER.equals(x.getValueType())
+                                )
+                                .sorted(Comparator.comparing(PqScriptDtls::getPhase))
+                                .collect(Collectors.toList());
+                        issueAdd(volList, dtlsVList, HARM_V, INHARM_V, freqDtls.getValue(), "U", channelListDTOS);
+
+                        //2.通道电流(ABC)
+                        List<PqScriptDtls> curList = value.stream().filter(x -> CUR.equals(x.getValueType()))
+                                .sorted(Comparator.comparing(PqScriptDtls::getPhase))
+                                .collect(Collectors.toList());
+                        //谐波电流,间谐波电流
+                        List<PqScriptDtls> dtlsIList = value.stream().filter(x -> HARM_I.equals(x.getValueType()) ||
+                                        INHARM_I.equals(x.getValueType())
+                                )
+                                .sorted(Comparator.comparing(PqScriptDtls::getPhase))
+                                .collect(Collectors.toList());
+                        issueAdd(curList, dtlsIList, HARM_I, INHARM_I, freqDtls.getValue(), "I", channelListDTOS);
+
+                        issue.setChannelList(channelListDTOS);
+                        sourceIssues.add(issue);
+                    }
+                });
+            }
+
+        }
+
+        return sourceIssues;
+    }
+
+
+    @Override
+    public List<Integer> getIndexList(String scriptType, String scriptId) {
+        MPJLambdaWrapper<PqScriptDtls> wrapper = new MPJLambdaWrapper<>();
+        wrapper.select(PqScriptDtls::getIndex)
+                .distinct()
+                .eq(PqScriptDtls::getScriptType, scriptType)
+                .eq(PqScriptDtls::getScriptId, scriptId);
+        return this.getBaseMapper().selectJoinList(PqScriptDtls.class, wrapper).stream().map(PqScriptDtls::getIndex).collect(Collectors.toList());
+    }
+
+    public List<PqScriptDtls> pqScriptDtls(String scriptId, String isPhaseSequence, Double volt, Double curr, List<Integer> indexList) {
+        List<PqScriptDtls> pqScriptDtls;
+        MPJLambdaWrapper<PqScriptDtls> queryWrapper = new MPJLambdaWrapper<>();
+        queryWrapper.selectAll(PqScriptDtls.class)
+                .selectAs(DictTree::getCode, PqScriptDtls::getScriptCode)
+                .leftJoin(DictTree.class, DictTree::getId, PqScriptDtls::getScriptType)
+//                .eq(PqScriptDtls::getIndex, 1)
+//                .le(PqScriptDtls::getIndex, 30)
+//                .in(PqScriptDtls::getIndex, Arrays.asList(1,7))
+
+                .eq(PqScriptCheckData::getEnable, DataStateEnum.ENABLE.getCode());
+        if (isPhaseSequence.equals(CommonEnum.PHASE_TEST.getValue())) {
+            //相序
+            queryWrapper.eq(PqScriptDtls::getIndex, -1)
+                    .eq(PqScriptDtls::getEnable, 1);
+            pqScriptDtls = this.list(queryWrapper);
+        } else if (isPhaseSequence.equals(CommonEnum.COEFFICIENT_TEST.getValue())) {
+            //系数
+            queryWrapper.in(PqScriptDtls::getIndex, indexList)
+                    .eq(PqScriptDtls::getEnable, 1);
+            pqScriptDtls = this.list(queryWrapper);
+        } else {
+            //先获取检测脚本类型是否相对值  true相对值 false绝对值（相对值要乘额定值,绝对值不需要处理)
+            Boolean isValueType = pqScriptMapper.selectScriptIsValueType(scriptId);
+            queryWrapper.eq(PqScriptDtls::getScriptId, scriptId);
+            pqScriptDtls = this.getBaseMapper().selectJoinList(PqScriptDtls.class, queryWrapper);
+            if (isValueType) {
+                for (PqScriptDtls pqScriptDtl : pqScriptDtls) {
+                    if (VOL.equals(pqScriptDtl.getValueType())) {
+                        BigDecimal volValue = new BigDecimal(pqScriptDtl.getValue());
+                        BigDecimal result = volValue.divide(new BigDecimal(100), 2, BigDecimal.ROUND_HALF_UP)
+                                .multiply(new BigDecimal(volt.toString()));
+                        pqScriptDtl.setValue(result.doubleValue());
+                    }
+                    if (CUR.equals(pqScriptDtl.getValueType())) {
+                        BigDecimal volValue = new BigDecimal(pqScriptDtl.getValue());
+                        BigDecimal result = volValue.divide(new BigDecimal(100), 2, BigDecimal.ROUND_HALF_UP)
+                                .multiply(new BigDecimal(curr.toString()));
+                        pqScriptDtl.setValue(result.doubleValue());
+                    }
+                }
+            }
+        }
+
+        return pqScriptDtls;
+    }
+
+
+    /**
+     * @param dtlsList        检测集合
+     * @param dtlsList        其他类型检测集合(谐波，间谐波等)
+     * @param harm            谐波
+     * @param inHarm          间谐波
+     * @param fFreq           频率
+     * @param code            U,I
+     * @param channelListDTOS 通道信息
+     * @param channelListDTOS 通道信息
+     * @Description: 通道信息组装
+     * @Author: wr
+     * @Date: 2024/12/16 15:51
+     */
+    private void issueAdd(List<PqScriptDtls> dtlsList,
+                          List<PqScriptDtls> dtlsOtherList,
+                          String harm,
+                          String inHarm,
+                          Double fFreq,
+                          String code,
+                          List<SourceIssue.ChannelListDTO> channelListDTOS) {
+        for (PqScriptDtls dtls : dtlsList) {
+            SourceIssue.ChannelListDTO channelListDTO = new SourceIssue.ChannelListDTO();
+            channelListDTO.setChannelFlag(true);
+            channelListDTO.setHarmFlag(false);
+            channelListDTO.setInHarmFlag(false);
+            channelListDTO.setDipFlag(false);
+            channelListDTO.setFlickerFlag(false);
+            channelListDTO.setChannelType(code + dtls.getPhase().toLowerCase());
+            channelListDTO.setFAmp(dtls.getValue());
+            channelListDTO.setFPhase(dtls.getAngle());
+            channelListDTO.setHarmList(new ArrayList<>());
+            channelListDTO.setInharmList(new ArrayList<>());
+            //暂态数据
+            SourceIssue.ChannelListDTO.DipDataDTO dipDataDTO = new SourceIssue.ChannelListDTO.DipDataDTO();
+            dipDataDTO.setFTransValue(0.0);
+            dipDataDTO.setFRetainTime(0.0);
+
+            dipDataDTO.setFPreTime(fPreTime);
+            dipDataDTO.setFRampIn(fRampIn);
+            dipDataDTO.setFRampOut(fRampOut);
+            dipDataDTO.setFAfterTime(fAfterTime);
+
+
+            channelListDTO.setDipData(dipDataDTO);
+            //闪变数据
+            SourceIssue.ChannelListDTO.FlickerDataDTO flickerDataDTO = new SourceIssue.ChannelListDTO.FlickerDataDTO();
+            flickerDataDTO.setWaveFluType(waveFluType);
+            flickerDataDTO.setWaveType(waveType);
+            flickerDataDTO.setFDutyCycle(fDutyCycle);
+
+            flickerDataDTO.setFChagFre(0.0);
+            flickerDataDTO.setFChagValue(0.0);
+            channelListDTO.setFlickerData(flickerDataDTO);
+
+
+            if (CollUtil.isNotEmpty(dtlsOtherList)) {
+                List<PqScriptDtls> phaseList = dtlsOtherList.stream().filter(x -> dtls.getPhase().equals(x.getPhase()))
+                        .sorted(Comparator.comparing(PqScriptDtls::getHarmNum))
+                        .collect(Collectors.toList());
+                if (CollUtil.isNotEmpty(phaseList)) {
+                    //处理谐波类型
+                    List<PqScriptDtls> harmList = phaseList.stream().filter(x -> harm.equals(x.getValueType()))
+                            .collect(Collectors.toList());
+                    if (CollUtil.isNotEmpty(harmList)) {
+                        channelListDTO.setHarmList(getHarmModels(harmList));
+                        channelListDTO.setHarmFlag(true);
+                    }
+                    //处理间谐波类型
+                    List<PqScriptDtls> inHarmList = phaseList.stream().filter(x -> inHarm.equals(x.getValueType()))
+                            .collect(Collectors.toList());
+                    if (CollUtil.isNotEmpty(inHarmList)) {
+                        channelListDTO.setInharmList(getInHarmModels(inHarmList));
+                        channelListDTO.setInHarmFlag(true);
+                    }
+                    //处理暂态数据
+                    List<PqScriptDtls> dipList = phaseList.stream().filter(x -> DIP.equals(x.getValueType()))
+                            .collect(Collectors.toList());
+                    if (CollUtil.isNotEmpty(dipList)) {
+                        PqScriptDtls dip = dipList.get(0);
+                        dipDataDTO.setFTransValue(dip.getTransValue());
+                        //  1.0/频率*持续时间（周波）= 暂态持续时间（s）
+                        dipDataDTO.setFRetainTime(NumberUtil.round(1.0 / fFreq * dip.getRetainTime(), 3).doubleValue());
+                        dipDataDTO.setRetainTime(dip.getRetainTime());
+                        channelListDTO.setDipFlag(true);
+                        channelListDTO.setDipData(dipDataDTO);
+                    }
+                    //处理闪变数据
+                    List<PqScriptDtls> flickeRList = phaseList.stream().filter(x -> FLICKER.equals(x.getValueType()))
+                            .collect(Collectors.toList());
+                    if (CollUtil.isNotEmpty(flickeRList)) {
+                        PqScriptDtls flicker = flickeRList.get(0);
+
+                        flickerDataDTO.setFChagFre(flicker.getChagFre());
+                        flickerDataDTO.setFChagValue(flicker.getChagValue());
+
+                        channelListDTO.setFlickerFlag(true);
+                        channelListDTO.setFlickerData(flickerDataDTO);
+                    }
+
+                }
+            }
+            channelListDTOS.add(channelListDTO);
+        }
+    }
+
+    /**
+     * 处理谐波信息
+     *
+     * @param phaseHarmVList
+     * @return
+     */
+    private List<SourceIssue.ChannelListDTO.HarmModel> getHarmModels(List<PqScriptDtls> phaseHarmVList) {
+        List<SourceIssue.ChannelListDTO.HarmModel> info = new ArrayList<>();
+        SourceIssue.ChannelListDTO.HarmModel harmModel;
+        for (PqScriptDtls pqScriptDtls : phaseHarmVList) {
+            harmModel = new SourceIssue.ChannelListDTO.HarmModel();
+            harmModel.setHarm(pqScriptDtls.getHarmNum().doubleValue());
+            harmModel.setFAmp(pqScriptDtls.getValue());
+            harmModel.setFPhase(pqScriptDtls.getAngle());
+            info.add(harmModel);
+        }
+        return info;
+    }
+
+    /**
+     * 处理间谐波谐波信息
+     *
+     * @param phaseHarmVList
+     * @return
+     */
+    private List<SourceIssue.ChannelListDTO.InharmModel> getInHarmModels(List<PqScriptDtls> phaseHarmVList) {
+        List<SourceIssue.ChannelListDTO.InharmModel> info = new ArrayList<>();
+        SourceIssue.ChannelListDTO.InharmModel inHarmModel;
+        for (PqScriptDtls pqScriptDtls : phaseHarmVList) {
+            inHarmModel = new SourceIssue.ChannelListDTO.InharmModel();
+            inHarmModel.setInharm(pqScriptDtls.getHarmNum());
+            inHarmModel.setFAmp(pqScriptDtls.getValue());
+            inHarmModel.setFPhase(pqScriptDtls.getAngle());
+            info.add(inHarmModel);
+        }
+        return info;
+    }
+}

detection/src/main/java/com/njcn/gather/script/service/impl/PqScriptServiceImpl.java

@@ -0,0 +1,114 @@
+package com.njcn.gather.script.service.impl;
+
+import cn.hutool.core.util.ObjectUtil;
+import cn.hutool.core.util.StrUtil;
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
+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.gather.script.mapper.PqScriptMapper;
+import com.njcn.gather.script.pojo.param.PqScriptParam;
+import com.njcn.gather.script.pojo.po.PqScript;
+import com.njcn.gather.script.service.IPqScriptDtlsService;
+import com.njcn.gather.script.service.IPqScriptService;
+import com.njcn.web.factory.PageFactory;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.BeanUtils;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.time.LocalDate;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+/**
+ * @author caozehui
+ * @date 2024-11-18
+ */
+@Slf4j
+@Service
+@RequiredArgsConstructor
+public class PqScriptServiceImpl extends ServiceImpl<PqScriptMapper, PqScript> implements IPqScriptService {
+
+    private final IPqScriptDtlsService pqScriptDtlsService;
+
+    @Override
+    public Page<PqScript> listPqScript(PqScriptParam.QueryParam param) {
+        QueryWrapper<PqScript> queryWrapper = new QueryWrapper<>();
+        if (ObjectUtil.isNotEmpty(param)) {
+            queryWrapper.like(StrUtil.isNotBlank(param.getName()), "pq_script.name", param.getName())
+                    .eq(ObjectUtil.isNotNull(param.getType()), "pq_script.type", param.getType())
+                    .eq(StrUtil.isNotBlank(param.getValueType()), "pq_script.Value_Type", param.getValueType())
+                    .eq(StrUtil.isNotBlank(param.getPattern()), "pq_script.pattern", param.getPattern());
+        }
+        queryWrapper.eq("pq_script.state", DataStateEnum.ENABLE.getCode()).orderByAsc("pq_script.create_time");
+        return this.page(new Page<>(PageFactory.getPageNum(param), PageFactory.getPageSize(param)), queryWrapper);
+    }
+
+    @Override
+    public PqScript getPqScriptById(String id) {
+        return this.lambdaQuery().eq(PqScript::getId, id).eq(PqScript::getState, DataStateEnum.ENABLE.getCode()).one();
+    }
+
+    @Override
+    @Transactional(rollbackFor = {Exception.class})
+    public boolean addPqScript(PqScriptParam param) {
+        PqScript pqScript = new PqScript();
+        BeanUtils.copyProperties(param, pqScript);
+        pqScript.setStandardTime(LocalDate.of(Integer.parseInt(param.getStandardTime()), 1, 1));
+        pqScript.setState(DataStateEnum.ENABLE.getCode());
+        return this.save(pqScript);
+    }
+
+    @Override
+    @Transactional(rollbackFor = {Exception.class})
+    public boolean updatePqScript(PqScriptParam.UpdateParam param) {
+        PqScript pqScript = new PqScript();
+        BeanUtils.copyProperties(param, pqScript);
+        pqScript.setState(DataStateEnum.ENABLE.getCode());
+        return this.updateById(pqScript);
+    }
+
+    @Override
+    @Transactional(rollbackFor = {Exception.class})
+    public boolean deletePqScript(List<String> ids) {
+        //删除对应的脚本详情
+        pqScriptDtlsService.deletePqScriptDtlsByScriptId(ids);
+        LambdaUpdateWrapper<PqScript> updateWrapper = new LambdaUpdateWrapper<>();
+        updateWrapper.set(PqScript::getState, DataStateEnum.DELETED.getCode())
+                .in(PqScript::getId, ids);
+        return this.update(updateWrapper);
+    }
+
+    @Override
+    @Transactional(rollbackFor = {Exception.class})
+    public boolean upgradeToTemplate(String id) {
+        PqScript pqScript = this.lambdaQuery().eq(PqScript::getId, id).one();
+        if (pqScript != null) {
+            pqScript.setType(1);
+            return this.updateById(pqScript);
+        }
+        return false;
+    }
+
+    @Override
+    public List<Map<String, Object>> listAllPqScript(String patternId) {
+        List<PqScript> pqScriptList = this.lambdaQuery().eq(PqScript::getPattern, patternId).eq(PqScript::getState, DataStateEnum.ENABLE.getCode()).list();
+        List<Map<String, Object>> result = pqScriptList.stream().map(pqScript -> {
+            Map<String, Object> map = new HashMap<>();
+            map.put("id", pqScript.getId());
+            map.put("name", pqScript.getName());
+            return map;
+        }).collect(Collectors.toList());
+        return result;
+    }
+
+    @Override
+    public PqScript getPqScriptByName(String name) {
+        return this.lambdaQuery().eq(PqScript::getName, name).eq(PqScript::getState, DataStateEnum.ENABLE.getCode()).one();
+    }
+}

detection/src/main/java/com/njcn/gather/script/util/ScriptDtlsDesc.java

@@ -0,0 +1,108 @@
+package com.njcn.gather.script.util;
+
+import cn.hutool.core.collection.CollUtil;
+import cn.hutool.core.util.ObjectUtil;
+import com.njcn.gather.script.pojo.enums.ResultUnitEnum;
+import com.njcn.gather.script.pojo.po.PqScriptDtls;
+
+import java.util.Comparator;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.stream.Collectors;
+
+/**
+ * @author wr
+ * @description
+ * @date 2025/1/13 22:05
+ */
+public class ScriptDtlsDesc {
+    public static StringBuffer getStringBuffer(List<PqScriptDtls> scriptDtlIndex, Boolean isValueType) {
+        if (ObjectUtil.isNull(isValueType)) {
+            isValueType = false;
+        }
+        StringBuffer buffer = new StringBuffer();
+        buffer.append("输入：");
+        appendValue(scriptDtlIndex, buffer, "Freq", "频率", ResultUnitEnum.FREQ_UNIT.getUnit(), null);
+        appendValue(scriptDtlIndex, buffer, "VOL", "U", isValueType ? ResultUnitEnum.V_RELATIVE_UNIT.getUnit() : ResultUnitEnum.V_ABSOLUTELY_UNIT.getUnit(), "相角=");
+        appendValue(scriptDtlIndex, buffer, "CUR", "I", isValueType ? ResultUnitEnum.I_RELATIVE_UNIT.getUnit() : ResultUnitEnum.I_ABSOLUTELY_UNIT.getUnit(), "相角=");
+        dtlsSetBuffer(scriptDtlIndex, buffer, "Harm_V", "h", ResultUnitEnum.HV_UNIT.getUnit(), true);
+        dtlsSetBuffer(scriptDtlIndex, buffer, "Harm_I", "h", ResultUnitEnum.HI_UNIT.getUnit(), true);
+        dtlsSetBuffer(scriptDtlIndex, buffer, "InHarm_V", "i", ResultUnitEnum.HSV_UNIT.getUnit(), false);
+        dtlsSetBuffer(scriptDtlIndex, buffer, "InHarm_I", "i", ResultUnitEnum.HSI_UNIT.getUnit(), false);
+        dtlsSetBufferDip(scriptDtlIndex, buffer, "Dip", "暂态", ResultUnitEnum.HSI_UNIT.getUnit());
+        dtlsSetBufferFlicker(scriptDtlIndex, buffer, "Flicker", "闪变");
+        return buffer;
+    }
+
+    public static void appendValue(List<PqScriptDtls> scriptDtlIndex, StringBuffer buffer, String valueType, String prefix, String unit, String suffix) {
+        List<PqScriptDtls> values = scriptDtlIndex.stream()
+                .filter(x -> valueType.equals(x.getValueType()))
+                .sorted(Comparator.comparing(PqScriptDtls::getPhase))
+                .collect(Collectors.toList());
+        if (CollUtil.isNotEmpty(values)) {
+            for (PqScriptDtls dtls : values) {
+                if ("Freq".equals(valueType)) {
+                    buffer.append(prefix + "=" + dtls.getValue() + unit);
+                } else {
+                    buffer.append(prefix + dtls.getPhase().toLowerCase() + "=" + dtls.getValue() + unit);
+                }
+                if (suffix != null) {
+                    buffer.append("," + suffix + dtls.getAngle() + "° ");
+                } else {
+                    buffer.append(" ");
+                }
+            }
+        }
+    }
+
+
+    public static void dtlsSetBuffer(List<PqScriptDtls> scriptDtlIndex, StringBuffer buffer, String valueType, String name, String unit, Boolean fly) {
+        LinkedHashMap<Double, List<PqScriptDtls>> harmNumMap = scriptDtlIndex.stream()
+                .filter(x -> valueType.equals(x.getValueType()))
+                .sorted(Comparator.comparing(PqScriptDtls::getHarmNum))
+                .collect(Collectors.groupingBy(PqScriptDtls::getHarmNum, LinkedHashMap::new, Collectors.toList()));
+        harmNumMap.forEach((harmNum, value) -> {
+            if (fly) {
+                buffer.append(name + String.format("%.0f", harmNum) + "(");
+            } else {
+                buffer.append(name + harmNum + "(");
+            }
+            appendValues(buffer, value, unit);
+        });
+    }
+
+    private static void dtlsSetBufferDip(List<PqScriptDtls> scriptDtlIndex, StringBuffer buffer, String valueType, String name, String unit) {
+        List<PqScriptDtls> list = scriptDtlIndex.stream().filter(x -> valueType.equals(x.getValueType()))
+                .sorted(Comparator.comparing(PqScriptDtls::getPhase))
+                .collect(Collectors.toList());
+        if (CollUtil.isNotEmpty(list)) {
+            buffer.append(name + " ");
+            for (PqScriptDtls dtls : list) {
+                buffer.append(dtls.getPhase() + "相(暂态深度=" + dtls.getTransValue() + ResultUnitEnum.VOLTAGE_DUR_UNIT.getUnit()
+                        + ",暂态持续时间=" + dtls.getRetainTime().intValue() + ResultUnitEnum.VOLTAGE_MAG_UNIT.getUnit() + ") ");
+            }
+        }
+    }
+
+    private static void dtlsSetBufferFlicker(List<PqScriptDtls> scriptDtlIndex, StringBuffer buffer, String valueType, String name) {
+        List<PqScriptDtls> list = scriptDtlIndex.stream().filter(x -> valueType.equals(x.getValueType()))
+                .sorted(Comparator.comparing(PqScriptDtls::getPhase))
+                .collect(Collectors.toList());
+        if (CollUtil.isNotEmpty(list)) {
+            buffer.append(name + " ");
+            for (PqScriptDtls dtls : list) {
+                buffer.append(dtls.getPhase() + "相(变动频度=" + dtls.getChagFre()
+                        + "次/min,变动量=" + dtls.getChagValue() + ResultUnitEnum.VOLTAGE_DUR_UNIT.getUnit() + ") ");
+            }
+        }
+    }
+
+    private static void appendValues(StringBuffer buffer, List<PqScriptDtls> values, String unit) {
+        if (CollUtil.isNotEmpty(values)) {
+            for (PqScriptDtls dtls : values) {
+                buffer.append(dtls.getPhase() + "相=" + dtls.getValue() + unit);
+            }
+            buffer.append(") ");
+        }
+    }
+}