Microservice/pqs
5
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 1 Wiki Activity

1.pms添加监测点越限对外接口

Browse Source 
2.添加技术监督台账相关对外接口
This commit is contained in:
雨木c
2024-03-01 08:47:27 +08:00
parent 8022b12b4c
commit 67a59e5214
22 changed files with 1068 additions and 627 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
pqs-device/common-device-biz/src/main/java/com/njcn/device/biz/commApi/CommTerminalGeneralClient.java
View File

@@ -8,6 +8,7 @@ import com.njcn.common.pojo.response.HttpResult;
import com.njcn.device.biz.commApi.fallback.CommTerminalGeneralClientFallbackFactory; import com.njcn.device.biz.commApi.fallback.CommTerminalGeneralClientFallbackFactory;
import com.njcn.device.biz.pojo.dto.*; import com.njcn.device.biz.pojo.dto.*;
import com.njcn.device.biz.pojo.param.DeptGetLineParam; import com.njcn.device.biz.pojo.param.DeptGetLineParam;
import com.njcn.device.biz.pojo.param.MonitorGetParam;
import com.njcn.device.biz.pojo.po.Overlimit; import com.njcn.device.biz.pojo.po.Overlimit;
import com.njcn.device.biz.pojo.po.PqsDeviceUnit; import com.njcn.device.biz.pojo.po.PqsDeviceUnit;
import io.swagger.annotations.ApiImplicitParam; import io.swagger.annotations.ApiImplicitParam;
@@ -181,11 +182,17 @@ public interface CommTerminalGeneralClient {
@GetMapping("/getCustomDetailByLineId") @GetMapping("/getCustomDetailByLineId")
HttpResult<Map<String,String>> getCustomDetailByLineId(@RequestParam("id") String id); HttpResult<Map<String,String>> getCustomDetailByLineId(@RequestParam("id") String id);
/**
* pms获取指定单位下面的母线以及母线下面的监测点信息
* @author cdf
* @date 2024/1/26
*/
@GetMapping("/getBusBarAndHisMonitor") @GetMapping("/getBusBarAndHisMonitor")
HttpResult<List<BusBarAndHisMonitorDTO>> getBusBarAndHisMonitor(); HttpResult<List<BusBarAndHisMonitorDTO>> getBusBarAndHisMonitor();
@PostMapping("/tagOrIdGetMonitorList")
HttpResult<List<CommMonitorInfoDTO>> tagOrIdGetMonitorList(@RequestBody MonitorGetParam monitorGetParam);
/** /**
* 用于返回pq 还是pms系统 * 用于返回pq 还是pms系统
* *

10
pqs-device/common-device-biz/src/main/java/com/njcn/device/biz/commApi/fallback/CommTerminalGeneralClientFallbackFactory.java
View File

@@ -7,6 +7,7 @@ import com.njcn.common.pojo.response.HttpResult;
import com.njcn.device.biz.commApi.CommTerminalGeneralClient; import com.njcn.device.biz.commApi.CommTerminalGeneralClient;
import com.njcn.device.biz.pojo.dto.*; import com.njcn.device.biz.pojo.dto.*;
import com.njcn.device.biz.pojo.param.DeptGetLineParam; import com.njcn.device.biz.pojo.param.DeptGetLineParam;
import com.njcn.device.biz.pojo.param.MonitorGetParam;
import com.njcn.device.biz.pojo.po.Overlimit; import com.njcn.device.biz.pojo.po.Overlimit;
import com.njcn.device.biz.pojo.po.PqsDeviceUnit; import com.njcn.device.biz.pojo.po.PqsDeviceUnit;
import com.njcn.device.biz.utils.DeviceEnumUtil; import com.njcn.device.biz.utils.DeviceEnumUtil;
@@ -151,7 +152,14 @@ public class CommTerminalGeneralClientFallbackFactory implements FallbackFactory
@Override @Override
public HttpResult<List<BusBarAndHisMonitorDTO>> getBusBarAndHisMonitor() { public HttpResult<List<BusBarAndHisMonitorDTO>> getBusBarAndHisMonitor() {
return null; log.error("{}异常，降级处理，异常为：{}", "pms获取指定单位下面的母线以及母线下面的监测点信息", throwable.toString());
throw new BusinessException(finalExceptionEnum);
}
@Override
public HttpResult<List<CommMonitorInfoDTO>> tagOrIdGetMonitorList(MonitorGetParam monitorGetParam) {
log.error("{}异常，降级处理，异常为：{}", "根据对象标签，监测点，获取主网监测点", throwable.toString());
throw new BusinessException(finalExceptionEnum);
} }
@Override @Override

26
pqs-device/common-device-biz/src/main/java/com/njcn/device/biz/pojo/dto/CommMonitorInfoDTO.java Normal file
View File

@@ -0,0 +1,26 @@
package com.njcn.device.biz.pojo.dto;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
/**
* pqs
*
* @author cdf
* @date 2024/2/28
*/
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class CommMonitorInfoDTO {
private String id;
private String name;
private String powerStationName;
}

25
pqs-device/common-device-biz/src/main/java/com/njcn/device/biz/pojo/param/MonitorGetParam.java Normal file
View File

@@ -0,0 +1,25 @@
package com.njcn.device.biz.pojo.param;
import lombok.Builder;
import lombok.Data;
import javax.validation.constraints.NotEmpty;
import java.util.List;
/**
* pqs
*
* @author cdf
* @date 2024/2/28
*/
@Data
public class MonitorGetParam {
private List<String> tagList;
private List<String> monitorIds;
private List<String> deptIds;
}

16
pqs-device/pms-device/pms-device-boot/src/main/java/com/njcn/device/pms/controller/ledgerManger/CommTerminalController.java
View File

@@ -10,6 +10,7 @@ import com.njcn.common.utils.HttpResultUtil;
import com.njcn.device.biz.pojo.dto.StatisticsMonitor; import com.njcn.device.biz.pojo.dto.StatisticsMonitor;
import com.njcn.device.biz.pojo.dto.*; import com.njcn.device.biz.pojo.dto.*;
import com.njcn.device.biz.pojo.param.DeptGetLineParam; import com.njcn.device.biz.pojo.param.DeptGetLineParam;
import com.njcn.device.biz.pojo.param.MonitorGetParam;
import com.njcn.device.biz.pojo.po.Overlimit; import com.njcn.device.biz.pojo.po.Overlimit;
import com.njcn.device.biz.pojo.po.PqsDeviceUnit; import com.njcn.device.biz.pojo.po.PqsDeviceUnit;
import com.njcn.device.pms.pojo.po.Monitor; import com.njcn.device.pms.pojo.po.Monitor;
@@ -391,6 +392,21 @@ public class CommTerminalController extends BaseController {
} }
/**
* 根据对象标签，监测点，获取主网监测点
* @author cdf
* @date 2024/2/28
*/
@OperateInfo(info = LogEnum.BUSINESS_COMMON)
@PostMapping("/tagOrIdGetMonitorList")
@ApiOperation("根据对象标签，监测点，获取主网监测点")
public HttpResult<List<CommMonitorInfoDTO>> tagOrIdGetMonitorList(@RequestBody MonitorGetParam monitorGetParam) {
String methodDescribe = getMethodDescribe("tagOrIdGetMonitorList");
List<CommMonitorInfoDTO> busBarAndHisMonitorDTOList = commTerminalService.tagOrIdGetMonitorList(monitorGetParam.getTagList(),monitorGetParam.getMonitorIds(),monitorGetParam.getDeptIds());
return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, busBarAndHisMonitorDTOList, methodDescribe);
}
/** /**
* 用于返回pq 还是pms系统 * 用于返回pq 还是pms系统
* @author cdf * @author cdf

4
pqs-device/pms-device/pms-device-boot/src/main/java/com/njcn/device/pms/service/ledgerManger/CommTerminalService.java
View File

@@ -5,6 +5,7 @@ import com.njcn.common.pojo.response.HttpResult;
import com.njcn.device.biz.pojo.dto.StatisticsMonitor; import com.njcn.device.biz.pojo.dto.StatisticsMonitor;
import com.njcn.device.biz.pojo.dto.*; import com.njcn.device.biz.pojo.dto.*;
import com.njcn.device.biz.pojo.param.DeptGetLineParam; import com.njcn.device.biz.pojo.param.DeptGetLineParam;
import com.njcn.device.pms.pojo.po.Monitor;
import org.springframework.web.bind.annotation.RequestParam; import org.springframework.web.bind.annotation.RequestParam;
import java.util.List; import java.util.List;
@@ -109,6 +110,9 @@ public interface CommTerminalService {
List<BusBarAndHisMonitorDTO> getBusBarAndHisMonitor(); List<BusBarAndHisMonitorDTO> getBusBarAndHisMonitor();
List<CommMonitorInfoDTO> tagOrIdGetMonitorList(List<String> tagList,List<String> monitorIds,List<String> deptIds);
/** /**
* 根据部门获取各变电站信息 * 根据部门获取各变电站信息
* @param deptGetLineParam * @param deptGetLineParam

19
pqs-device/pms-device/pms-device-boot/src/main/java/com/njcn/device/pms/service/ledgerManger/impl/CommTerminalServiceImpl.java
View File

@@ -29,9 +29,11 @@ import com.njcn.device.pq.pojo.po.LineBak;
import com.njcn.system.api.DicDataFeignClient; import com.njcn.system.api.DicDataFeignClient;
import com.njcn.system.enums.DicDataEnum; import com.njcn.system.enums.DicDataEnum;
import com.njcn.system.enums.DicDataTypeEnum; import com.njcn.system.enums.DicDataTypeEnum;
import com.njcn.system.pojo.po.Dic;
import com.njcn.system.pojo.po.DictData; import com.njcn.system.pojo.po.DictData;
import com.njcn.user.api.DeptFeignClient; import com.njcn.user.api.DeptFeignClient;
import com.njcn.user.pojo.dto.DeptDTO; import com.njcn.user.pojo.dto.DeptDTO;
import com.njcn.user.pojo.po.Dept;
import lombok.RequiredArgsConstructor; import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j; import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service; import org.springframework.stereotype.Service;
@@ -790,6 +792,23 @@ public class CommTerminalServiceImpl implements CommTerminalService {
return result; return result;
} }
@Override
public List<CommMonitorInfoDTO> tagOrIdGetMonitorList(List<String> tagList, List<String> monitorIds,List<String> deptIds) {
List<CommMonitorInfoDTO> result = new ArrayList<>();
DictData dictData = dicDataFeignClient.getDicDataByCodeAndType(DicDataEnum.RUN.getCode(),DicDataTypeEnum.LINE_STATE.getCode()).getData();
List<Dept> deptList = deptFeignClient.getDeptInfoListByIds(deptIds).getData();
List<Monitor> monitorList = monitorMapper.selectList(new LambdaQueryWrapper<Monitor>()
.eq(Monitor::getStatus,DataStateEnum.ENABLE.getCode()).in(Monitor::getOrgId,deptList.stream().map(Dept::getCode).collect(Collectors.toList()))
.eq(Monitor::getMonitorState,dictData.getId())
.in(Monitor::getMonitorTag,tagList)
.or(item->item.in(Monitor::getId,monitorIds)));
monitorList.forEach(item->result.add(CommMonitorInfoDTO.builder().id(item.getId()).name(item.getName()).powerStationName(item.getPowerrName()).build()));
return result;
}
@Override @Override
public List<DeptGetSubStationDTO.Info> deptSubStationInfo(DeptGetLineParam deptGetLineParam) { public List<DeptGetSubStationDTO.Info> deptSubStationInfo(DeptGetLineParam deptGetLineParam) {
List<DeptGetSubStationDTO.Info> result = new ArrayList<>(); List<DeptGetSubStationDTO.Info> result = new ArrayList<>();

9
pqs-harmonic/harmonic-api/src/main/java/com/njcn/harmonic/annotaion/HarCurrent.java Normal file
View File

@@ -0,0 +1,9 @@
package com.njcn.harmonic.annotaion;
import java.lang.annotation.*;
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface HarCurrent {
}

9
pqs-harmonic/harmonic-api/src/main/java/com/njcn/harmonic/annotaion/HarVoltage.java Normal file
View File

@@ -0,0 +1,9 @@
package com.njcn.harmonic.annotaion;
import java.lang.annotation.*;
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface HarVoltage {
}

11
pqs-harmonic/harmonic-api/src/main/java/com/njcn/harmonic/annotaion/InterharVoltage.java Normal file
View File

@@ -0,0 +1,11 @@
package com.njcn.harmonic.annotaion;
import java.lang.annotation.*;
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface InterharVoltage {
}

34
pqs-harmonic/harmonic-api/src/main/java/com/njcn/harmonic/api/RStatLimitRateDClient.java Normal file
View File

@@ -0,0 +1,34 @@
package com.njcn.harmonic.api;
import com.njcn.common.pojo.constant.ServerInfo;
import com.njcn.common.pojo.response.HttpResult;
import com.njcn.harmonic.api.fallback.HarmDataFeignClientFallbackFactory;
import com.njcn.harmonic.api.fallback.RStatLimitRateDFeignClientFallbackFactory;
import com.njcn.harmonic.pojo.param.HistoryHarmParam;
import com.njcn.harmonic.pojo.param.RStatLimitQueryParam;
import com.njcn.harmonic.pojo.param.StatSubstationBizBaseParam;
import com.njcn.harmonic.pojo.po.day.RStatLimitRateDPO;
import com.njcn.harmonic.pojo.po.day.RStatLimitTargetDPO;
import com.njcn.influx.pojo.dto.HarmHistoryDataDTO;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import java.util.List;
@FeignClient(
value = ServerInfo.HARMONIC,
path = "/limitRateD",
fallbackFactory = RStatLimitRateDFeignClientFallbackFactory.class,
contextId = "limitRateD")
public interface RStatLimitRateDClient {
@PostMapping("/monitorIdsGetLimitRateInfo")
HttpResult<List<RStatLimitRateDPO>> monitorIdsGetLimitInfo(@RequestBody RStatLimitQueryParam rStatLimitQueryParam);
@PostMapping("/monitorIdsGetLimitTargetInfo")
HttpResult<List<RStatLimitTargetDPO>> monitorIdsGetLimitTargetInfo(@RequestBody RStatLimitQueryParam rStatLimitQueryParam);
}

54
pqs-harmonic/harmonic-api/src/main/java/com/njcn/harmonic/api/fallback/RStatLimitRateDFeignClientFallbackFactory.java Normal file
View File

@@ -0,0 +1,54 @@
package com.njcn.harmonic.api.fallback;
import com.njcn.common.pojo.enums.response.CommonResponseEnum;
import com.njcn.common.pojo.exception.BusinessException;
import com.njcn.common.pojo.response.HttpResult;
import com.njcn.device.biz.utils.DeviceEnumUtil;
import com.njcn.harmonic.api.HarmDataFeignClient;
import com.njcn.harmonic.api.RStatLimitRateDClient;
import com.njcn.harmonic.pojo.param.HistoryHarmParam;
import com.njcn.harmonic.pojo.param.RStatLimitQueryParam;
import com.njcn.harmonic.pojo.param.StatSubstationBizBaseParam;
import com.njcn.harmonic.pojo.po.day.RStatLimitRateDPO;
import com.njcn.harmonic.pojo.po.day.RStatLimitTargetDPO;
import com.njcn.influx.pojo.dto.HarmHistoryDataDTO;
import feign.hystrix.FallbackFactory;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
import java.util.List;
/**
* @author hongawen
* @version 1.0.0
* @date 2023年07月21日 14:31
*/
@Slf4j
@Component
public class RStatLimitRateDFeignClientFallbackFactory implements FallbackFactory<RStatLimitRateDClient> {
@Override
public RStatLimitRateDClient create(Throwable throwable) {
//判断抛出异常是否为解码器抛出的业务异常
Enum<?> exceptionEnum = CommonResponseEnum.SERVICE_FALLBACK;
if (throwable.getCause() instanceof BusinessException) {
BusinessException businessException = (BusinessException) throwable.getCause();
exceptionEnum = DeviceEnumUtil.getExceptionEnum(businessException.getResult());
}
Enum<?> finalExceptionEnum = exceptionEnum;
return new RStatLimitRateDClient() {
@Override
public HttpResult<List<RStatLimitRateDPO>> monitorIdsGetLimitInfo(RStatLimitQueryParam rStatLimitQueryParam) {
log.error("{}异常，降级处理，异常为：{}", "获取指定日期超标监测点详细信息", throwable.toString());
return new HttpResult<>(CommonResponseEnum.FAIL.getCode(),CommonResponseEnum.FAIL.getMessage());
}
@Override
public HttpResult<List<RStatLimitTargetDPO>> monitorIdsGetLimitTargetInfo(RStatLimitQueryParam rStatLimitQueryParam) {
log.error("{}异常，降级处理，异常为：{}", "获取指定日期超标监测点详细信息", throwable.toString());
return new HttpResult<>(CommonResponseEnum.FAIL.getCode(),CommonResponseEnum.FAIL.getMessage());
}
};
}
}

25
pqs-harmonic/harmonic-api/src/main/java/com/njcn/harmonic/pojo/param/RStatLimitQueryParam.java Normal file
View File

@@ -0,0 +1,25 @@
package com.njcn.harmonic.pojo.param;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.util.List;
/**
* pqs
*
* @author cdf
* @date 2024/2/28
*/
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class RStatLimitQueryParam {
private List<String> ids;
private String date;
}

3
pqs-harmonic/harmonic-api/src/main/java/com/njcn/harmonic/pojo/po/LimitRate.java
View File

@@ -6,7 +6,7 @@ import org.influxdb.annotation.Measurement;
/** /**
* 类的介绍： * 类的介绍：
* * 已经废弃需要删除。。。。。。。。。。。。。。
* @author xuyang * @author xuyang
* @version 1.0.0 * @version 1.0.0
* @createTime 2022/5/7 10:41 * @createTime 2022/5/7 10:41
@@ -14,6 +14,7 @@ import org.influxdb.annotation.Measurement;
@Data @Data
@Measurement(name = "limit_rate") @Measurement(name = "limit_rate")
@EqualsAndHashCode(callSuper = true) @EqualsAndHashCode(callSuper = true)
@Deprecated
public class LimitRate extends LimitTarget{ public class LimitRate extends LimitTarget{

67
pqs-harmonic/harmonic-api/src/main/java/com/njcn/harmonic/pojo/po/day/RStatLimitRateDPO.java
View File

@@ -4,6 +4,9 @@ import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableName; import com.baomidou.mybatisplus.annotation.TableName;
import com.fasterxml.jackson.annotation.JsonFormat; import com.fasterxml.jackson.annotation.JsonFormat;
import com.github.jeffreyning.mybatisplus.anno.MppMultiId; import com.github.jeffreyning.mybatisplus.anno.MppMultiId;
import com.njcn.harmonic.annotaion.HarCurrent;
import com.njcn.harmonic.annotaion.HarVoltage;
import com.njcn.harmonic.annotaion.InterharVoltage;
import lombok.AllArgsConstructor; import lombok.AllArgsConstructor;
import lombok.Data; import lombok.Data;
import lombok.NoArgsConstructor; import lombok.NoArgsConstructor;
@@ -88,288 +91,336 @@ public class RStatLimitRateDPO {
/** /**
* 2次电压谐波含有率越限次数 * 2次电压谐波含有率越限次数
*/ */
@HarVoltage
@TableField(value = "uharm_2_overtime") @TableField(value = "uharm_2_overtime")
private Integer uharm2Overtime; private Integer uharm2Overtime;
/** /**
* 3次电压谐波含有率越限次数 * 3次电压谐波含有率越限次数
*/ */
@HarVoltage
@TableField(value = "uharm_3_overtime") @TableField(value = "uharm_3_overtime")
private Integer uharm3Overtime; private Integer uharm3Overtime;
/** /**
* 4次电压谐波含有率越限次数 * 4次电压谐波含有率越限次数
*/ */
@HarVoltage
@TableField(value = "uharm_4_overtime") @TableField(value = "uharm_4_overtime")
private Integer uharm4Overtime; private Integer uharm4Overtime;
/** /**
* 5次电压谐波含有率越限次数 * 5次电压谐波含有率越限次数
*/ */
@HarVoltage
@TableField(value = "uharm_5_overtime") @TableField(value = "uharm_5_overtime")
private Integer uharm5Overtime; private Integer uharm5Overtime;
/** /**
* 6次电压谐波含有率越限次数 * 6次电压谐波含有率越限次数
*/ */
@HarVoltage
@TableField(value = "uharm_6_overtime") @TableField(value = "uharm_6_overtime")
private Integer uharm6Overtime; private Integer uharm6Overtime;
/** /**
* 7次电压谐波含有率越限次数 * 7次电压谐波含有率越限次数
*/ */
@HarVoltage
@TableField(value = "uharm_7_overtime") @TableField(value = "uharm_7_overtime")
private Integer uharm7Overtime; private Integer uharm7Overtime;
/** /**
* 8次电压谐波含有率越限次数 * 8次电压谐波含有率越限次数
*/ */
@HarVoltage
@TableField(value = "uharm_8_overtime") @TableField(value = "uharm_8_overtime")
private Integer uharm8Overtime; private Integer uharm8Overtime;
/** /**
* 9次电压谐波含有率越限次数 * 9次电压谐波含有率越限次数
*/ */
@HarVoltage
@TableField(value = "uharm_9_overtime") @TableField(value = "uharm_9_overtime")
private Integer uharm9Overtime; private Integer uharm9Overtime;
/** /**
* 10次电压谐波含有率越限次数 * 10次电压谐波含有率越限次数
*/ */
@HarVoltage
@TableField(value = "uharm_10_overtime") @TableField(value = "uharm_10_overtime")
private Integer uharm10Overtime; private Integer uharm10Overtime;
/** /**
* 11次电压谐波含有率越限次数 * 11次电压谐波含有率越限次数
*/ */
@HarVoltage
@TableField(value = "uharm_11_overtime") @TableField(value = "uharm_11_overtime")
private Integer uharm11Overtime; private Integer uharm11Overtime;
/** /**
* 12次电压谐波含有率越限次数 * 12次电压谐波含有率越限次数
*/ */
@HarVoltage
@TableField(value = "uharm_12_overtime") @TableField(value = "uharm_12_overtime")
private Integer uharm12Overtime; private Integer uharm12Overtime;
/** /**
* 13次电压谐波含有率越限次数 * 13次电压谐波含有率越限次数
*/ */
@HarVoltage
@TableField(value = "uharm_13_overtime") @TableField(value = "uharm_13_overtime")
private Integer uharm13Overtime; private Integer uharm13Overtime;
/** /**
* 14次电压谐波含有率越限次数 * 14次电压谐波含有率越限次数
*/ */
@HarVoltage
@TableField(value = "uharm_14_overtime") @TableField(value = "uharm_14_overtime")
private Integer uharm14Overtime; private Integer uharm14Overtime;
/** /**
* 15次电压谐波含有率越限次数 * 15次电压谐波含有率越限次数
*/ */
@HarVoltage
@TableField(value = "uharm_15_overtime") @TableField(value = "uharm_15_overtime")
private Integer uharm15Overtime; private Integer uharm15Overtime;
/** /**
* 16次电压谐波含有率越限次数 * 16次电压谐波含有率越限次数
*/ */
@HarVoltage
@TableField(value = "uharm_16_overtime") @TableField(value = "uharm_16_overtime")
private Integer uharm16Overtime; private Integer uharm16Overtime;
/** /**
* 17次电压谐波含有率越限次数 * 17次电压谐波含有率越限次数
*/ */
@HarVoltage
@TableField(value = "uharm_17_overtime") @TableField(value = "uharm_17_overtime")
private Integer uharm17Overtime; private Integer uharm17Overtime;
/** /**
* 18次电压谐波含有率越限次数 * 18次电压谐波含有率越限次数
*/ */
@HarVoltage
@TableField(value = "uharm_18_overtime") @TableField(value = "uharm_18_overtime")
private Integer uharm18Overtime; private Integer uharm18Overtime;
/** /**
* 19次电压谐波含有率越限次数 * 19次电压谐波含有率越限次数
*/ */
@HarVoltage
@TableField(value = "uharm_19_overtime") @TableField(value = "uharm_19_overtime")
private Integer uharm19Overtime; private Integer uharm19Overtime;
/** /**
* 20次电压谐波含有率越限次数 * 20次电压谐波含有率越限次数
*/ */
@HarVoltage
@TableField(value = "uharm_20_overtime") @TableField(value = "uharm_20_overtime")
private Integer uharm20Overtime; private Integer uharm20Overtime;
/** /**
* 21次电压谐波含有率越限次数 * 21次电压谐波含有率越限次数
*/ */
@HarVoltage
@TableField(value = "uharm_21_overtime") @TableField(value = "uharm_21_overtime")
private Integer uharm21Overtime; private Integer uharm21Overtime;
/** /**
* 22次电压谐波含有率越限次数 * 22次电压谐波含有率越限次数
*/ */
@HarVoltage
@TableField(value = "uharm_22_overtime") @TableField(value = "uharm_22_overtime")
private Integer uharm22Overtime; private Integer uharm22Overtime;
/** /**
* 23次电压谐波含有率越限次数 * 23次电压谐波含有率越限次数
*/ */
@HarVoltage
@TableField(value = "uharm_23_overtime") @TableField(value = "uharm_23_overtime")
private Integer uharm23Overtime; private Integer uharm23Overtime;
/** /**
* 24次电压谐波含有率越限次数 * 24次电压谐波含有率越限次数
*/ */
@HarVoltage
@TableField(value = "uharm_24_overtime") @TableField(value = "uharm_24_overtime")
private Integer uharm24Overtime; private Integer uharm24Overtime;
/** /**
* 25次电压谐波含有率越限次数 * 25次电压谐波含有率越限次数
*/ */
@HarVoltage
@TableField(value = "uharm_25_overtime") @TableField(value = "uharm_25_overtime")
private Integer uharm25Overtime; private Integer uharm25Overtime;
/** /**
* 2次电流谐波幅值越限次数 * 2次电流谐波幅值越限次数
*/ */
@HarCurrent
@TableField(value = "iharm_2_overtime") @TableField(value = "iharm_2_overtime")
private Integer iharm2Overtime; private Integer iharm2Overtime;
/** /**
* 3次电流谐波幅值越限次数 * 3次电流谐波幅值越限次数
*/ */
@HarCurrent
@TableField(value = "iharm_3_overtime") @TableField(value = "iharm_3_overtime")
private Integer iharm3Overtime; private Integer iharm3Overtime;
/** /**
* 4次电流谐波幅值越限次数 * 4次电流谐波幅值越限次数
*/ */
@HarCurrent
@TableField(value = "iharm_4_overtime") @TableField(value = "iharm_4_overtime")
private Integer iharm4Overtime; private Integer iharm4Overtime;
/** /**
* 5次电流谐波幅值越限次数 * 5次电流谐波幅值越限次数
*/ */
@HarCurrent
@TableField(value = "iharm_5_overtime") @TableField(value = "iharm_5_overtime")
private Integer iharm5Overtime; private Integer iharm5Overtime;
/** /**
* 6次电流谐波幅值越限次数 * 6次电流谐波幅值越限次数
*/ */
@HarCurrent
@TableField(value = "iharm_6_overtime") @TableField(value = "iharm_6_overtime")
private Integer iharm6Overtime; private Integer iharm6Overtime;
/** /**
* 7次电流谐波幅值越限次数 * 7次电流谐波幅值越限次数
*/ */
@HarCurrent
@TableField(value = "iharm_7_overtime") @TableField(value = "iharm_7_overtime")
private Integer iharm7Overtime; private Integer iharm7Overtime;
/** /**
* 8次电流谐波幅值越限次数 * 8次电流谐波幅值越限次数
*/ */
@HarCurrent
@TableField(value = "iharm_8_overtime") @TableField(value = "iharm_8_overtime")
private Integer iharm8Overtime; private Integer iharm8Overtime;
/** /**
* 9次电流谐波幅值越限次数 * 9次电流谐波幅值越限次数
*/ */
@HarCurrent
@TableField(value = "iharm_9_overtime") @TableField(value = "iharm_9_overtime")
private Integer iharm9Overtime; private Integer iharm9Overtime;
/** /**
* 10次电流谐波幅值越限次数 * 10次电流谐波幅值越限次数
*/ */
@HarCurrent
@TableField(value = "iharm_10_overtime") @TableField(value = "iharm_10_overtime")
private Integer iharm10Overtime; private Integer iharm10Overtime;
/** /**
* 11次电流谐波幅值越限次数 * 11次电流谐波幅值越限次数
*/ */
@HarCurrent
@TableField(value = "iharm_11_overtime") @TableField(value = "iharm_11_overtime")
private Integer iharm11Overtime; private Integer iharm11Overtime;
/** /**
* 12次电流谐波幅值越限次数 * 12次电流谐波幅值越限次数
*/ */
@HarCurrent
@TableField(value = "iharm_12_overtime") @TableField(value = "iharm_12_overtime")
private Integer iharm12Overtime; private Integer iharm12Overtime;
/** /**
* 13次电流谐波幅值越限次数 * 13次电流谐波幅值越限次数
*/ */
@HarCurrent
@TableField(value = "iharm_13_overtime") @TableField(value = "iharm_13_overtime")
private Integer iharm13Overtime; private Integer iharm13Overtime;
/** /**
* 14次电流谐波幅值越限次数 * 14次电流谐波幅值越限次数
*/ */
@HarCurrent
@TableField(value = "iharm_14_overtime") @TableField(value = "iharm_14_overtime")
private Integer iharm14Overtime; private Integer iharm14Overtime;
/** /**
* 15次电流谐波幅值越限次数 * 15次电流谐波幅值越限次数
*/ */
@HarCurrent
@TableField(value = "iharm_15_overtime") @TableField(value = "iharm_15_overtime")
private Integer iharm15Overtime; private Integer iharm15Overtime;
/** /**
* 16次电流谐波幅值越限次数 * 16次电流谐波幅值越限次数
*/ */
@HarCurrent
@TableField(value = "iharm_16_overtime") @TableField(value = "iharm_16_overtime")
private Integer iharm16Overtime; private Integer iharm16Overtime;
/** /**
* 17次电流谐波幅值越限次数 * 17次电流谐波幅值越限次数
*/ */
@HarCurrent
@TableField(value = "iharm_17_overtime") @TableField(value = "iharm_17_overtime")
private Integer iharm17Overtime; private Integer iharm17Overtime;
/** /**
* 18次电流谐波幅值越限次数 * 18次电流谐波幅值越限次数
*/ */
@HarCurrent
@TableField(value = "iharm_18_overtime") @TableField(value = "iharm_18_overtime")
private Integer iharm18Overtime; private Integer iharm18Overtime;
/** /**
* 19次电流谐波幅值越限次数 * 19次电流谐波幅值越限次数
*/ */
@HarCurrent
@TableField(value = "iharm_19_overtime") @TableField(value = "iharm_19_overtime")
private Integer iharm19Overtime; private Integer iharm19Overtime;
/** /**
* 20次电流谐波幅值越限次数 * 20次电流谐波幅值越限次数
*/ */
@HarCurrent
@TableField(value = "iharm_20_overtime") @TableField(value = "iharm_20_overtime")
private Integer iharm20Overtime; private Integer iharm20Overtime;
/** /**
* 21次电流谐波幅值越限次数 * 21次电流谐波幅值越限次数
*/ */
@HarCurrent
@TableField(value = "iharm_21_overtime") @TableField(value = "iharm_21_overtime")
private Integer iharm21Overtime; private Integer iharm21Overtime;
/** /**
* 22次电流谐波幅值越限次数 * 22次电流谐波幅值越限次数
*/ */
@HarCurrent
@TableField(value = "iharm_22_overtime") @TableField(value = "iharm_22_overtime")
private Integer iharm22Overtime; private Integer iharm22Overtime;
/** /**
* 23次电流谐波幅值越限次数 * 23次电流谐波幅值越限次数
*/ */
@HarCurrent
@TableField(value = "iharm_23_overtime") @TableField(value = "iharm_23_overtime")
private Integer iharm23Overtime; private Integer iharm23Overtime;
/** /**
* 24次电流谐波幅值越限次数 * 24次电流谐波幅值越限次数
*/ */
@HarCurrent
@TableField(value = "iharm_24_overtime") @TableField(value = "iharm_24_overtime")
private Integer iharm24Overtime; private Integer iharm24Overtime;
/** /**
* 25次电流谐波幅值越限次数 * 25次电流谐波幅值越限次数
*/ */
@HarCurrent
@TableField(value = "iharm_25_overtime") @TableField(value = "iharm_25_overtime")
private Integer iharm25Overtime; private Integer iharm25Overtime;
@@ -377,95 +428,111 @@ public class RStatLimitRateDPO {
* 0.5次间谐波电压限值次数 * 0.5次间谐波电压限值次数
*/ */
@TableField(value = "inuharm_1_overtime") @TableField(value = "inuharm_1_overtime")
@InterharVoltage
private Integer inuharm1Overtime; private Integer inuharm1Overtime;
/** /**
* 1.5次间谐波电压限值次数 * 1.5次间谐波电压限值次数
*/ */
@InterharVoltage
@TableField(value = "inuharm_2_overtime") @TableField(value = "inuharm_2_overtime")
private Integer inuharm2Overtime; private Integer inuharm2Overtime;
/** /**
* 2.5次间谐波电压限值次数 * 2.5次间谐波电压限值次数
*/ */
@InterharVoltage
@TableField(value = "inuharm_3_overtime") @TableField(value = "inuharm_3_overtime")
private Integer inuharm3Overtime; private Integer inuharm3Overtime;
/** /**
* 3.5次间谐波电压限值次数 * 3.5次间谐波电压限值次数
*/ */
@InterharVoltage
@TableField(value = "inuharm_4_overtime") @TableField(value = "inuharm_4_overtime")
private Integer inuharm4Overtime; private Integer inuharm4Overtime;
/** /**
* 4.5次间谐波电压限值次数 * 4.5次间谐波电压限值次数
*/ */
@InterharVoltage
@TableField(value = "inuharm_5_overtime") @TableField(value = "inuharm_5_overtime")
private Integer inuharm5Overtime; private Integer inuharm5Overtime;
/** /**
* 5.5次间谐波电压限值次数 * 5.5次间谐波电压限值次数
*/ */
@InterharVoltage
@TableField(value = "inuharm_6_overtime") @TableField(value = "inuharm_6_overtime")
private Integer inuharm6Overtime; private Integer inuharm6Overtime;
/** /**
* 6.5次间谐波电压限值次数 * 6.5次间谐波电压限值次数
*/ */
@InterharVoltage
@TableField(value = "inuharm_7_overtime") @TableField(value = "inuharm_7_overtime")
private Integer inuharm7Overtime; private Integer inuharm7Overtime;
/** /**
* 7.5次间谐波电压限值次数 * 7.5次间谐波电压限值次数
*/ */
@InterharVoltage
@TableField(value = "inuharm_8_overtime") @TableField(value = "inuharm_8_overtime")
private Integer inuharm8Overtime; private Integer inuharm8Overtime;
/** /**
* 8.5次间谐波电压限值次数 * 8.5次间谐波电压限值次数
*/ */
@InterharVoltage
@TableField(value = "inuharm_9_overtime") @TableField(value = "inuharm_9_overtime")
private Integer inuharm9Overtime; private Integer inuharm9Overtime;
/** /**
* 9.5次间谐波电压限值次数 * 9.5次间谐波电压限值次数
*/ */
@InterharVoltage
@TableField(value = "inuharm_10_overtime") @TableField(value = "inuharm_10_overtime")
private Integer inuharm10Overtime; private Integer inuharm10Overtime;
/** /**
* 10.5次间谐波电压限值次数 * 10.5次间谐波电压限值次数
*/ */
@InterharVoltage
@TableField(value = "inuharm_11_overtime") @TableField(value = "inuharm_11_overtime")
private Integer inuharm11Overtime; private Integer inuharm11Overtime;
/** /**
* 11.5次间谐波电压限值次数 * 11.5次间谐波电压限值次数
*/ */
@InterharVoltage
@TableField(value = "inuharm_12_overtime") @TableField(value = "inuharm_12_overtime")
private Integer inuharm12Overtime; private Integer inuharm12Overtime;
/** /**
* 12.5次间谐波电压限值次数 * 12.5次间谐波电压限值次数
*/ */
@InterharVoltage
@TableField(value = "inuharm_13_overtime") @TableField(value = "inuharm_13_overtime")
private Integer inuharm13Overtime; private Integer inuharm13Overtime;
/** /**
* 13.5次间谐波电压限值次数 * 13.5次间谐波电压限值次数
*/ */
@InterharVoltage
@TableField(value = "inuharm_14_overtime") @TableField(value = "inuharm_14_overtime")
private Integer inuharm14Overtime; private Integer inuharm14Overtime;
/** /**
* 14.5次间谐波电压限值次数 * 14.5次间谐波电压限值次数
*/ */
@InterharVoltage
@TableField(value = "inuharm_15_overtime") @TableField(value = "inuharm_15_overtime")
private Integer inuharm15Overtime; private Integer inuharm15Overtime;
/** /**
* 15.5次间谐波电压限值次数 * 15.5次间谐波电压限值次数
*/ */
@InterharVoltage
@TableField(value = "inuharm_16_overtime") @TableField(value = "inuharm_16_overtime")
private Integer inuharm16Overtime; private Integer inuharm16Overtime;
} }

5
pqs-harmonic/harmonic-api/src/main/java/com/njcn/harmonic/pojo/vo/SourceSteadyIndicator.java
View File

@@ -39,8 +39,5 @@ public class SourceSteadyIndicator {
* 类型（0：预警；1：告警） * 类型（0：预警；1：告警）
*/ */
private Integer type; private Integer type;
/**
* 监测点id
*/
private String monitorId;
} }

57
pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/controller/majornetwork/RStatLimitController.java Normal file
View File

@@ -0,0 +1,57 @@
package com.njcn.harmonic.controller.majornetwork;
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.HttpResultUtil;
import com.njcn.harmonic.pojo.param.RStatLimitQueryParam;
import com.njcn.harmonic.pojo.po.day.RStatLimitRateDPO;
import com.njcn.harmonic.pojo.po.day.RStatLimitTargetDPO;
import com.njcn.harmonic.service.majornetwork.RStatLimitService;
import com.njcn.web.controller.BaseController;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.RequiredArgsConstructor;
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;
import java.util.List;
/**
* pqs
*
* @author cdf
* @date 2024/2/28
*/
@RestController
@RequiredArgsConstructor
@Api(tags = "主网指标检测点超标明细")
@RequestMapping("/limitRateD")
public class RStatLimitController extends BaseController {
private final RStatLimitService rStatLimitService;
@PostMapping("/monitorIdsGetLimitRateInfo")
@OperateInfo(info = LogEnum.BUSINESS_COMMON)
@ApiOperation("获取指定日期超标监测点详细信息")
public HttpResult<List<RStatLimitRateDPO>> monitorIdsGetLimitRateInfo(@RequestBody RStatLimitQueryParam rStatLimitQueryParam) {
String methodDescribe = getMethodDescribe("monitorIdsGetLimitRateInfo");
List<RStatLimitRateDPO> result = rStatLimitService.monitorIdsGetLimitRateInfo(rStatLimitQueryParam.getDate(),rStatLimitQueryParam.getIds());
return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, result, methodDescribe);
}
@PostMapping("/monitorIdsGetLimitTargetInfo")
@OperateInfo(info = LogEnum.BUSINESS_COMMON)
@ApiOperation("获取指定日期超标监测点详细信息")
public HttpResult<List<RStatLimitTargetDPO>> monitorIdsGetLimitTargetInfo(@RequestBody RStatLimitQueryParam rStatLimitQueryParam) {
String methodDescribe = getMethodDescribe("monitorIdsGetLimitTargetInfo");
List<RStatLimitTargetDPO> result = rStatLimitService.monitorIdsGetLimitTargetInfo(rStatLimitQueryParam.getDate(),rStatLimitQueryParam.getIds());
return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, result, methodDescribe);
}
}

27
pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/majornetwork/RStatLimitService.java Normal file
View File

@@ -0,0 +1,27 @@
package com.njcn.harmonic.service.majornetwork;
import com.njcn.harmonic.pojo.po.day.RStatLimitRateDPO;
import com.njcn.harmonic.pojo.po.day.RStatLimitTargetDPO;
import java.util.List;
/**
* pqs
*
* @author cdf
* @date 2024/2/28
*/
public interface RStatLimitService {
/**
* 获取指定日期的监测点超标详情
* @author cdf
* @date 2024/2/28
*/
List<RStatLimitRateDPO> monitorIdsGetLimitRateInfo(String date, List<String> monitorIds);
List<RStatLimitTargetDPO> monitorIdsGetLimitTargetInfo(String date, List<String> monitorIds);
}

46
pqs-harmonic/harmonic-boot/src/main/java/com/njcn/harmonic/service/majornetwork/impl/RStatLimitServiceImpl.java Normal file
View File

@@ -0,0 +1,46 @@
package com.njcn.harmonic.service.majornetwork.impl;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.njcn.harmonic.mapper.RStatLimitRateDMapper;
import com.njcn.harmonic.mapper.RStatLimitTargetDMapper;
import com.njcn.harmonic.mapper.RStatLimitTargetMapper;
import com.njcn.harmonic.pojo.po.day.RStatLimitRateDPO;
import com.njcn.harmonic.pojo.po.day.RStatLimitTargetDPO;
import com.njcn.harmonic.service.majornetwork.RStatLimitService;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import java.util.List;
/**
* pqs
*
* @author cdf
* @date 2024/2/28
*/
@Service
@RequiredArgsConstructor
public class RStatLimitServiceImpl implements RStatLimitService {
private final RStatLimitRateDMapper rStatLimitRateDMapper;
private final RStatLimitTargetDMapper rStatLimitTargetDMapper;
@Override
public List<RStatLimitRateDPO> monitorIdsGetLimitRateInfo(String date, List<String> monitorIds) {
return rStatLimitRateDMapper.selectList(new LambdaQueryWrapper<RStatLimitRateDPO>()
.in(RStatLimitRateDPO::getLineId,monitorIds).eq(RStatLimitRateDPO::getTime,date).eq(RStatLimitRateDPO::getPhasicType,"T"));
}
@Override
public List<RStatLimitTargetDPO> monitorIdsGetLimitTargetInfo(String date, List<String> monitorIds) {
return rStatLimitTargetDMapper.selectList(new LambdaQueryWrapper<RStatLimitTargetDPO>().in(RStatLimitTargetDPO::getLineId,monitorIds)
.eq(RStatLimitTargetDPO::getTime,date).gt(RStatLimitTargetDPO::getAllTime,0));
}
}

102
pqs-prepare/prepare-boot/src/main/java/com/njcn/prepare/harmonic/controller/line/ThsSuperviseController.java
View File

@@ -1,51 +1,51 @@
package com.njcn.prepare.harmonic.controller.line; //package com.njcn.prepare.harmonic.controller.line;
//
//
import com.njcn.common.pojo.enums.response.CommonResponseEnum; //import com.njcn.common.pojo.enums.response.CommonResponseEnum;
import com.njcn.common.pojo.response.HttpResult; //import com.njcn.common.pojo.response.HttpResult;
import com.njcn.common.utils.HttpResultUtil; //import com.njcn.common.utils.HttpResultUtil;
import com.njcn.prepare.harmonic.pojo.param.SuperviseParam; //import com.njcn.prepare.harmonic.pojo.param.SuperviseParam;
import com.njcn.prepare.harmonic.service.mysql.line.ThsSuperviseService; //
import com.njcn.web.controller.BaseController; //import com.njcn.web.controller.BaseController;
import io.swagger.annotations.Api; //import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam; //import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiOperation; //import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Autowired; //import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.validation.annotation.Validated; //import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*; //import org.springframework.web.bind.annotation.*;
//
/** ///**
* <p> // * <p>
* 前端控制器 // * 前端控制器
* </p> // * </p>
* // *
* @author lxp // * @author lxp
* @since 2023-03-16 // * @since 2023-03-16
*/ // */
@Api(tags = "预警-告警技术监督") //@Api(tags = "预警-告警技术监督")
@RestController //@RestController
@RequestMapping("/thsSupervise") //@RequestMapping("/thsSupervise")
public class ThsSuperviseController extends BaseController { //public class ThsSuperviseController extends BaseController {
@Autowired // @Autowired
private ThsSuperviseService thsSuperviseService; // private ThsSuperviseService thsSuperviseService;
//
@ApiOperation("预警/告警事务手动初始化") // @ApiOperation("预警/告警事务手动初始化")
@ApiImplicitParam(name = "superviseParam", value = "新建技术监督参数", required = true) // @ApiImplicitParam(name = "superviseParam", value = "新建技术监督参数", required = true)
@PostMapping("/initSupervise") // @PostMapping("/initSupervise")
@ResponseBody // @ResponseBody
public HttpResult<String> initSupervise(@RequestBody @Validated SuperviseParam superviseParam) { // public HttpResult<String> initSupervise(@RequestBody @Validated SuperviseParam superviseParam) {
return thsSuperviseService.initSupervise(superviseParam); // return thsSuperviseService.initSupervise(superviseParam);
} // }
//
//
@ApiOperation("预警/告警事务自动生成") // @ApiOperation("预警/告警事务自动生成")
@ApiImplicitParam(name = "superviseParam", value = "创建技术监督参数", required = true) // @ApiImplicitParam(name = "superviseParam", value = "创建技术监督参数", required = true)
@PostMapping("/creatSupervise") // @PostMapping("/creatSupervise")
@ResponseBody // @ResponseBody
public HttpResult<String> creatSupervise(@RequestBody @Validated SuperviseParam superviseParam) { // public HttpResult<String> creatSupervise(@RequestBody @Validated SuperviseParam superviseParam) {
String methodDescribe = getMethodDescribe("creatSupervise"); // String methodDescribe = getMethodDescribe("creatSupervise");
thsSuperviseService.creatSupervise(superviseParam); // thsSuperviseService.creatSupervise(superviseParam);
return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, null, methodDescribe); // return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, null, methodDescribe);
} // }
} //}
//

937
pqs-prepare/prepare-boot/src/main/java/com/njcn/prepare/harmonic/service/mysql/Impl/line/ThsSuperviseServiceImpl.java
View File

@@ -1,469 +1,468 @@
package com.njcn.prepare.harmonic.service.mysql.Impl.line; //package com.njcn.prepare.harmonic.service.mysql.Impl.line;
//
import cn.hutool.core.collection.CollectionUtil; //import cn.hutool.core.collection.CollectionUtil;
import cn.hutool.core.date.DateUtil; //import cn.hutool.core.date.DateUtil;
import cn.hutool.core.util.IdUtil; //import cn.hutool.core.util.IdUtil;
import com.alibaba.fastjson.JSON; //import com.alibaba.fastjson.JSON;
import com.baomidou.dynamic.datasource.annotation.DS; //import com.baomidou.dynamic.datasource.annotation.DS;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper; //import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl; //import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.njcn.common.pojo.enums.response.CommonResponseEnum; //import com.njcn.common.pojo.enums.response.CommonResponseEnum;
import com.njcn.common.pojo.response.HttpResult; //import com.njcn.common.pojo.response.HttpResult;
import com.njcn.common.utils.HttpResultUtil; //import com.njcn.common.utils.HttpResultUtil;
import com.njcn.device.pms.pojo.po.Monitor; //import com.njcn.device.pms.pojo.po.Monitor;
import com.njcn.harmonic.pojo.po.day.RStatLimitRateDPO; //import com.njcn.harmonic.pojo.po.day.RStatLimitRateDPO;
import com.njcn.harmonic.pojo.vo.SourceSteadyIndicator; //import com.njcn.harmonic.pojo.vo.SourceSteadyIndicator;
import com.njcn.harmonic.pojo.vo.ThsStrategyVo; //import com.njcn.harmonic.pojo.vo.ThsStrategyVo;
import com.njcn.oss.utils.FileStorageUtil; //import com.njcn.oss.utils.FileStorageUtil;
import com.njcn.prepare.enums.*; //import com.njcn.prepare.enums.*;
import com.njcn.prepare.harmonic.mapper.mysql.line.*; //import com.njcn.prepare.harmonic.mapper.mysql.line.*;
import com.njcn.prepare.harmonic.pojo.param.SuperviseParam; //import com.njcn.prepare.harmonic.pojo.param.SuperviseParam;
import com.njcn.prepare.harmonic.pojo.po.ThsOverRunLog; //import com.njcn.prepare.harmonic.pojo.po.ThsOverRunLog;
import com.njcn.prepare.harmonic.pojo.po.ThsSupervise; //import com.njcn.prepare.harmonic.pojo.po.ThsSupervise;
import com.njcn.prepare.harmonic.pojo.vo.SuperviceRunLogVo; //import com.njcn.prepare.harmonic.pojo.vo.SuperviceRunLogVo;
import com.njcn.prepare.harmonic.service.mysql.day.IRStatLimitRateDService; //import com.njcn.prepare.harmonic.service.mysql.day.IRStatLimitRateDService;
import com.njcn.prepare.harmonic.service.mysql.line.ThsSuperviseService; //import com.njcn.prepare.harmonic.service.mysql.line.ThsSuperviseService;
import com.njcn.process.annotaion.HarCurrent; //import com.njcn.process.annotaion.HarCurrent;
import com.njcn.process.annotaion.HarVoltage; //import com.njcn.process.annotaion.HarVoltage;
import com.njcn.process.annotaion.InterharVoltage; //import com.njcn.process.annotaion.InterharVoltage;
import com.njcn.process.api.FlowableDefineFeignClient; //import com.njcn.process.api.FlowableDefineFeignClient;
import com.njcn.process.pojo.po.ThsWarnStrategyAss; //import com.njcn.process.pojo.po.ThsWarnStrategyAss;
import com.njcn.system.api.DicDataFeignClient; //import com.njcn.system.api.DicDataFeignClient;
import com.njcn.system.pojo.po.DictData; //import com.njcn.system.pojo.po.DictData;
import com.njcn.user.api.DeptFeignClient; //import com.njcn.user.api.DeptFeignClient;
import com.njcn.user.pojo.po.Dept; //import com.njcn.user.pojo.po.Dept;
import com.njcn.web.utils.RequestUtil; //import com.njcn.web.utils.RequestUtil;
import lombok.RequiredArgsConstructor; //import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j; //import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections.map.HashedMap; //import org.apache.commons.collections.map.HashedMap;
import org.apache.commons.lang.StringUtils; //import org.apache.commons.lang.StringUtils;
import org.springframework.scheduling.annotation.Async; //import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service; //import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional; //import org.springframework.transaction.annotation.Transactional;
//
import java.lang.reflect.Field; //import java.lang.reflect.Field;
import java.time.Instant; //import java.time.Instant;
import java.time.LocalDate; //import java.time.LocalDate;
import java.time.LocalTime; //import java.time.LocalTime;
import java.time.ZoneId; //import java.time.ZoneId;
import java.util.*; //import java.util.*;
import java.util.stream.Collectors; //import java.util.stream.Collectors;
//
/** ///**
* <p> // * <p>
* 服务实现类 // * 服务实现类
* </p> // * </p>
* // *
* @author lxp // * @author lxp
* @since 2023-03-16 // * @since 2023-03-16
*/ // */
@Service //@Service
@Slf4j //@Slf4j
@RequiredArgsConstructor //@RequiredArgsConstructor
public class ThsSuperviseServiceImpl extends ServiceImpl<ThsSuperviseMapper, ThsSupervise> implements ThsSuperviseService { //public class ThsSuperviseServiceImpl extends ServiceImpl<ThsSuperviseMapper, ThsSupervise> implements ThsSuperviseService {
//
//
//
//
private final ThsWarnStrategyMapper thsWarnStrategyMapper; // private final ThsWarnStrategyMapper thsWarnStrategyMapper;
//
private final ThsWarnStrategyAssMapper thsWarnStrategyAssMapper; // private final ThsWarnStrategyAssMapper thsWarnStrategyAssMapper;
//
private final PmsMonitorMapper pmsMonitorMapper; // private final PmsMonitorMapper pmsMonitorMapper;
//
private final IRStatLimitRateDService rateDService; // private final IRStatLimitRateDService rateDService;
//
private final DicDataFeignClient dicDataFeignClient; // private final DicDataFeignClient dicDataFeignClient;
//
private final ThsSuperviseMapper thsSuperviseMapper; // private final ThsSuperviseMapper thsSuperviseMapper;
//
private final ThsOverRunLogMapper thsOverRunLogMapper; // private final ThsOverRunLogMapper thsOverRunLogMapper;
//
private final DeptFeignClient deptFeignClient; // private final DeptFeignClient deptFeignClient;
//
private final FileStorageUtil fileStorageUtil; // private final FileStorageUtil fileStorageUtil;
private static final String DESCRIPTION = "description"; // private static final String DESCRIPTION = "description";
//
private final FlowableDefineFeignClient flowableDefineFeignClient; // private final FlowableDefineFeignClient flowableDefineFeignClient;
//
//
@Override // @Override
@Async("asyncExecutor") // @Async("asyncExecutor")
public void creatSupervise(SuperviseParam superviseParam) { // public void creatSupervise(SuperviseParam superviseParam) {
this.initSupervise(superviseParam); // this.initSupervise(superviseParam);
} // }
//
@Override // @Override
public HttpResult<String> initSupervise(SuperviseParam superviseParam) { // public HttpResult<String> initSupervise(SuperviseParam superviseParam) {
SuperviceRunLogVo superviceRunLogVo = new SuperviceRunLogVo(); // SuperviceRunLogVo superviceRunLogVo = new SuperviceRunLogVo();
List<ThsOverRunLog> overRunLogList = new ArrayList<>(); // List<ThsOverRunLog> overRunLogList = new ArrayList<>();
if (InitTypeEnum.MANUAL.getCode().equals(superviseParam.getInitType()) && StringUtils.isBlank(superviseParam.getDeptId())) { // if (InitTypeEnum.MANUAL.getCode().equals(superviseParam.getInitType()) && StringUtils.isBlank(superviseParam.getDeptId())) {
return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.INVALID_PARAMETER, null, ""); // return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.INVALID_PARAMETER, null, "");
} // }
List<ThsStrategyVo> thsStrategyList = this.selectStrategyList(superviseParam); // List<ThsStrategyVo> thsStrategyList = this.selectStrategyList(superviseParam);
//按部门进行分组 // //按部门进行分组
if (CollectionUtil.isNotEmpty(thsStrategyList)) { // if (CollectionUtil.isNotEmpty(thsStrategyList)) {
Map<String, List<ThsStrategyVo>> deptMap = thsStrategyList.stream().collect(Collectors.groupingBy(ThsStrategyVo::getDeptId)); // Map<String, List<ThsStrategyVo>> deptMap = thsStrategyList.stream().collect(Collectors.groupingBy(ThsStrategyVo::getDeptId));
for (Map.Entry<String, List<ThsStrategyVo>> entry : deptMap.entrySet()) { // for (Map.Entry<String, List<ThsStrategyVo>> entry : deptMap.entrySet()) {
String depId = entry.getKey(); // String depId = entry.getKey();
ThsSupervise thsSupervise = new ThsSupervise(); // ThsSupervise thsSupervise = new ThsSupervise();
List<ThsStrategyVo> deptList = entry.getValue(); // List<ThsStrategyVo> deptList = entry.getValue();
List<ThsStrategyVo> oneLevel = deptList.stream().filter(r -> !GradeEnum.THREE_LEVEL.getCode().equals(r.getGrade())).collect(Collectors.toList());//一级或二级策略集合 // List<ThsStrategyVo> oneLevel = deptList.stream().filter(r -> !GradeEnum.THREE_LEVEL.getCode().equals(r.getGrade())).collect(Collectors.toList());//一级或二级策略集合
List<SourceSteadyIndicator> oneSourceSteadyIndicatorList = new ArrayList<>(); // List<SourceSteadyIndicator> oneSourceSteadyIndicatorList = new ArrayList<>();
if (CollectionUtil.isNotEmpty(oneLevel)) { // if (CollectionUtil.isNotEmpty(oneLevel)) {
for (ThsStrategyVo oneStrategyVo : oneLevel) { // for (ThsStrategyVo oneStrategyVo : oneLevel) {
List<ThsWarnStrategyAss> oneInterferenceSourceAsses = this.queryWarnStrategyAss(oneStrategyVo.getId(), TypeEnum.SOURCE_TYPE);//干扰源列表 // List<ThsWarnStrategyAss> oneInterferenceSourceAsses = this.queryWarnStrategyAss(oneStrategyVo.getId(), TypeEnum.SOURCE_TYPE);//干扰源列表
List<ThsWarnStrategyAss> oneSteadyIndicatorAsses = this.queryWarnStrategyAss(oneStrategyVo.getId(), TypeEnum.INTERFERENCE_TYPE);//干扰源列表 // List<ThsWarnStrategyAss> oneSteadyIndicatorAsses = this.queryWarnStrategyAss(oneStrategyVo.getId(), TypeEnum.INTERFERENCE_TYPE);//干扰源列表
List<String> oneSteadyIndicatorAssesIds = oneSteadyIndicatorAsses.stream().map(ThsWarnStrategyAss::getAssId).collect(Collectors.toList()); // List<String> oneSteadyIndicatorAssesIds = oneSteadyIndicatorAsses.stream().map(ThsWarnStrategyAss::getAssId).collect(Collectors.toList());
//封装每一种干扰源和对应的指标 // //封装每一种干扰源和对应的指标
for (ThsWarnStrategyAss oneWarnStrategyAss : oneInterferenceSourceAsses) { // for (ThsWarnStrategyAss oneWarnStrategyAss : oneInterferenceSourceAsses) {
SourceSteadyIndicator build = SourceSteadyIndicator.builder().id(oneStrategyVo.getId()).operation(oneStrategyVo.getOperation()) // SourceSteadyIndicator build = SourceSteadyIndicator.builder().id(oneStrategyVo.getId()).operation(oneStrategyVo.getOperation())
.interferenceSource(oneWarnStrategyAss.getAssId()) // .interferenceSource(oneWarnStrategyAss.getAssId())
.steadyIndicator(oneSteadyIndicatorAssesIds) // .steadyIndicator(oneSteadyIndicatorAssesIds)
.deptId(oneStrategyVo.getDeptId()) // .deptId(oneStrategyVo.getDeptId())
.type(oneStrategyVo.getType()) // .type(oneStrategyVo.getType())
.monitorId(oneStrategyVo.getMonitorId()) // .build();
.build(); // oneSourceSteadyIndicatorList.add(build);
oneSourceSteadyIndicatorList.add(build); // }
} // }
} // }
} // List<ThsStrategyVo> threeLevel = deptList.stream().filter(r -> GradeEnum.THREE_LEVEL.getCode().equals(r.getGrade())).collect(Collectors.toList());//三级策略集合
List<ThsStrategyVo> threeLevel = deptList.stream().filter(r -> GradeEnum.THREE_LEVEL.getCode().equals(r.getGrade())).collect(Collectors.toList());//三级策略集合 // if (CollectionUtil.isNotEmpty(threeLevel)) {
if (CollectionUtil.isNotEmpty(threeLevel)) { // for (ThsStrategyVo threeStrategyVo : threeLevel) {
for (ThsStrategyVo threeStrategyVo : threeLevel) { // Iterator<SourceSteadyIndicator> iterator = oneSourceSteadyIndicatorList.iterator();
Iterator<SourceSteadyIndicator> iterator = oneSourceSteadyIndicatorList.iterator(); // while (iterator.hasNext()) {
while (iterator.hasNext()) { // SourceSteadyIndicator sourceSteady = iterator.next();
SourceSteadyIndicator sourceSteady = iterator.next(); // if (sourceSteady.getType().equals(threeStrategyVo.getType())) {
if (sourceSteady.getType().equals(threeStrategyVo.getType())) { // if (StringUtils.equals(threeStrategyVo.getMonitorId(), sourceSteady.getMonitorId())) {
if (StringUtils.equals(threeStrategyVo.getMonitorId(), sourceSteady.getMonitorId())) { // List<ThsWarnStrategyAss> interferenceSourceAsses = this.queryWarnStrategyAss(threeStrategyVo.getId(), TypeEnum.SOURCE_TYPE);
List<ThsWarnStrategyAss> interferenceSourceAsses = this.queryWarnStrategyAss(threeStrategyVo.getId(), TypeEnum.SOURCE_TYPE); // //干扰源类型id
//干扰源类型id // List<String> threeInterferenceSourceIds = interferenceSourceAsses.stream().map(ThsWarnStrategyAss::getAssId).collect(Collectors.toList());
List<String> threeInterferenceSourceIds = interferenceSourceAsses.stream().map(ThsWarnStrategyAss::getAssId).collect(Collectors.toList()); // List<ThsWarnStrategyAss> threeSteadyIndicatorAsses = this.queryWarnStrategyAss(threeStrategyVo.getId(), TypeEnum.INTERFERENCE_TYPE);
List<ThsWarnStrategyAss> threeSteadyIndicatorAsses = this.queryWarnStrategyAss(threeStrategyVo.getId(), TypeEnum.INTERFERENCE_TYPE); // //指标类型id
//指标类型id // List<String> steadyIndicatorIds = threeSteadyIndicatorAsses.stream().map(ThsWarnStrategyAss::getAssId).collect(Collectors.toList());
List<String> steadyIndicatorIds = threeSteadyIndicatorAsses.stream().map(ThsWarnStrategyAss::getAssId).collect(Collectors.toList()); // for (String threeInterferenceSourceId : threeInterferenceSourceIds) {
for (String threeInterferenceSourceId : threeInterferenceSourceIds) { // if (OperationEnum.AND.getCode().equals(threeStrategyVo.getOperation())) {//处理三级策略的与
if (OperationEnum.AND.getCode().equals(threeStrategyVo.getOperation())) {//处理三级策略的与 // if (OperationEnum.AND.getCode().equals(sourceSteady.getOperation())) {
if (OperationEnum.AND.getCode().equals(sourceSteady.getOperation())) { // if (StringUtils.equals(threeInterferenceSourceId, sourceSteady.getInterferenceSource()) &&
if (StringUtils.equals(threeInterferenceSourceId, sourceSteady.getInterferenceSource()) && // steadyIndicatorIds.containsAll(sourceSteady.getSteadyIndicator())) {
steadyIndicatorIds.containsAll(sourceSteady.getSteadyIndicator())) { // iterator.remove();
iterator.remove(); // }
} // }
} // } else {//处理三级策略的或
} else {//处理三级策略的或 // if (StringUtils.equals(threeInterferenceSourceId, sourceSteady.getInterferenceSource())) {
if (StringUtils.equals(threeInterferenceSourceId, sourceSteady.getInterferenceSource())) { // if (steadyIndicatorIds.containsAll(sourceSteady.getSteadyIndicator())) {
if (steadyIndicatorIds.containsAll(sourceSteady.getSteadyIndicator())) { // iterator.remove();
iterator.remove(); // } else {
} else { // List<String> steadyIndicator = sourceSteady.getSteadyIndicator();
List<String> steadyIndicator = sourceSteady.getSteadyIndicator(); // steadyIndicator.removeAll(steadyIndicatorIds);
steadyIndicator.removeAll(steadyIndicatorIds); // }
} // }
} // }
} // }
} // }
} // }
} // }
} // }
} // }
} // if (CollectionUtil.isNotEmpty(oneSourceSteadyIndicatorList)) {
if (CollectionUtil.isNotEmpty(oneSourceSteadyIndicatorList)) { // oneSourceSteadyIndicatorList.forEach(steady -> {
oneSourceSteadyIndicatorList.forEach(steady -> { // Monitor monitor = pmsMonitorMapper.selectById(steady.getMonitorId());
Monitor monitor = pmsMonitorMapper.selectById(steady.getMonitorId()); // if (monitor != null) {
if (monitor != null) { // if (StringUtils.equals(monitor.getMonitorTag(), steady.getInterferenceSource())) {//匹配该监测点属于的干扰源类型
if (StringUtils.equals(monitor.getMonitorTag(), steady.getInterferenceSource())) {//匹配该监测点属于的干扰源类型 // //查询该监测点的检测数据
//查询该监测点的检测数据 // RStatLimitRateDPO limitRate = this.queryLimitTargetData(monitor.getId());
RStatLimitRateDPO limitRate = this.queryLimitTargetData(monitor.getId()); // //判断指标是否超标
//判断指标是否超标 // Map<String, Object> limitBoolMap = this.verifyLimit(limitRate, steady);
Map<String, Object> limitBoolMap = this.verifyLimit(limitRate, steady); // //构建监督数据
//构建监督数据 // this.buildData(steady, limitBoolMap, monitor, limitRate, superviseParam.getInitType(), thsSupervise, overRunLogList);
this.buildData(steady, limitBoolMap, monitor, limitRate, superviseParam.getInitType(), thsSupervise, overRunLogList); //
// }
} // }
} // });
}); // //生成技术监督数据
//生成技术监督数据 // HttpResult<Dept> deptById = deptFeignClient.getDeptById(depId);
HttpResult<Dept> deptById = deptFeignClient.getDeptById(depId); // Dept dept = deptById.getData();
Dept dept = deptById.getData(); // if (InitTypeEnum.AUTO.getCode().equals(superviseParam.getInitType())) {
if (InitTypeEnum.AUTO.getCode().equals(superviseParam.getInitType())) { // this.creatData(dept, thsSupervise, overRunLogList);
this.creatData(dept, thsSupervise, overRunLogList); // } else {
} else { // this.buildSuperviseName(thsSupervise, overRunLogList, dept);
this.buildSuperviseName(thsSupervise, overRunLogList, dept); // superviceRunLogVo.setOverRunLog(overRunLogList);
superviceRunLogVo.setOverRunLog(overRunLogList); // superviceRunLogVo.setThsSupervise(thsSupervise);
superviceRunLogVo.setThsSupervise(thsSupervise); // }
} // }
} // }
} // }
} // return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, JSON.toJSONString(superviceRunLogVo), "");
return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, JSON.toJSONString(superviceRunLogVo), ""); // }
} //
// /**
/** // * 构建技术监督名称
* 构建技术监督名称 // *
* // * @param thsSupervise
* @param thsSupervise // * @param overRunLogList
* @param overRunLogList // * @param dept
* @param dept // */
*/ // private void buildSuperviseName(ThsSupervise thsSupervise, List<ThsOverRunLog> overRunLogList, Dept dept) {
private void buildSuperviseName(ThsSupervise thsSupervise, List<ThsOverRunLog> overRunLogList, Dept dept) { // if (CollectionUtil.isNotEmpty(overRunLogList)) {
if (CollectionUtil.isNotEmpty(overRunLogList)) { // thsSupervise.setDescription(overRunLogList.get(0).getDescription());
thsSupervise.setDescription(overRunLogList.get(0).getDescription()); // String str = Arrays.asList(overRunLogList.get(0).getDescription().split(",")).get(0);
String str = Arrays.asList(overRunLogList.get(0).getDescription().split(",")).get(0); // String overItem = str.substring(0, str.indexOf("次") - 1);
String overItem = str.substring(0, str.indexOf("次") - 1); // thsSupervise.setName(DateUtil.today() + dept.getName() + overRunLogList.get(0).getName() + "等" + overRunLogList.size() + "个监测点" + overItem);
thsSupervise.setName(DateUtil.today() + dept.getName() + overRunLogList.get(0).getName() + "等" + overRunLogList.size() + "个监测点" + overItem); // }
} // }
} //
// //生成技术监督数据
//生成技术监督数据 // @DS("process")
@DS("process") // @Transactional(rollbackFor = Exception.class)
@Transactional(rollbackFor = Exception.class) // @Override
@Override // public void creatData(Dept dept, ThsSupervise thsSupervise, List<ThsOverRunLog> overRunLogList) {
public void creatData(Dept dept, ThsSupervise thsSupervise, List<ThsOverRunLog> overRunLogList) { // if (CollectionUtil.isNotEmpty(overRunLogList)) {
if (CollectionUtil.isNotEmpty(overRunLogList)) { // thsSupervise.setDescription(overRunLogList.get(0).getDescription());
thsSupervise.setDescription(overRunLogList.get(0).getDescription()); // String str = Arrays.asList(overRunLogList.get(0).getDescription().split(",")).get(0);
String str = Arrays.asList(overRunLogList.get(0).getDescription().split(",")).get(0); // String overItem = str.substring(0, str.indexOf("次") - 1);
String overItem = str.substring(0, str.indexOf("次") - 1); // thsSupervise.setName(DateUtil.today() + dept.getName() + overRunLogList.get(0).getName() + "等" + overRunLogList.size() + "个监测点" + overItem);
thsSupervise.setName(DateUtil.today() + dept.getName() + overRunLogList.get(0).getName() + "等" + overRunLogList.size() + "个监测点" + overItem); // thsSuperviseMapper.insert(thsSupervise);
thsSuperviseMapper.insert(thsSupervise); //
// //TODO 解决工作流写死问题
//TODO 解决工作流写死问题 // Map<String, Object> mapParam = new HashMap<>();
Map<String, Object> mapParam = new HashMap<>(); // String proInId ="";
String proInId =""; // if(thsSupervise.getType() == 0){
if(thsSupervise.getType() == 0){ // proInId = "flow_yzep99kb:1:a100b48b-da75-11ed-8335-b07b253cdad9";
proInId = "flow_yzep99kb:1:a100b48b-da75-11ed-8335-b07b253cdad9"; // }else {
}else { // proInId = "flow_yzep99kb:2:6358e099-dcba-11ed-8026-b07b253cdad9";
proInId = "flow_yzep99kb:2:6358e099-dcba-11ed-8026-b07b253cdad9"; // }
} // flowableDefineFeignClient.start(proInId,thsSupervise.getSupIndex(),mapParam);
flowableDefineFeignClient.start(proInId,thsSupervise.getSupIndex(),mapParam); //
// for (ThsOverRunLog thsOverRunLog : overRunLogList) {
for (ThsOverRunLog thsOverRunLog : overRunLogList) { // thsOverRunLogMapper.insert(thsOverRunLog);
thsOverRunLogMapper.insert(thsOverRunLog); // }
} // }
} // }
} //
//
// /**
/** // * 查询策略列表
* 查询策略列表 // *
* // * @param superviseParam
* @param superviseParam // * @return
* @return // */
*/ // @DS("process")
@DS("process") // @Override
@Override // public List<ThsStrategyVo> selectStrategyList(SuperviseParam superviseParam) {
public List<ThsStrategyVo> selectStrategyList(SuperviseParam superviseParam) { // return thsWarnStrategyMapper.selectStrategyList(superviseParam);
return thsWarnStrategyMapper.selectStrategyList(superviseParam); // }
} //
// /**
/** // * 查询策略绑定的干扰源列表或指标参数列表
* 查询策略绑定的干扰源列表或指标参数列表 // *
* // * @param warnId
* @param warnId // * @param typeEnum
* @param typeEnum // * @return
* @return // */
*/ // @DS("process")
@DS("process") // @Override
@Override // public List<ThsWarnStrategyAss> queryWarnStrategyAss(String warnId, TypeEnum typeEnum) {
public List<ThsWarnStrategyAss> queryWarnStrategyAss(String warnId, TypeEnum typeEnum) { // return thsWarnStrategyAssMapper.selectList(new LambdaQueryWrapper<ThsWarnStrategyAss>()
return thsWarnStrategyAssMapper.selectList(new LambdaQueryWrapper<ThsWarnStrategyAss>() // .eq(ThsWarnStrategyAss::getWarnId, warnId)
.eq(ThsWarnStrategyAss::getWarnId, warnId) // .eq(ThsWarnStrategyAss::getType, typeEnum.getCode()));
.eq(ThsWarnStrategyAss::getType, typeEnum.getCode())); // }
} //
// /**
/** // * 生成监督数据
* 生成监督数据 // *
* // * @param limitBoolMap
* @param limitBoolMap // */
*/ // @Override
@Override // public void buildData(SourceSteadyIndicator steady, Map<String, Object> limitBoolMap, Monitor monitor, RStatLimitRateDPO limitRate, Integer initType, ThsSupervise thsSupervise, List<ThsOverRunLog> thsOverRunLogs) {
public void buildData(SourceSteadyIndicator steady, Map<String, Object> limitBoolMap, Monitor monitor, RStatLimitRateDPO limitRate, Integer initType, ThsSupervise thsSupervise, List<ThsOverRunLog> thsOverRunLogs) { // if (CollectionUtil.isNotEmpty(limitBoolMap)) {
if (CollectionUtil.isNotEmpty(limitBoolMap)) { // if (OperationEnum.AND.getCode().equals(steady.getOperation())) {
if (OperationEnum.AND.getCode().equals(steady.getOperation())) { // for (Map.Entry<String, Object> entry : limitBoolMap.entrySet()) {
for (Map.Entry<String, Object> entry : limitBoolMap.entrySet()) { // if (entry.getValue() instanceof Boolean && !(boolean) entry.getValue()) {
if (entry.getValue() instanceof Boolean && !(boolean) entry.getValue()) { // return;
return; // }
} // }
} // //构建监督数据
//构建监督数据 // this.buildSuperviseData(steady, monitor, limitRate, limitBoolMap, initType, thsSupervise, thsOverRunLogs);
this.buildSuperviseData(steady, monitor, limitRate, limitBoolMap, initType, thsSupervise, thsOverRunLogs); // //构建告警/预警监测点列表数据
//构建告警/预警监测点列表数据 // this.buildOverRunLog(steady, thsSupervise, monitor, limitRate, limitBoolMap, initType, thsOverRunLogs);
this.buildOverRunLog(steady, thsSupervise, monitor, limitRate, limitBoolMap, initType, thsOverRunLogs); // return;
return; // }
} // if (OperationEnum.OR.getCode().equals(steady.getOperation())) {
if (OperationEnum.OR.getCode().equals(steady.getOperation())) { // for (Map.Entry<String, Object> entry : limitBoolMap.entrySet()) {
for (Map.Entry<String, Object> entry : limitBoolMap.entrySet()) { // if (entry.getValue() instanceof Boolean && (boolean) entry.getValue()) {
if (entry.getValue() instanceof Boolean && (boolean) entry.getValue()) { // //生成监督数据
//生成监督数据 // this.buildSuperviseData(steady, monitor, limitRate, limitBoolMap, initType, thsSupervise, thsOverRunLogs);
this.buildSuperviseData(steady, monitor, limitRate, limitBoolMap, initType, thsSupervise, thsOverRunLogs); // //生成告警/预警监测点数据
//生成告警/预警监测点数据 // this.buildOverRunLog(steady, thsSupervise, monitor, limitRate, limitBoolMap, initType, thsOverRunLogs);
this.buildOverRunLog(steady, thsSupervise, monitor, limitRate, limitBoolMap, initType, thsOverRunLogs); // return;
return; // }
} // }
} // }
} // }
} // }
} //
//
// @Override
@Override // public void buildSuperviseData(SourceSteadyIndicator steady, Monitor monitor, RStatLimitRateDPO limitRate, Map<String, Object> limitBoolMap, Integer initType, ThsSupervise thsSupervise, List<ThsOverRunLog> thsOverRunLogs) {
public void buildSuperviseData(SourceSteadyIndicator steady, Monitor monitor, RStatLimitRateDPO limitRate, Map<String, Object> limitBoolMap, Integer initType, ThsSupervise thsSupervise, List<ThsOverRunLog> thsOverRunLogs) { // if (thsSupervise != null && StringUtils.isBlank(thsSupervise.getSupIndex())) {
if (thsSupervise != null && StringUtils.isBlank(thsSupervise.getSupIndex())) { // thsSupervise.setSupIndex(IdUtil.simpleUUID());
thsSupervise.setSupIndex(IdUtil.simpleUUID()); // thsSupervise.setDeptId(steady.getDeptId());
thsSupervise.setDeptId(steady.getDeptId()); // thsSupervise.setCreateTime(new Date());
thsSupervise.setCreateTime(new Date()); // thsSupervise.setType(steady.getType());
thsSupervise.setType(steady.getType()); // thsSupervise.setCreateUser(RequestUtil.getUsername());
thsSupervise.setCreateUser(RequestUtil.getUsername()); // thsSupervise.setProgress(ProgressEnum.START.getCode());
thsSupervise.setProgress(ProgressEnum.START.getCode()); // thsSupervise.setCreateType(initType);
thsSupervise.setCreateType(initType); // }
} // }
} //
//
// @Override
@Override // public void buildOverRunLog(SourceSteadyIndicator steady, ThsSupervise thsSupervise, Monitor monitor, RStatLimitRateDPO limitRate, Map<String, Object> limitBoolMap, Integer initType, List<ThsOverRunLog> thsOverRunLogs) {
public void buildOverRunLog(SourceSteadyIndicator steady, ThsSupervise thsSupervise, Monitor monitor, RStatLimitRateDPO limitRate, Map<String, Object> limitBoolMap, Integer initType, List<ThsOverRunLog> thsOverRunLogs) { // ThsOverRunLog thsOverRunLog = new ThsOverRunLog();
ThsOverRunLog thsOverRunLog = new ThsOverRunLog(); // thsOverRunLog.setId(IdUtil.simpleUUID());
thsOverRunLog.setId(IdUtil.simpleUUID()); // thsOverRunLog.setSupIndex(thsSupervise.getSupIndex());
thsOverRunLog.setSupIndex(thsSupervise.getSupIndex()); // thsOverRunLog.setLineIndex(monitor.getId());
thsOverRunLog.setLineIndex(monitor.getId()); // thsOverRunLog.setName(monitor.getPowerrName() + "_" + monitor.getName() + "_" + DateUtil.today() + "_" + monitor.getId());
thsOverRunLog.setName(monitor.getPowerrName() + "_" + monitor.getName() + "_" + DateUtil.today() + "_" + monitor.getId()); // thsOverRunLog.setUpdateTime(Date.from(limitRate.getTime().atTime(LocalTime.MIDNIGHT).atZone(ZoneId.systemDefault()).toInstant()));
thsOverRunLog.setUpdateTime(Date.from(limitRate.getTime().atTime(LocalTime.MIDNIGHT).atZone(ZoneId.systemDefault()).toInstant())); // thsOverRunLog.setCreateTime(new Date());
thsOverRunLog.setCreateTime(new Date()); // List<String> descriptionList = (List) limitBoolMap.get(DESCRIPTION);
List<String> descriptionList = (List) limitBoolMap.get(DESCRIPTION); // thsOverRunLog.setDescription(StringUtils.join(descriptionList, ","));
thsOverRunLog.setDescription(StringUtils.join(descriptionList, ",")); // thsOverRunLogs.add(thsOverRunLog);
thsOverRunLogs.add(thsOverRunLog); // }
} //
//
// @Override
@Override // @DS("pms")
@DS("pms") // public RStatLimitRateDPO queryLimitTargetData(String monitorId) {
public RStatLimitRateDPO queryLimitTargetData(String monitorId) { // RStatLimitRateDPO limitRate = rateDService.getOne(new LambdaQueryWrapper<RStatLimitRateDPO>().eq(RStatLimitRateDPO::getLineId, monitorId)
RStatLimitRateDPO limitRate = rateDService.getOne(new LambdaQueryWrapper<RStatLimitRateDPO>().eq(RStatLimitRateDPO::getLineId, monitorId) // .between(RStatLimitRateDPO::getTime,
.between(RStatLimitRateDPO::getTime, // DateUtil.beginOfDay(DateUtil.offsetDay(new Date(), -1)),
DateUtil.beginOfDay(DateUtil.offsetDay(new Date(), -1)), // DateUtil.endOfDay(DateUtil.offsetDay(new Date(), -1))).last("limit 1"));
DateUtil.endOfDay(DateUtil.offsetDay(new Date(), -1))).last("limit 1")); // return limitRate;
return limitRate; // }
} //
//
// /**
/** // * 判断监测数据是否超标
* 判断监测数据是否超标 // *
* // * @param limitRate
* @param limitRate // * @param steady
* @param steady // */
*/ // private Map<String, Object> verifyLimit(RStatLimitRateDPO limitRate, SourceSteadyIndicator steady) {
private Map<String, Object> verifyLimit(RStatLimitRateDPO limitRate, SourceSteadyIndicator steady) { // if (limitRate != null) {
if (limitRate != null) { // List<String> steadyIndicator = steady.getSteadyIndicator();
List<String> steadyIndicator = steady.getSteadyIndicator(); // Map<String, Object> limitBoolMap = new HashedMap();
Map<String, Object> limitBoolMap = new HashedMap(); // List<String> descriptionList = new ArrayList<>();
List<String> descriptionList = new ArrayList<>(); // steadyIndicator.forEach(id -> {
steadyIndicator.forEach(id -> { // HttpResult<DictData> dicDataById = dicDataFeignClient.getDicDataById(id);
HttpResult<DictData> dicDataById = dicDataFeignClient.getDicDataById(id); // if (CommonResponseEnum.SUCCESS.getCode().equals(dicDataById.getCode()) && dicDataById.getData() != null) {
if (CommonResponseEnum.SUCCESS.getCode().equals(dicDataById.getCode()) && dicDataById.getData() != null) { // SteadyIndicatorEnum steadyIndicatorEnum = SteadyIndicatorEnum.getSteadyIndicatorEnumByCode(dicDataById.getData().getCode());
SteadyIndicatorEnum steadyIndicatorEnum = SteadyIndicatorEnum.getSteadyIndicatorEnumByCode(dicDataById.getData().getCode()); // if (null != steadyIndicatorEnum) {
if (null != steadyIndicatorEnum) { // switch (steadyIndicatorEnum) {
switch (steadyIndicatorEnum) { // case Negative_Voltage://负序电压不平衡度
case Negative_Voltage://负序电压不平衡度 // if (limitRate.getUbalanceOvertime() > 0) {
if (limitRate.getUbalanceOvertime() > 0) { // limitBoolMap.put(SteadyIndicatorEnum.Negative_Voltage.getCode(), true);
limitBoolMap.put(SteadyIndicatorEnum.Negative_Voltage.getCode(), true); // descriptionList.add(SteadyIndicatorEnum.Negative_Voltage.getMessage().concat(limitRate.getUbalanceOvertime() + "次"));
descriptionList.add(SteadyIndicatorEnum.Negative_Voltage.getMessage().concat(limitRate.getUbalanceOvertime() + "次")); // } else {
} else { // limitBoolMap.put(SteadyIndicatorEnum.Negative_Voltage.getCode(), false);
limitBoolMap.put(SteadyIndicatorEnum.Negative_Voltage.getCode(), false); // }
} // break;
break; // case Interhar_Voltage://间谐波电压
case Interhar_Voltage://间谐波电压 // Integer interharVoltageOvertime = this.maxOverTime(limitRate, InterharVoltage.class);
Integer interharVoltageOvertime = this.maxOverTime(limitRate, InterharVoltage.class); // if (interharVoltageOvertime > 0) {
if (interharVoltageOvertime > 0) { // limitBoolMap.put(SteadyIndicatorEnum.Interhar_Voltage.getCode(), true);
limitBoolMap.put(SteadyIndicatorEnum.Interhar_Voltage.getCode(), true); // descriptionList.add(SteadyIndicatorEnum.Interhar_Voltage.getMessage().concat(interharVoltageOvertime + "次"));
descriptionList.add(SteadyIndicatorEnum.Interhar_Voltage.getMessage().concat(interharVoltageOvertime + "次")); // } else {
} else { // limitBoolMap.put(SteadyIndicatorEnum.Interhar_Voltage.getCode(), false);
limitBoolMap.put(SteadyIndicatorEnum.Interhar_Voltage.getCode(), false); // }
} // break;
break; // case Neg_Current://负序电流
case Neg_Current://负序电流 // if (limitRate.getINegOvertime() > 0) {
if (limitRate.getINegOvertime() > 0) { // limitBoolMap.put(SteadyIndicatorEnum.Neg_Current.getCode(), true);
limitBoolMap.put(SteadyIndicatorEnum.Neg_Current.getCode(), true); // descriptionList.add(SteadyIndicatorEnum.Neg_Current.getMessage().concat(limitRate.getINegOvertime() + "次"));
descriptionList.add(SteadyIndicatorEnum.Neg_Current.getMessage().concat(limitRate.getINegOvertime() + "次")); // } else {
} else { // limitBoolMap.put(SteadyIndicatorEnum.Neg_Current.getCode(), false);
limitBoolMap.put(SteadyIndicatorEnum.Neg_Current.getCode(), false); // }
} // break;
break; // case Fre_Deviation://频率偏差
case Fre_Deviation://频率偏差 // if (limitRate.getFreqDevOvertime() > 0) {
if (limitRate.getFreqDevOvertime() > 0) { // limitBoolMap.put(SteadyIndicatorEnum.Fre_Deviation.getCode(), true);
limitBoolMap.put(SteadyIndicatorEnum.Fre_Deviation.getCode(), true); // descriptionList.add(SteadyIndicatorEnum.Fre_Deviation.getMessage().concat(limitRate.getFreqDevOvertime() + "次"));
descriptionList.add(SteadyIndicatorEnum.Fre_Deviation.getMessage().concat(limitRate.getFreqDevOvertime() + "次")); // } else {
} else { // limitBoolMap.put(SteadyIndicatorEnum.Fre_Deviation.getCode(), false);
limitBoolMap.put(SteadyIndicatorEnum.Fre_Deviation.getCode(), false); // }
} // break;
break; // case Voltage_Dev://电压偏差
case Voltage_Dev://电压偏差 // if (limitRate.getVoltageDevOvertime() > 0) {
if (limitRate.getVoltageDevOvertime() > 0) { // limitBoolMap.put(SteadyIndicatorEnum.Voltage_Dev.getCode(), true);
limitBoolMap.put(SteadyIndicatorEnum.Voltage_Dev.getCode(), true); // descriptionList.add(SteadyIndicatorEnum.Voltage_Dev.getMessage().concat(limitRate.getVoltageDevOvertime() + "次"));
descriptionList.add(SteadyIndicatorEnum.Voltage_Dev.getMessage().concat(limitRate.getVoltageDevOvertime() + "次")); // } else {
} else { // limitBoolMap.put(SteadyIndicatorEnum.Voltage_Dev.getCode(), false);
limitBoolMap.put(SteadyIndicatorEnum.Voltage_Dev.getCode(), false); // }
} // break;
break; // case Har_Current://谐波电流
case Har_Current://谐波电流 // Integer harCurrentOvertime = this.maxOverTime(limitRate, HarCurrent.class);
Integer harCurrentOvertime = this.maxOverTime(limitRate, HarCurrent.class); // if (harCurrentOvertime > 0) {
if (harCurrentOvertime > 0) { // limitBoolMap.put(SteadyIndicatorEnum.Har_Current.getCode(), true);
limitBoolMap.put(SteadyIndicatorEnum.Har_Current.getCode(), true); // descriptionList.add(SteadyIndicatorEnum.Har_Current.getMessage().concat(harCurrentOvertime + "次"));
descriptionList.add(SteadyIndicatorEnum.Har_Current.getMessage().concat(harCurrentOvertime + "次")); // } else {
} else { // limitBoolMap.put(SteadyIndicatorEnum.Har_Current.getCode(), false);
limitBoolMap.put(SteadyIndicatorEnum.Har_Current.getCode(), false); // }
} // break;
break; // case Voltage_Fluc://电压波动与闪变
case Voltage_Fluc://电压波动与闪变 // if (limitRate.getFlickerOvertime() > 0) {
if (limitRate.getFlickerOvertime() > 0) { // limitBoolMap.put(SteadyIndicatorEnum.Voltage_Fluc.getCode(), true);
limitBoolMap.put(SteadyIndicatorEnum.Voltage_Fluc.getCode(), true); // descriptionList.add(SteadyIndicatorEnum.Voltage_Fluc.getMessage().concat(limitRate.getFlickerOvertime() + "次"));
descriptionList.add(SteadyIndicatorEnum.Voltage_Fluc.getMessage().concat(limitRate.getFlickerOvertime() + "次")); // } else {
} else { // limitBoolMap.put(SteadyIndicatorEnum.Voltage_Fluc.getCode(), false);
limitBoolMap.put(SteadyIndicatorEnum.Voltage_Fluc.getCode(), false); // }
} // break;
break; // case Har_Voltage://谐波电压
case Har_Voltage://谐波电压 // Integer harVoltageOvertime = this.maxOverTime(limitRate, HarVoltage.class);
Integer harVoltageOvertime = this.maxOverTime(limitRate, HarVoltage.class); // if (harVoltageOvertime > 0) {
if (harVoltageOvertime > 0) { // limitBoolMap.put(SteadyIndicatorEnum.Har_Voltage.getCode(), true);
limitBoolMap.put(SteadyIndicatorEnum.Har_Voltage.getCode(), true); // descriptionList.add(SteadyIndicatorEnum.Har_Voltage.getMessage().concat(harVoltageOvertime + "次"));
descriptionList.add(SteadyIndicatorEnum.Har_Voltage.getMessage().concat(harVoltageOvertime + "次")); // } else {
} else { // limitBoolMap.put(SteadyIndicatorEnum.Har_Voltage.getCode(), false);
limitBoolMap.put(SteadyIndicatorEnum.Har_Voltage.getCode(), false); // }
} // break;
break; // }
} // }
} // }
} // });
}); // limitBoolMap.put(DESCRIPTION, descriptionList);
limitBoolMap.put(DESCRIPTION, descriptionList); // return limitBoolMap;
return limitBoolMap; // }
} // return null;
return null; // }
} //
// /***
/*** // * 获取越限最大值
* 获取越限最大值 // * @param object
* @param object // * @param annotation
* @param annotation // * @return
* @return // */
*/ // private Integer maxOverTime(Object object, Class annotation) {
private Integer maxOverTime(Object object, Class annotation) { // Integer maxValue = 0;
Integer maxValue = 0; // try {
try { // Class objClass = object.getClass();
Class objClass = object.getClass(); // Field[] fields = objClass.getDeclaredFields();
Field[] fields = objClass.getDeclaredFields(); // for (Field field : fields) {
for (Field field : fields) { // field.setAccessible(true);
field.setAccessible(true); // boolean isAnon = field.isAnnotationPresent(annotation);
boolean isAnon = field.isAnnotationPresent(annotation); // if (isAnon) {
if (isAnon) { // Object objValue = field.get(object);
Object objValue = field.get(object); // if (objValue instanceof Integer) {
if (objValue instanceof Integer) { // if ((Integer) objValue > maxValue) {
if ((Integer) objValue > maxValue) { // maxValue = (Integer) objValue;
maxValue = (Integer) objValue; // }
} // }
} // }
} // }
} // } catch (Exception e) {
} catch (Exception e) { // log.error("获取越限最大值异常：{}", e.toString());
log.error("获取越限最大值异常：{}", e.toString()); // }
} // return maxValue;
return maxValue; // }
} //}
}

198
pqs-prepare/prepare-boot/src/main/java/com/njcn/prepare/harmonic/service/mysql/line/ThsSuperviseService.java
View File

@@ -1,99 +1,99 @@
package com.njcn.prepare.harmonic.service.mysql.line; //package com.njcn.prepare.harmonic.service.mysql.line;
//
import com.baomidou.mybatisplus.extension.service.IService; //import com.baomidou.mybatisplus.extension.service.IService;
import com.njcn.common.pojo.response.HttpResult; //import com.njcn.common.pojo.response.HttpResult;
import com.njcn.device.pms.pojo.po.Monitor; //import com.njcn.device.pms.pojo.po.Monitor;
import com.njcn.harmonic.pojo.po.day.RStatLimitRateDPO; //import com.njcn.harmonic.pojo.po.day.RStatLimitRateDPO;
import com.njcn.harmonic.pojo.vo.SourceSteadyIndicator; //import com.njcn.harmonic.pojo.vo.SourceSteadyIndicator;
import com.njcn.harmonic.pojo.vo.ThsStrategyVo; //import com.njcn.harmonic.pojo.vo.ThsStrategyVo;
import com.njcn.prepare.enums.TypeEnum; //import com.njcn.prepare.enums.TypeEnum;
import com.njcn.prepare.harmonic.pojo.param.SuperviseParam; //import com.njcn.prepare.harmonic.pojo.param.SuperviseParam;
import com.njcn.prepare.harmonic.pojo.po.ThsOverRunLog; //import com.njcn.prepare.harmonic.pojo.po.ThsOverRunLog;
import com.njcn.prepare.harmonic.pojo.po.ThsSupervise; //import com.njcn.prepare.harmonic.pojo.po.ThsSupervise;
import com.njcn.process.pojo.po.ThsWarnStrategyAss; //import com.njcn.process.pojo.po.ThsWarnStrategyAss;
import com.njcn.user.pojo.po.Dept; //import com.njcn.user.pojo.po.Dept;
//
import java.util.List; //import java.util.List;
import java.util.Map; //import java.util.Map;
//
/** ///**
* <p> // * <p>
* 服务类 // * 服务类
* </p> // * </p>
* // *
* @author lxp // * @author lxp
* @since 2023-03-16 // * @since 2023-03-16
*/ // */
public interface ThsSuperviseService extends IService<ThsSupervise> { //public interface ThsSuperviseService extends IService<ThsSupervise> {
/** // /**
* 初始化技术监督 // * 初始化技术监督
*/ // */
HttpResult<String> initSupervise(SuperviseParam superviseParam); // HttpResult<String> initSupervise(SuperviseParam superviseParam);
//
/** // /**
* 查新策略集合 // * 查新策略集合
* // *
* @param superviseParam // * @param superviseParam
* @return // * @return
*/ // */
List<ThsStrategyVo> selectStrategyList(SuperviseParam superviseParam); // List<ThsStrategyVo> selectStrategyList(SuperviseParam superviseParam);
//
/** // /**
* 查询LimitTarget数据 // * 查询LimitTarget数据
* // *
* @param monitorId // * @param monitorId
*/ // */
RStatLimitRateDPO queryLimitTargetData(String monitorId); // RStatLimitRateDPO queryLimitTargetData(String monitorId);
//
/** // /**
* 生成监督数据 // * 生成监督数据
* // *
* @param limitBoolMap // * @param limitBoolMap
*/ // */
void buildData(SourceSteadyIndicator steady, Map<String, Object> limitBoolMap, Monitor monitor, RStatLimitRateDPO limitRate, Integer initType, ThsSupervise thsSupervise, List<ThsOverRunLog> thsOverRunLogs); // void buildData(SourceSteadyIndicator steady, Map<String, Object> limitBoolMap, Monitor monitor, RStatLimitRateDPO limitRate, Integer initType, ThsSupervise thsSupervise, List<ThsOverRunLog> thsOverRunLogs);
//
/** // /**
* 查询策略绑定的干扰源列表或指标参数列表 // * 查询策略绑定的干扰源列表或指标参数列表
* // *
* @param id // * @param id
* @param typeEnum // * @param typeEnum
* @return // * @return
*/ // */
List<ThsWarnStrategyAss> queryWarnStrategyAss(String id, TypeEnum typeEnum); // List<ThsWarnStrategyAss> queryWarnStrategyAss(String id, TypeEnum typeEnum);
//
/** // /**
* 生成监督数据 // * 生成监督数据
* // *
* @param steady // * @param steady
* @param monitor // * @param monitor
* @return // * @return
*/ // */
void buildSuperviseData(SourceSteadyIndicator steady, Monitor monitor, RStatLimitRateDPO limitRate, Map<String, Object> limitBoolMap, Integer initType, ThsSupervise thsSupervise, List<ThsOverRunLog> thsOverRunLogs); // void buildSuperviseData(SourceSteadyIndicator steady, Monitor monitor, RStatLimitRateDPO limitRate, Map<String, Object> limitBoolMap, Integer initType, ThsSupervise thsSupervise, List<ThsOverRunLog> thsOverRunLogs);
//
/** // /**
* 生成 告警/预警监测点列表 数据 // * 生成 告警/预警监测点列表 数据
* // *
* @param steady // * @param steady
* @param thsSupervise // * @param thsSupervise
* @param monitor // * @param monitor
*/ // */
void buildOverRunLog(SourceSteadyIndicator steady, ThsSupervise thsSupervise, Monitor monitor, RStatLimitRateDPO limitRate, Map<String, Object> limitBoolMap, Integer initType, List<ThsOverRunLog> thsOverRunLogs); // void buildOverRunLog(SourceSteadyIndicator steady, ThsSupervise thsSupervise, Monitor monitor, RStatLimitRateDPO limitRate, Map<String, Object> limitBoolMap, Integer initType, List<ThsOverRunLog> thsOverRunLogs);
//
//
/** // /**
* 生成技术监督数据 // * 生成技术监督数据
* // *
* @param thsSupervise // * @param thsSupervise
* @param overRunLogList // * @param overRunLogList
*/ // */
void creatData(Dept dept, ThsSupervise thsSupervise, List<ThsOverRunLog> overRunLogList); // void creatData(Dept dept, ThsSupervise thsSupervise, List<ThsOverRunLog> overRunLogList);
//
/** // /**
* 创建技术监督 // * 创建技术监督
* // *
* @param superviseParam // * @param superviseParam
* @return // * @return
*/ // */
//
void creatSupervise(SuperviseParam superviseParam); // void creatSupervise(SuperviseParam superviseParam);
} //}