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.pojo.dto.*;
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.PqsDeviceUnit;
import io.swagger.annotations.ApiImplicitParam;
@@ -181,11 +182,17 @@ public interface CommTerminalGeneralClient {
@GetMapping("/getCustomDetailByLineId")
HttpResult<Map<String,String>> getCustomDetailByLineId(@RequestParam("id") String id);
/**
* pms获取指定单位下面的母线以及母线下面的监测点信息
* @author cdf
* @date 2024/1/26
*/
@GetMapping("/getBusBarAndHisMonitor")
HttpResult<List<BusBarAndHisMonitorDTO>> getBusBarAndHisMonitor();
@PostMapping("/tagOrIdGetMonitorList")
HttpResult<List<CommMonitorInfoDTO>> tagOrIdGetMonitorList(@RequestBody MonitorGetParam monitorGetParam);
/**
* 用于返回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.pojo.dto.*;
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.PqsDeviceUnit;
import com.njcn.device.biz.utils.DeviceEnumUtil;
@@ -151,7 +152,14 @@ public class CommTerminalGeneralClientFallbackFactory implements FallbackFactory
@Override
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

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.*;
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.PqsDeviceUnit;
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系统
* @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.*;
import com.njcn.device.biz.pojo.param.DeptGetLineParam;
import com.njcn.device.pms.pojo.po.Monitor;
import org.springframework.web.bind.annotation.RequestParam;
import java.util.List;
@@ -109,6 +110,9 @@ public interface CommTerminalService {
List<BusBarAndHisMonitorDTO> getBusBarAndHisMonitor();
List<CommMonitorInfoDTO> tagOrIdGetMonitorList(List<String> tagList,List<String> monitorIds,List<String> deptIds);
/**
* 根据部门获取各变电站信息
* @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.enums.DicDataEnum;
import com.njcn.system.enums.DicDataTypeEnum;
import com.njcn.system.pojo.po.Dic;
import com.njcn.system.pojo.po.DictData;
import com.njcn.user.api.DeptFeignClient;
import com.njcn.user.pojo.dto.DeptDTO;
import com.njcn.user.pojo.po.Dept;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
@@ -790,6 +792,23 @@ public class CommTerminalServiceImpl implements CommTerminalService {
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
public List<DeptGetSubStationDTO.Info> deptSubStationInfo(DeptGetLineParam deptGetLineParam) {
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
* @version 1.0.0
* @createTime 2022/5/7 10:41
@@ -14,6 +14,7 @@ import org.influxdb.annotation.Measurement;
@Data
@Measurement(name = "limit_rate")
@EqualsAndHashCode(callSuper = true)
@Deprecated
public class LimitRate extends LimitTarget{

69
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.fasterxml.jackson.annotation.JsonFormat;
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.Data;
import lombok.NoArgsConstructor;
@@ -88,288 +91,336 @@ public class RStatLimitRateDPO {
/**
* 2次电压谐波含有率越限次数
*/
@HarVoltage
@TableField(value = "uharm_2_overtime")
private Integer uharm2Overtime;
/**
* 3次电压谐波含有率越限次数
*/
@HarVoltage
@TableField(value = "uharm_3_overtime")
private Integer uharm3Overtime;
/**
* 4次电压谐波含有率越限次数
*/
@HarVoltage
@TableField(value = "uharm_4_overtime")
private Integer uharm4Overtime;
/**
* 5次电压谐波含有率越限次数
*/
@HarVoltage
@TableField(value = "uharm_5_overtime")
private Integer uharm5Overtime;
/**
* 6次电压谐波含有率越限次数
*/
@HarVoltage
@TableField(value = "uharm_6_overtime")
private Integer uharm6Overtime;
/**
* 7次电压谐波含有率越限次数
*/
@HarVoltage
@TableField(value = "uharm_7_overtime")
private Integer uharm7Overtime;
/**
* 8次电压谐波含有率越限次数
*/
@HarVoltage
@TableField(value = "uharm_8_overtime")
private Integer uharm8Overtime;
/**
* 9次电压谐波含有率越限次数
*/
@HarVoltage
@TableField(value = "uharm_9_overtime")
private Integer uharm9Overtime;
/**
* 10次电压谐波含有率越限次数
*/
@HarVoltage
@TableField(value = "uharm_10_overtime")
private Integer uharm10Overtime;
/**
* 11次电压谐波含有率越限次数
*/
@HarVoltage
@TableField(value = "uharm_11_overtime")
private Integer uharm11Overtime;
/**
* 12次电压谐波含有率越限次数
*/
@HarVoltage
@TableField(value = "uharm_12_overtime")
private Integer uharm12Overtime;
/**
* 13次电压谐波含有率越限次数
*/
@HarVoltage
@TableField(value = "uharm_13_overtime")
private Integer uharm13Overtime;
/**
* 14次电压谐波含有率越限次数
*/
@HarVoltage
@TableField(value = "uharm_14_overtime")
private Integer uharm14Overtime;
/**
* 15次电压谐波含有率越限次数
*/
@HarVoltage
@TableField(value = "uharm_15_overtime")
private Integer uharm15Overtime;
/**
* 16次电压谐波含有率越限次数
*/
@HarVoltage
@TableField(value = "uharm_16_overtime")
private Integer uharm16Overtime;
/**
* 17次电压谐波含有率越限次数
*/
@HarVoltage
@TableField(value = "uharm_17_overtime")
private Integer uharm17Overtime;
/**
* 18次电压谐波含有率越限次数
*/
@HarVoltage
@TableField(value = "uharm_18_overtime")
private Integer uharm18Overtime;
/**
* 19次电压谐波含有率越限次数
*/
@HarVoltage
@TableField(value = "uharm_19_overtime")
private Integer uharm19Overtime;
/**
* 20次电压谐波含有率越限次数
*/
@HarVoltage
@TableField(value = "uharm_20_overtime")
private Integer uharm20Overtime;
/**
* 21次电压谐波含有率越限次数
*/
@HarVoltage
@TableField(value = "uharm_21_overtime")
private Integer uharm21Overtime;
/**
* 22次电压谐波含有率越限次数
*/
@HarVoltage
@TableField(value = "uharm_22_overtime")
private Integer uharm22Overtime;
/**
* 23次电压谐波含有率越限次数
*/
@HarVoltage
@TableField(value = "uharm_23_overtime")
private Integer uharm23Overtime;
/**
* 24次电压谐波含有率越限次数
*/
@HarVoltage
@TableField(value = "uharm_24_overtime")
private Integer uharm24Overtime;
/**
* 25次电压谐波含有率越限次数
*/
@HarVoltage
@TableField(value = "uharm_25_overtime")
private Integer uharm25Overtime;
/**
* 2次电流谐波幅值越限次数
*/
@HarCurrent
@TableField(value = "iharm_2_overtime")
private Integer iharm2Overtime;
/**
* 3次电流谐波幅值越限次数
*/
@HarCurrent
@TableField(value = "iharm_3_overtime")
private Integer iharm3Overtime;
/**
* 4次电流谐波幅值越限次数
*/
@HarCurrent
@TableField(value = "iharm_4_overtime")
private Integer iharm4Overtime;
/**
* 5次电流谐波幅值越限次数
*/
@HarCurrent
@TableField(value = "iharm_5_overtime")
private Integer iharm5Overtime;
/**
* 6次电流谐波幅值越限次数
*/
@HarCurrent
@TableField(value = "iharm_6_overtime")
private Integer iharm6Overtime;
/**
* 7次电流谐波幅值越限次数
*/
@HarCurrent
@TableField(value = "iharm_7_overtime")
private Integer iharm7Overtime;
/**
* 8次电流谐波幅值越限次数
*/
@HarCurrent
@TableField(value = "iharm_8_overtime")
private Integer iharm8Overtime;
/**
* 9次电流谐波幅值越限次数
*/
@HarCurrent
@TableField(value = "iharm_9_overtime")
private Integer iharm9Overtime;
/**
* 10次电流谐波幅值越限次数
*/
@HarCurrent
@TableField(value = "iharm_10_overtime")
private Integer iharm10Overtime;
/**
* 11次电流谐波幅值越限次数
*/
@HarCurrent
@TableField(value = "iharm_11_overtime")
private Integer iharm11Overtime;
/**
* 12次电流谐波幅值越限次数
*/
@HarCurrent
@TableField(value = "iharm_12_overtime")
private Integer iharm12Overtime;
/**
* 13次电流谐波幅值越限次数
*/
@HarCurrent
@TableField(value = "iharm_13_overtime")
private Integer iharm13Overtime;
/**
* 14次电流谐波幅值越限次数
*/
@HarCurrent
@TableField(value = "iharm_14_overtime")
private Integer iharm14Overtime;
/**
* 15次电流谐波幅值越限次数
*/
@HarCurrent
@TableField(value = "iharm_15_overtime")
private Integer iharm15Overtime;
/**
* 16次电流谐波幅值越限次数
*/
@HarCurrent
@TableField(value = "iharm_16_overtime")
private Integer iharm16Overtime;
/**
* 17次电流谐波幅值越限次数
*/
@HarCurrent
@TableField(value = "iharm_17_overtime")
private Integer iharm17Overtime;
/**
* 18次电流谐波幅值越限次数
*/
@HarCurrent
@TableField(value = "iharm_18_overtime")
private Integer iharm18Overtime;
/**
* 19次电流谐波幅值越限次数
*/
@HarCurrent
@TableField(value = "iharm_19_overtime")
private Integer iharm19Overtime;
/**
* 20次电流谐波幅值越限次数
*/
@HarCurrent
@TableField(value = "iharm_20_overtime")
private Integer iharm20Overtime;
/**
* 21次电流谐波幅值越限次数
*/
@HarCurrent
@TableField(value = "iharm_21_overtime")
private Integer iharm21Overtime;
/**
* 22次电流谐波幅值越限次数
*/
@HarCurrent
@TableField(value = "iharm_22_overtime")
private Integer iharm22Overtime;
/**
* 23次电流谐波幅值越限次数
*/
@HarCurrent
@TableField(value = "iharm_23_overtime")
private Integer iharm23Overtime;
/**
* 24次电流谐波幅值越限次数
*/
@HarCurrent
@TableField(value = "iharm_24_overtime")
private Integer iharm24Overtime;
/**
* 25次电流谐波幅值越限次数
*/
@HarCurrent
@TableField(value = "iharm_25_overtime")
private Integer iharm25Overtime;
@@ -377,95 +428,111 @@ public class RStatLimitRateDPO {
* 0.5次间谐波电压限值次数
*/
@TableField(value = "inuharm_1_overtime")
@InterharVoltage
private Integer inuharm1Overtime;
/**
* 1.5次间谐波电压限值次数
*/
@InterharVoltage
@TableField(value = "inuharm_2_overtime")
private Integer inuharm2Overtime;
/**
* 2.5次间谐波电压限值次数
*/
@InterharVoltage
@TableField(value = "inuharm_3_overtime")
private Integer inuharm3Overtime;
/**
* 3.5次间谐波电压限值次数
*/
@InterharVoltage
@TableField(value = "inuharm_4_overtime")
private Integer inuharm4Overtime;
/**
* 4.5次间谐波电压限值次数
*/
@InterharVoltage
@TableField(value = "inuharm_5_overtime")
private Integer inuharm5Overtime;
/**
* 5.5次间谐波电压限值次数
*/
@InterharVoltage
@TableField(value = "inuharm_6_overtime")
private Integer inuharm6Overtime;
/**
* 6.5次间谐波电压限值次数
*/
@InterharVoltage
@TableField(value = "inuharm_7_overtime")
private Integer inuharm7Overtime;
/**
* 7.5次间谐波电压限值次数
*/
@InterharVoltage
@TableField(value = "inuharm_8_overtime")
private Integer inuharm8Overtime;
/**
* 8.5次间谐波电压限值次数
*/
@InterharVoltage
@TableField(value = "inuharm_9_overtime")
private Integer inuharm9Overtime;
/**
* 9.5次间谐波电压限值次数
*/
@InterharVoltage
@TableField(value = "inuharm_10_overtime")
private Integer inuharm10Overtime;
/**
* 10.5次间谐波电压限值次数
*/
@InterharVoltage
@TableField(value = "inuharm_11_overtime")
private Integer inuharm11Overtime;
/**
* 11.5次间谐波电压限值次数
*/
@InterharVoltage
@TableField(value = "inuharm_12_overtime")
private Integer inuharm12Overtime;
/**
* 12.5次间谐波电压限值次数
*/
@InterharVoltage
@TableField(value = "inuharm_13_overtime")
private Integer inuharm13Overtime;
/**
* 13.5次间谐波电压限值次数
*/
@InterharVoltage
@TableField(value = "inuharm_14_overtime")
private Integer inuharm14Overtime;
/**
* 14.5次间谐波电压限值次数
*/
@InterharVoltage
@TableField(value = "inuharm_15_overtime")
private Integer inuharm15Overtime;
/**
* 15.5次间谐波电压限值次数
*/
@InterharVoltage
@TableField(value = "inuharm_16_overtime")
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：告警）
*/
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;
import com.njcn.common.pojo.enums.response.CommonResponseEnum;
import com.njcn.common.pojo.response.HttpResult;
import com.njcn.common.utils.HttpResultUtil;
import com.njcn.prepare.harmonic.pojo.param.SuperviseParam;
import com.njcn.prepare.harmonic.service.mysql.line.ThsSuperviseService;
import com.njcn.web.controller.BaseController;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
/**
* <p>
* 前端控制器
* </p>
*
* @author lxp
* @since 2023-03-16
*/
@Api(tags = "预警-告警技术监督")
@RestController
@RequestMapping("/thsSupervise")
public class ThsSuperviseController extends BaseController {
@Autowired
private ThsSuperviseService thsSuperviseService;
@ApiOperation("预警/告警事务手动初始化")
@ApiImplicitParam(name = "superviseParam", value = "新建技术监督参数", required = true)
@PostMapping("/initSupervise")
@ResponseBody
public HttpResult<String> initSupervise(@RequestBody @Validated SuperviseParam superviseParam) {
return thsSuperviseService.initSupervise(superviseParam);
}
@ApiOperation("预警/告警事务自动生成")
@ApiImplicitParam(name = "superviseParam", value = "创建技术监督参数", required = true)
@PostMapping("/creatSupervise")
@ResponseBody
public HttpResult<String> creatSupervise(@RequestBody @Validated SuperviseParam superviseParam) {
String methodDescribe = getMethodDescribe("creatSupervise");
thsSuperviseService.creatSupervise(superviseParam);
return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, null, methodDescribe);
}
}
//package com.njcn.prepare.harmonic.controller.line;
//
//
//import com.njcn.common.pojo.enums.response.CommonResponseEnum;
//import com.njcn.common.pojo.response.HttpResult;
//import com.njcn.common.utils.HttpResultUtil;
//import com.njcn.prepare.harmonic.pojo.param.SuperviseParam;
//
//import com.njcn.web.controller.BaseController;
//import io.swagger.annotations.Api;
//import io.swagger.annotations.ApiImplicitParam;
//import io.swagger.annotations.ApiOperation;
//import org.springframework.beans.factory.annotation.Autowired;
//import org.springframework.validation.annotation.Validated;
//import org.springframework.web.bind.annotation.*;
//
///**
// * <p>
// * 前端控制器
// * </p>
// *
// * @author lxp
// * @since 2023-03-16
// */
//@Api(tags = "预警-告警技术监督")
//@RestController
//@RequestMapping("/thsSupervise")
//public class ThsSuperviseController extends BaseController {
// @Autowired
// private ThsSuperviseService thsSuperviseService;
//
// @ApiOperation("预警/告警事务手动初始化")
// @ApiImplicitParam(name = "superviseParam", value = "新建技术监督参数", required = true)
// @PostMapping("/initSupervise")
// @ResponseBody
// public HttpResult<String> initSupervise(@RequestBody @Validated SuperviseParam superviseParam) {
// return thsSuperviseService.initSupervise(superviseParam);
// }
//
//
// @ApiOperation("预警/告警事务自动生成")
// @ApiImplicitParam(name = "superviseParam", value = "创建技术监督参数", required = true)
// @PostMapping("/creatSupervise")
// @ResponseBody
// public HttpResult<String> creatSupervise(@RequestBody @Validated SuperviseParam superviseParam) {
// String methodDescribe = getMethodDescribe("creatSupervise");
// thsSuperviseService.creatSupervise(superviseParam);
// 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;
import cn.hutool.core.collection.CollectionUtil;
import cn.hutool.core.date.DateUtil;
import cn.hutool.core.util.IdUtil;
import com.alibaba.fastjson.JSON;
import com.baomidou.dynamic.datasource.annotation.DS;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.njcn.common.pojo.enums.response.CommonResponseEnum;
import com.njcn.common.pojo.response.HttpResult;
import com.njcn.common.utils.HttpResultUtil;
import com.njcn.device.pms.pojo.po.Monitor;
import com.njcn.harmonic.pojo.po.day.RStatLimitRateDPO;
import com.njcn.harmonic.pojo.vo.SourceSteadyIndicator;
import com.njcn.harmonic.pojo.vo.ThsStrategyVo;
import com.njcn.oss.utils.FileStorageUtil;
import com.njcn.prepare.enums.*;
import com.njcn.prepare.harmonic.mapper.mysql.line.*;
import com.njcn.prepare.harmonic.pojo.param.SuperviseParam;
import com.njcn.prepare.harmonic.pojo.po.ThsOverRunLog;
import com.njcn.prepare.harmonic.pojo.po.ThsSupervise;
import com.njcn.prepare.harmonic.pojo.vo.SuperviceRunLogVo;
import com.njcn.prepare.harmonic.service.mysql.day.IRStatLimitRateDService;
import com.njcn.prepare.harmonic.service.mysql.line.ThsSuperviseService;
import com.njcn.process.annotaion.HarCurrent;
import com.njcn.process.annotaion.HarVoltage;
import com.njcn.process.annotaion.InterharVoltage;
import com.njcn.process.api.FlowableDefineFeignClient;
import com.njcn.process.pojo.po.ThsWarnStrategyAss;
import com.njcn.system.api.DicDataFeignClient;
import com.njcn.system.pojo.po.DictData;
import com.njcn.user.api.DeptFeignClient;
import com.njcn.user.pojo.po.Dept;
import com.njcn.web.utils.RequestUtil;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections.map.HashedMap;
import org.apache.commons.lang.StringUtils;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.lang.reflect.Field;
import java.time.Instant;
import java.time.LocalDate;
import java.time.LocalTime;
import java.time.ZoneId;
import java.util.*;
import java.util.stream.Collectors;
/**
* <p>
* 服务实现类
* </p>
*
* @author lxp
* @since 2023-03-16
*/
@Service
@Slf4j
@RequiredArgsConstructor
public class ThsSuperviseServiceImpl extends ServiceImpl<ThsSuperviseMapper, ThsSupervise> implements ThsSuperviseService {
private final ThsWarnStrategyMapper thsWarnStrategyMapper;
private final ThsWarnStrategyAssMapper thsWarnStrategyAssMapper;
private final PmsMonitorMapper pmsMonitorMapper;
private final IRStatLimitRateDService rateDService;
private final DicDataFeignClient dicDataFeignClient;
private final ThsSuperviseMapper thsSuperviseMapper;
private final ThsOverRunLogMapper thsOverRunLogMapper;
private final DeptFeignClient deptFeignClient;
private final FileStorageUtil fileStorageUtil;
private static final String DESCRIPTION = "description";
private final FlowableDefineFeignClient flowableDefineFeignClient;
@Override
@Async("asyncExecutor")
public void creatSupervise(SuperviseParam superviseParam) {
this.initSupervise(superviseParam);
}
@Override
public HttpResult<String> initSupervise(SuperviseParam superviseParam) {
SuperviceRunLogVo superviceRunLogVo = new SuperviceRunLogVo();
List<ThsOverRunLog> overRunLogList = new ArrayList<>();
if (InitTypeEnum.MANUAL.getCode().equals(superviseParam.getInitType()) && StringUtils.isBlank(superviseParam.getDeptId())) {
return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.INVALID_PARAMETER, null, "");
}
List<ThsStrategyVo> thsStrategyList = this.selectStrategyList(superviseParam);
//按部门进行分组
if (CollectionUtil.isNotEmpty(thsStrategyList)) {
Map<String, List<ThsStrategyVo>> deptMap = thsStrategyList.stream().collect(Collectors.groupingBy(ThsStrategyVo::getDeptId));
for (Map.Entry<String, List<ThsStrategyVo>> entry : deptMap.entrySet()) {
String depId = entry.getKey();
ThsSupervise thsSupervise = new ThsSupervise();
List<ThsStrategyVo> deptList = entry.getValue();
List<ThsStrategyVo> oneLevel = deptList.stream().filter(r -> !GradeEnum.THREE_LEVEL.getCode().equals(r.getGrade())).collect(Collectors.toList());//一级或二级策略集合
List<SourceSteadyIndicator> oneSourceSteadyIndicatorList = new ArrayList<>();
if (CollectionUtil.isNotEmpty(oneLevel)) {
for (ThsStrategyVo oneStrategyVo : oneLevel) {
List<ThsWarnStrategyAss> oneInterferenceSourceAsses = this.queryWarnStrategyAss(oneStrategyVo.getId(), TypeEnum.SOURCE_TYPE);//干扰源列表
List<ThsWarnStrategyAss> oneSteadyIndicatorAsses = this.queryWarnStrategyAss(oneStrategyVo.getId(), TypeEnum.INTERFERENCE_TYPE);//干扰源列表
List<String> oneSteadyIndicatorAssesIds = oneSteadyIndicatorAsses.stream().map(ThsWarnStrategyAss::getAssId).collect(Collectors.toList());
//封装每一种干扰源和对应的指标
for (ThsWarnStrategyAss oneWarnStrategyAss : oneInterferenceSourceAsses) {
SourceSteadyIndicator build = SourceSteadyIndicator.builder().id(oneStrategyVo.getId()).operation(oneStrategyVo.getOperation())
.interferenceSource(oneWarnStrategyAss.getAssId())
.steadyIndicator(oneSteadyIndicatorAssesIds)
.deptId(oneStrategyVo.getDeptId())
.type(oneStrategyVo.getType())
.monitorId(oneStrategyVo.getMonitorId())
.build();
oneSourceSteadyIndicatorList.add(build);
}
}
}
List<ThsStrategyVo> threeLevel = deptList.stream().filter(r -> GradeEnum.THREE_LEVEL.getCode().equals(r.getGrade())).collect(Collectors.toList());//三级策略集合
if (CollectionUtil.isNotEmpty(threeLevel)) {
for (ThsStrategyVo threeStrategyVo : threeLevel) {
Iterator<SourceSteadyIndicator> iterator = oneSourceSteadyIndicatorList.iterator();
while (iterator.hasNext()) {
SourceSteadyIndicator sourceSteady = iterator.next();
if (sourceSteady.getType().equals(threeStrategyVo.getType())) {
if (StringUtils.equals(threeStrategyVo.getMonitorId(), sourceSteady.getMonitorId())) {
List<ThsWarnStrategyAss> interferenceSourceAsses = this.queryWarnStrategyAss(threeStrategyVo.getId(), TypeEnum.SOURCE_TYPE);
//干扰源类型id
List<String> threeInterferenceSourceIds = interferenceSourceAsses.stream().map(ThsWarnStrategyAss::getAssId).collect(Collectors.toList());
List<ThsWarnStrategyAss> threeSteadyIndicatorAsses = this.queryWarnStrategyAss(threeStrategyVo.getId(), TypeEnum.INTERFERENCE_TYPE);
//指标类型id
List<String> steadyIndicatorIds = threeSteadyIndicatorAsses.stream().map(ThsWarnStrategyAss::getAssId).collect(Collectors.toList());
for (String threeInterferenceSourceId : threeInterferenceSourceIds) {
if (OperationEnum.AND.getCode().equals(threeStrategyVo.getOperation())) {//处理三级策略的与
if (OperationEnum.AND.getCode().equals(sourceSteady.getOperation())) {
if (StringUtils.equals(threeInterferenceSourceId, sourceSteady.getInterferenceSource()) &&
steadyIndicatorIds.containsAll(sourceSteady.getSteadyIndicator())) {
iterator.remove();
}
}
} else {//处理三级策略的或
if (StringUtils.equals(threeInterferenceSourceId, sourceSteady.getInterferenceSource())) {
if (steadyIndicatorIds.containsAll(sourceSteady.getSteadyIndicator())) {
iterator.remove();
} else {
List<String> steadyIndicator = sourceSteady.getSteadyIndicator();
steadyIndicator.removeAll(steadyIndicatorIds);
}
}
}
}
}
}
}
}
}
if (CollectionUtil.isNotEmpty(oneSourceSteadyIndicatorList)) {
oneSourceSteadyIndicatorList.forEach(steady -> {
Monitor monitor = pmsMonitorMapper.selectById(steady.getMonitorId());
if (monitor != null) {
if (StringUtils.equals(monitor.getMonitorTag(), steady.getInterferenceSource())) {//匹配该监测点属于的干扰源类型
//查询该监测点的检测数据
RStatLimitRateDPO limitRate = this.queryLimitTargetData(monitor.getId());
//判断指标是否超标
Map<String, Object> limitBoolMap = this.verifyLimit(limitRate, steady);
//构建监督数据
this.buildData(steady, limitBoolMap, monitor, limitRate, superviseParam.getInitType(), thsSupervise, overRunLogList);
}
}
});
//生成技术监督数据
HttpResult<Dept> deptById = deptFeignClient.getDeptById(depId);
Dept dept = deptById.getData();
if (InitTypeEnum.AUTO.getCode().equals(superviseParam.getInitType())) {
this.creatData(dept, thsSupervise, overRunLogList);
} else {
this.buildSuperviseName(thsSupervise, overRunLogList, dept);
superviceRunLogVo.setOverRunLog(overRunLogList);
superviceRunLogVo.setThsSupervise(thsSupervise);
}
}
}
}
return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, JSON.toJSONString(superviceRunLogVo), "");
}
/**
* 构建技术监督名称
*
* @param thsSupervise
* @param overRunLogList
* @param dept
*/
private void buildSuperviseName(ThsSupervise thsSupervise, List<ThsOverRunLog> overRunLogList, Dept dept) {
if (CollectionUtil.isNotEmpty(overRunLogList)) {
thsSupervise.setDescription(overRunLogList.get(0).getDescription());
String str = Arrays.asList(overRunLogList.get(0).getDescription().split(",")).get(0);
String overItem = str.substring(0, str.indexOf("次") - 1);
thsSupervise.setName(DateUtil.today() + dept.getName() + overRunLogList.get(0).getName() + "等" + overRunLogList.size() + "个监测点" + overItem);
}
}
//生成技术监督数据
@DS("process")
@Transactional(rollbackFor = Exception.class)
@Override
public void creatData(Dept dept, ThsSupervise thsSupervise, List<ThsOverRunLog> overRunLogList) {
if (CollectionUtil.isNotEmpty(overRunLogList)) {
thsSupervise.setDescription(overRunLogList.get(0).getDescription());
String str = Arrays.asList(overRunLogList.get(0).getDescription().split(",")).get(0);
String overItem = str.substring(0, str.indexOf("次") - 1);
thsSupervise.setName(DateUtil.today() + dept.getName() + overRunLogList.get(0).getName() + "等" + overRunLogList.size() + "个监测点" + overItem);
thsSuperviseMapper.insert(thsSupervise);
//TODO 解决工作流写死问题
Map<String, Object> mapParam = new HashMap<>();
String proInId ="";
if(thsSupervise.getType() == 0){
proInId = "flow_yzep99kb:1:a100b48b-da75-11ed-8335-b07b253cdad9";
}else {
proInId = "flow_yzep99kb:2:6358e099-dcba-11ed-8026-b07b253cdad9";
}
flowableDefineFeignClient.start(proInId,thsSupervise.getSupIndex(),mapParam);
for (ThsOverRunLog thsOverRunLog : overRunLogList) {
thsOverRunLogMapper.insert(thsOverRunLog);
}
}
}
/**
* 查询策略列表
*
* @param superviseParam
* @return
*/
@DS("process")
@Override
public List<ThsStrategyVo> selectStrategyList(SuperviseParam superviseParam) {
return thsWarnStrategyMapper.selectStrategyList(superviseParam);
}
/**
* 查询策略绑定的干扰源列表或指标参数列表
*
* @param warnId
* @param typeEnum
* @return
*/
@DS("process")
@Override
public List<ThsWarnStrategyAss> queryWarnStrategyAss(String warnId, TypeEnum typeEnum) {
return thsWarnStrategyAssMapper.selectList(new LambdaQueryWrapper<ThsWarnStrategyAss>()
.eq(ThsWarnStrategyAss::getWarnId, warnId)
.eq(ThsWarnStrategyAss::getType, typeEnum.getCode()));
}
/**
* 生成监督数据
*
* @param limitBoolMap
*/
@Override
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 (OperationEnum.AND.getCode().equals(steady.getOperation())) {
for (Map.Entry<String, Object> entry : limitBoolMap.entrySet()) {
if (entry.getValue() instanceof Boolean && !(boolean) entry.getValue()) {
return;
}
}
//构建监督数据
this.buildSuperviseData(steady, monitor, limitRate, limitBoolMap, initType, thsSupervise, thsOverRunLogs);
//构建告警/预警监测点列表数据
this.buildOverRunLog(steady, thsSupervise, monitor, limitRate, limitBoolMap, initType, thsOverRunLogs);
return;
}
if (OperationEnum.OR.getCode().equals(steady.getOperation())) {
for (Map.Entry<String, Object> entry : limitBoolMap.entrySet()) {
if (entry.getValue() instanceof Boolean && (boolean) entry.getValue()) {
//生成监督数据
this.buildSuperviseData(steady, monitor, limitRate, limitBoolMap, initType, thsSupervise, thsOverRunLogs);
//生成告警/预警监测点数据
this.buildOverRunLog(steady, thsSupervise, monitor, limitRate, limitBoolMap, initType, thsOverRunLogs);
return;
}
}
}
}
}
@Override
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())) {
thsSupervise.setSupIndex(IdUtil.simpleUUID());
thsSupervise.setDeptId(steady.getDeptId());
thsSupervise.setCreateTime(new Date());
thsSupervise.setType(steady.getType());
thsSupervise.setCreateUser(RequestUtil.getUsername());
thsSupervise.setProgress(ProgressEnum.START.getCode());
thsSupervise.setCreateType(initType);
}
}
@Override
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.setId(IdUtil.simpleUUID());
thsOverRunLog.setSupIndex(thsSupervise.getSupIndex());
thsOverRunLog.setLineIndex(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.setCreateTime(new Date());
List<String> descriptionList = (List) limitBoolMap.get(DESCRIPTION);
thsOverRunLog.setDescription(StringUtils.join(descriptionList, ","));
thsOverRunLogs.add(thsOverRunLog);
}
@Override
@DS("pms")
public RStatLimitRateDPO queryLimitTargetData(String monitorId) {
RStatLimitRateDPO limitRate = rateDService.getOne(new LambdaQueryWrapper<RStatLimitRateDPO>().eq(RStatLimitRateDPO::getLineId, monitorId)
.between(RStatLimitRateDPO::getTime,
DateUtil.beginOfDay(DateUtil.offsetDay(new Date(), -1)),
DateUtil.endOfDay(DateUtil.offsetDay(new Date(), -1))).last("limit 1"));
return limitRate;
}
/**
* 判断监测数据是否超标
*
* @param limitRate
* @param steady
*/
private Map<String, Object> verifyLimit(RStatLimitRateDPO limitRate, SourceSteadyIndicator steady) {
if (limitRate != null) {
List<String> steadyIndicator = steady.getSteadyIndicator();
Map<String, Object> limitBoolMap = new HashedMap();
List<String> descriptionList = new ArrayList<>();
steadyIndicator.forEach(id -> {
HttpResult<DictData> dicDataById = dicDataFeignClient.getDicDataById(id);
if (CommonResponseEnum.SUCCESS.getCode().equals(dicDataById.getCode()) && dicDataById.getData() != null) {
SteadyIndicatorEnum steadyIndicatorEnum = SteadyIndicatorEnum.getSteadyIndicatorEnumByCode(dicDataById.getData().getCode());
if (null != steadyIndicatorEnum) {
switch (steadyIndicatorEnum) {
case Negative_Voltage://负序电压不平衡度
if (limitRate.getUbalanceOvertime() > 0) {
limitBoolMap.put(SteadyIndicatorEnum.Negative_Voltage.getCode(), true);
descriptionList.add(SteadyIndicatorEnum.Negative_Voltage.getMessage().concat(limitRate.getUbalanceOvertime() + "次"));
} else {
limitBoolMap.put(SteadyIndicatorEnum.Negative_Voltage.getCode(), false);
}
break;
case Interhar_Voltage://间谐波电压
Integer interharVoltageOvertime = this.maxOverTime(limitRate, InterharVoltage.class);
if (interharVoltageOvertime > 0) {
limitBoolMap.put(SteadyIndicatorEnum.Interhar_Voltage.getCode(), true);
descriptionList.add(SteadyIndicatorEnum.Interhar_Voltage.getMessage().concat(interharVoltageOvertime + "次"));
} else {
limitBoolMap.put(SteadyIndicatorEnum.Interhar_Voltage.getCode(), false);
}
break;
case Neg_Current://负序电流
if (limitRate.getINegOvertime() > 0) {
limitBoolMap.put(SteadyIndicatorEnum.Neg_Current.getCode(), true);
descriptionList.add(SteadyIndicatorEnum.Neg_Current.getMessage().concat(limitRate.getINegOvertime() + "次"));
} else {
limitBoolMap.put(SteadyIndicatorEnum.Neg_Current.getCode(), false);
}
break;
case Fre_Deviation://频率偏差
if (limitRate.getFreqDevOvertime() > 0) {
limitBoolMap.put(SteadyIndicatorEnum.Fre_Deviation.getCode(), true);
descriptionList.add(SteadyIndicatorEnum.Fre_Deviation.getMessage().concat(limitRate.getFreqDevOvertime() + "次"));
} else {
limitBoolMap.put(SteadyIndicatorEnum.Fre_Deviation.getCode(), false);
}
break;
case Voltage_Dev://电压偏差
if (limitRate.getVoltageDevOvertime() > 0) {
limitBoolMap.put(SteadyIndicatorEnum.Voltage_Dev.getCode(), true);
descriptionList.add(SteadyIndicatorEnum.Voltage_Dev.getMessage().concat(limitRate.getVoltageDevOvertime() + "次"));
} else {
limitBoolMap.put(SteadyIndicatorEnum.Voltage_Dev.getCode(), false);
}
break;
case Har_Current://谐波电流
Integer harCurrentOvertime = this.maxOverTime(limitRate, HarCurrent.class);
if (harCurrentOvertime > 0) {
limitBoolMap.put(SteadyIndicatorEnum.Har_Current.getCode(), true);
descriptionList.add(SteadyIndicatorEnum.Har_Current.getMessage().concat(harCurrentOvertime + "次"));
} else {
limitBoolMap.put(SteadyIndicatorEnum.Har_Current.getCode(), false);
}
break;
case Voltage_Fluc://电压波动与闪变
if (limitRate.getFlickerOvertime() > 0) {
limitBoolMap.put(SteadyIndicatorEnum.Voltage_Fluc.getCode(), true);
descriptionList.add(SteadyIndicatorEnum.Voltage_Fluc.getMessage().concat(limitRate.getFlickerOvertime() + "次"));
} else {
limitBoolMap.put(SteadyIndicatorEnum.Voltage_Fluc.getCode(), false);
}
break;
case Har_Voltage://谐波电压
Integer harVoltageOvertime = this.maxOverTime(limitRate, HarVoltage.class);
if (harVoltageOvertime > 0) {
limitBoolMap.put(SteadyIndicatorEnum.Har_Voltage.getCode(), true);
descriptionList.add(SteadyIndicatorEnum.Har_Voltage.getMessage().concat(harVoltageOvertime + "次"));
} else {
limitBoolMap.put(SteadyIndicatorEnum.Har_Voltage.getCode(), false);
}
break;
}
}
}
});
limitBoolMap.put(DESCRIPTION, descriptionList);
return limitBoolMap;
}
return null;
}
/***
* 获取越限最大值
* @param object
* @param annotation
* @return
*/
private Integer maxOverTime(Object object, Class annotation) {
Integer maxValue = 0;
try {
Class objClass = object.getClass();
Field[] fields = objClass.getDeclaredFields();
for (Field field : fields) {
field.setAccessible(true);
boolean isAnon = field.isAnnotationPresent(annotation);
if (isAnon) {
Object objValue = field.get(object);
if (objValue instanceof Integer) {
if ((Integer) objValue > maxValue) {
maxValue = (Integer) objValue;
}
}
}
}
} catch (Exception e) {
log.error("获取越限最大值异常：{}", e.toString());
}
return maxValue;
}
}
//package com.njcn.prepare.harmonic.service.mysql.Impl.line;
//
//import cn.hutool.core.collection.CollectionUtil;
//import cn.hutool.core.date.DateUtil;
//import cn.hutool.core.util.IdUtil;
//import com.alibaba.fastjson.JSON;
//import com.baomidou.dynamic.datasource.annotation.DS;
//import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
//import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
//import com.njcn.common.pojo.enums.response.CommonResponseEnum;
//import com.njcn.common.pojo.response.HttpResult;
//import com.njcn.common.utils.HttpResultUtil;
//import com.njcn.device.pms.pojo.po.Monitor;
//import com.njcn.harmonic.pojo.po.day.RStatLimitRateDPO;
//import com.njcn.harmonic.pojo.vo.SourceSteadyIndicator;
//import com.njcn.harmonic.pojo.vo.ThsStrategyVo;
//import com.njcn.oss.utils.FileStorageUtil;
//import com.njcn.prepare.enums.*;
//import com.njcn.prepare.harmonic.mapper.mysql.line.*;
//import com.njcn.prepare.harmonic.pojo.param.SuperviseParam;
//import com.njcn.prepare.harmonic.pojo.po.ThsOverRunLog;
//import com.njcn.prepare.harmonic.pojo.po.ThsSupervise;
//import com.njcn.prepare.harmonic.pojo.vo.SuperviceRunLogVo;
//import com.njcn.prepare.harmonic.service.mysql.day.IRStatLimitRateDService;
//import com.njcn.prepare.harmonic.service.mysql.line.ThsSuperviseService;
//import com.njcn.process.annotaion.HarCurrent;
//import com.njcn.process.annotaion.HarVoltage;
//import com.njcn.process.annotaion.InterharVoltage;
//import com.njcn.process.api.FlowableDefineFeignClient;
//import com.njcn.process.pojo.po.ThsWarnStrategyAss;
//import com.njcn.system.api.DicDataFeignClient;
//import com.njcn.system.pojo.po.DictData;
//import com.njcn.user.api.DeptFeignClient;
//import com.njcn.user.pojo.po.Dept;
//import com.njcn.web.utils.RequestUtil;
//import lombok.RequiredArgsConstructor;
//import lombok.extern.slf4j.Slf4j;
//import org.apache.commons.collections.map.HashedMap;
//import org.apache.commons.lang.StringUtils;
//import org.springframework.scheduling.annotation.Async;
//import org.springframework.stereotype.Service;
//import org.springframework.transaction.annotation.Transactional;
//
//import java.lang.reflect.Field;
//import java.time.Instant;
//import java.time.LocalDate;
//import java.time.LocalTime;
//import java.time.ZoneId;
//import java.util.*;
//import java.util.stream.Collectors;
//
///**
// * <p>
// * 服务实现类
// * </p>
// *
// * @author lxp
// * @since 2023-03-16
// */
//@Service
//@Slf4j
//@RequiredArgsConstructor
//public class ThsSuperviseServiceImpl extends ServiceImpl<ThsSuperviseMapper, ThsSupervise> implements ThsSuperviseService {
//
//
//
//
// private final ThsWarnStrategyMapper thsWarnStrategyMapper;
//
// private final ThsWarnStrategyAssMapper thsWarnStrategyAssMapper;
//
// private final PmsMonitorMapper pmsMonitorMapper;
//
// private final IRStatLimitRateDService rateDService;
//
// private final DicDataFeignClient dicDataFeignClient;
//
// private final ThsSuperviseMapper thsSuperviseMapper;
//
// private final ThsOverRunLogMapper thsOverRunLogMapper;
//
// private final DeptFeignClient deptFeignClient;
//
// private final FileStorageUtil fileStorageUtil;
// private static final String DESCRIPTION = "description";
//
// private final FlowableDefineFeignClient flowableDefineFeignClient;
//
//
// @Override
// @Async("asyncExecutor")
// public void creatSupervise(SuperviseParam superviseParam) {
// this.initSupervise(superviseParam);
// }
//
// @Override
// public HttpResult<String> initSupervise(SuperviseParam superviseParam) {
// SuperviceRunLogVo superviceRunLogVo = new SuperviceRunLogVo();
// List<ThsOverRunLog> overRunLogList = new ArrayList<>();
// if (InitTypeEnum.MANUAL.getCode().equals(superviseParam.getInitType()) && StringUtils.isBlank(superviseParam.getDeptId())) {
// return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.INVALID_PARAMETER, null, "");
// }
// List<ThsStrategyVo> thsStrategyList = this.selectStrategyList(superviseParam);
// //按部门进行分组
// if (CollectionUtil.isNotEmpty(thsStrategyList)) {
// Map<String, List<ThsStrategyVo>> deptMap = thsStrategyList.stream().collect(Collectors.groupingBy(ThsStrategyVo::getDeptId));
// for (Map.Entry<String, List<ThsStrategyVo>> entry : deptMap.entrySet()) {
// String depId = entry.getKey();
// ThsSupervise thsSupervise = new ThsSupervise();
// List<ThsStrategyVo> deptList = entry.getValue();
// List<ThsStrategyVo> oneLevel = deptList.stream().filter(r -> !GradeEnum.THREE_LEVEL.getCode().equals(r.getGrade())).collect(Collectors.toList());//一级或二级策略集合
// List<SourceSteadyIndicator> oneSourceSteadyIndicatorList = new ArrayList<>();
// if (CollectionUtil.isNotEmpty(oneLevel)) {
// for (ThsStrategyVo oneStrategyVo : oneLevel) {
// List<ThsWarnStrategyAss> oneInterferenceSourceAsses = this.queryWarnStrategyAss(oneStrategyVo.getId(), TypeEnum.SOURCE_TYPE);//干扰源列表
// List<ThsWarnStrategyAss> oneSteadyIndicatorAsses = this.queryWarnStrategyAss(oneStrategyVo.getId(), TypeEnum.INTERFERENCE_TYPE);//干扰源列表
// List<String> oneSteadyIndicatorAssesIds = oneSteadyIndicatorAsses.stream().map(ThsWarnStrategyAss::getAssId).collect(Collectors.toList());
// //封装每一种干扰源和对应的指标
// for (ThsWarnStrategyAss oneWarnStrategyAss : oneInterferenceSourceAsses) {
// SourceSteadyIndicator build = SourceSteadyIndicator.builder().id(oneStrategyVo.getId()).operation(oneStrategyVo.getOperation())
// .interferenceSource(oneWarnStrategyAss.getAssId())
// .steadyIndicator(oneSteadyIndicatorAssesIds)
// .deptId(oneStrategyVo.getDeptId())
// .type(oneStrategyVo.getType())
// .build();
// oneSourceSteadyIndicatorList.add(build);
// }
// }
// }
// List<ThsStrategyVo> threeLevel = deptList.stream().filter(r -> GradeEnum.THREE_LEVEL.getCode().equals(r.getGrade())).collect(Collectors.toList());//三级策略集合
// if (CollectionUtil.isNotEmpty(threeLevel)) {
// for (ThsStrategyVo threeStrategyVo : threeLevel) {
// Iterator<SourceSteadyIndicator> iterator = oneSourceSteadyIndicatorList.iterator();
// while (iterator.hasNext()) {
// SourceSteadyIndicator sourceSteady = iterator.next();
// if (sourceSteady.getType().equals(threeStrategyVo.getType())) {
// if (StringUtils.equals(threeStrategyVo.getMonitorId(), sourceSteady.getMonitorId())) {
// List<ThsWarnStrategyAss> interferenceSourceAsses = this.queryWarnStrategyAss(threeStrategyVo.getId(), TypeEnum.SOURCE_TYPE);
// //干扰源类型id
// List<String> threeInterferenceSourceIds = interferenceSourceAsses.stream().map(ThsWarnStrategyAss::getAssId).collect(Collectors.toList());
// List<ThsWarnStrategyAss> threeSteadyIndicatorAsses = this.queryWarnStrategyAss(threeStrategyVo.getId(), TypeEnum.INTERFERENCE_TYPE);
// //指标类型id
// List<String> steadyIndicatorIds = threeSteadyIndicatorAsses.stream().map(ThsWarnStrategyAss::getAssId).collect(Collectors.toList());
// for (String threeInterferenceSourceId : threeInterferenceSourceIds) {
// if (OperationEnum.AND.getCode().equals(threeStrategyVo.getOperation())) {//处理三级策略的与
// if (OperationEnum.AND.getCode().equals(sourceSteady.getOperation())) {
// if (StringUtils.equals(threeInterferenceSourceId, sourceSteady.getInterferenceSource()) &&
// steadyIndicatorIds.containsAll(sourceSteady.getSteadyIndicator())) {
// iterator.remove();
// }
// }
// } else {//处理三级策略的或
// if (StringUtils.equals(threeInterferenceSourceId, sourceSteady.getInterferenceSource())) {
// if (steadyIndicatorIds.containsAll(sourceSteady.getSteadyIndicator())) {
// iterator.remove();
// } else {
// List<String> steadyIndicator = sourceSteady.getSteadyIndicator();
// steadyIndicator.removeAll(steadyIndicatorIds);
// }
// }
// }
// }
// }
// }
// }
// }
// }
// if (CollectionUtil.isNotEmpty(oneSourceSteadyIndicatorList)) {
// oneSourceSteadyIndicatorList.forEach(steady -> {
// Monitor monitor = pmsMonitorMapper.selectById(steady.getMonitorId());
// if (monitor != null) {
// if (StringUtils.equals(monitor.getMonitorTag(), steady.getInterferenceSource())) {//匹配该监测点属于的干扰源类型
// //查询该监测点的检测数据
// RStatLimitRateDPO limitRate = this.queryLimitTargetData(monitor.getId());
// //判断指标是否超标
// Map<String, Object> limitBoolMap = this.verifyLimit(limitRate, steady);
// //构建监督数据
// this.buildData(steady, limitBoolMap, monitor, limitRate, superviseParam.getInitType(), thsSupervise, overRunLogList);
//
// }
// }
// });
// //生成技术监督数据
// HttpResult<Dept> deptById = deptFeignClient.getDeptById(depId);
// Dept dept = deptById.getData();
// if (InitTypeEnum.AUTO.getCode().equals(superviseParam.getInitType())) {
// this.creatData(dept, thsSupervise, overRunLogList);
// } else {
// this.buildSuperviseName(thsSupervise, overRunLogList, dept);
// superviceRunLogVo.setOverRunLog(overRunLogList);
// superviceRunLogVo.setThsSupervise(thsSupervise);
// }
// }
// }
// }
// return HttpResultUtil.assembleCommonResponseResult(CommonResponseEnum.SUCCESS, JSON.toJSONString(superviceRunLogVo), "");
// }
//
// /**
// * 构建技术监督名称
// *
// * @param thsSupervise
// * @param overRunLogList
// * @param dept
// */
// private void buildSuperviseName(ThsSupervise thsSupervise, List<ThsOverRunLog> overRunLogList, Dept dept) {
// if (CollectionUtil.isNotEmpty(overRunLogList)) {
// thsSupervise.setDescription(overRunLogList.get(0).getDescription());
// String str = Arrays.asList(overRunLogList.get(0).getDescription().split(",")).get(0);
// String overItem = str.substring(0, str.indexOf("次") - 1);
// thsSupervise.setName(DateUtil.today() + dept.getName() + overRunLogList.get(0).getName() + "等" + overRunLogList.size() + "个监测点" + overItem);
// }
// }
//
// //生成技术监督数据
// @DS("process")
// @Transactional(rollbackFor = Exception.class)
// @Override
// public void creatData(Dept dept, ThsSupervise thsSupervise, List<ThsOverRunLog> overRunLogList) {
// if (CollectionUtil.isNotEmpty(overRunLogList)) {
// thsSupervise.setDescription(overRunLogList.get(0).getDescription());
// String str = Arrays.asList(overRunLogList.get(0).getDescription().split(",")).get(0);
// String overItem = str.substring(0, str.indexOf("次") - 1);
// thsSupervise.setName(DateUtil.today() + dept.getName() + overRunLogList.get(0).getName() + "等" + overRunLogList.size() + "个监测点" + overItem);
// thsSuperviseMapper.insert(thsSupervise);
//
// //TODO 解决工作流写死问题
// Map<String, Object> mapParam = new HashMap<>();
// String proInId ="";
// if(thsSupervise.getType() == 0){
// proInId = "flow_yzep99kb:1:a100b48b-da75-11ed-8335-b07b253cdad9";
// }else {
// proInId = "flow_yzep99kb:2:6358e099-dcba-11ed-8026-b07b253cdad9";
// }
// flowableDefineFeignClient.start(proInId,thsSupervise.getSupIndex(),mapParam);
//
// for (ThsOverRunLog thsOverRunLog : overRunLogList) {
// thsOverRunLogMapper.insert(thsOverRunLog);
// }
// }
// }
//
//
// /**
// * 查询策略列表
// *
// * @param superviseParam
// * @return
// */
// @DS("process")
// @Override
// public List<ThsStrategyVo> selectStrategyList(SuperviseParam superviseParam) {
// return thsWarnStrategyMapper.selectStrategyList(superviseParam);
// }
//
// /**
// * 查询策略绑定的干扰源列表或指标参数列表
// *
// * @param warnId
// * @param typeEnum
// * @return
// */
// @DS("process")
// @Override
// public List<ThsWarnStrategyAss> queryWarnStrategyAss(String warnId, TypeEnum typeEnum) {
// return thsWarnStrategyAssMapper.selectList(new LambdaQueryWrapper<ThsWarnStrategyAss>()
// .eq(ThsWarnStrategyAss::getWarnId, warnId)
// .eq(ThsWarnStrategyAss::getType, typeEnum.getCode()));
// }
//
// /**
// * 生成监督数据
// *
// * @param limitBoolMap
// */
// @Override
// 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 (OperationEnum.AND.getCode().equals(steady.getOperation())) {
// for (Map.Entry<String, Object> entry : limitBoolMap.entrySet()) {
// if (entry.getValue() instanceof Boolean && !(boolean) entry.getValue()) {
// return;
// }
// }
// //构建监督数据
// this.buildSuperviseData(steady, monitor, limitRate, limitBoolMap, initType, thsSupervise, thsOverRunLogs);
// //构建告警/预警监测点列表数据
// this.buildOverRunLog(steady, thsSupervise, monitor, limitRate, limitBoolMap, initType, thsOverRunLogs);
// return;
// }
// if (OperationEnum.OR.getCode().equals(steady.getOperation())) {
// for (Map.Entry<String, Object> entry : limitBoolMap.entrySet()) {
// if (entry.getValue() instanceof Boolean && (boolean) entry.getValue()) {
// //生成监督数据
// this.buildSuperviseData(steady, monitor, limitRate, limitBoolMap, initType, thsSupervise, thsOverRunLogs);
// //生成告警/预警监测点数据
// this.buildOverRunLog(steady, thsSupervise, monitor, limitRate, limitBoolMap, initType, thsOverRunLogs);
// return;
// }
// }
// }
// }
// }
//
//
// @Override
// 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())) {
// thsSupervise.setSupIndex(IdUtil.simpleUUID());
// thsSupervise.setDeptId(steady.getDeptId());
// thsSupervise.setCreateTime(new Date());
// thsSupervise.setType(steady.getType());
// thsSupervise.setCreateUser(RequestUtil.getUsername());
// thsSupervise.setProgress(ProgressEnum.START.getCode());
// thsSupervise.setCreateType(initType);
// }
// }
//
//
// @Override
// 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.setId(IdUtil.simpleUUID());
// thsOverRunLog.setSupIndex(thsSupervise.getSupIndex());
// thsOverRunLog.setLineIndex(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.setCreateTime(new Date());
// List<String> descriptionList = (List) limitBoolMap.get(DESCRIPTION);
// thsOverRunLog.setDescription(StringUtils.join(descriptionList, ","));
// thsOverRunLogs.add(thsOverRunLog);
// }
//
//
// @Override
// @DS("pms")
// public RStatLimitRateDPO queryLimitTargetData(String monitorId) {
// RStatLimitRateDPO limitRate = rateDService.getOne(new LambdaQueryWrapper<RStatLimitRateDPO>().eq(RStatLimitRateDPO::getLineId, monitorId)
// .between(RStatLimitRateDPO::getTime,
// DateUtil.beginOfDay(DateUtil.offsetDay(new Date(), -1)),
// DateUtil.endOfDay(DateUtil.offsetDay(new Date(), -1))).last("limit 1"));
// return limitRate;
// }
//
//
// /**
// * 判断监测数据是否超标
// *
// * @param limitRate
// * @param steady
// */
// private Map<String, Object> verifyLimit(RStatLimitRateDPO limitRate, SourceSteadyIndicator steady) {
// if (limitRate != null) {
// List<String> steadyIndicator = steady.getSteadyIndicator();
// Map<String, Object> limitBoolMap = new HashedMap();
// List<String> descriptionList = new ArrayList<>();
// steadyIndicator.forEach(id -> {
// HttpResult<DictData> dicDataById = dicDataFeignClient.getDicDataById(id);
// if (CommonResponseEnum.SUCCESS.getCode().equals(dicDataById.getCode()) && dicDataById.getData() != null) {
// SteadyIndicatorEnum steadyIndicatorEnum = SteadyIndicatorEnum.getSteadyIndicatorEnumByCode(dicDataById.getData().getCode());
// if (null != steadyIndicatorEnum) {
// switch (steadyIndicatorEnum) {
// case Negative_Voltage://负序电压不平衡度
// if (limitRate.getUbalanceOvertime() > 0) {
// limitBoolMap.put(SteadyIndicatorEnum.Negative_Voltage.getCode(), true);
// descriptionList.add(SteadyIndicatorEnum.Negative_Voltage.getMessage().concat(limitRate.getUbalanceOvertime() + "次"));
// } else {
// limitBoolMap.put(SteadyIndicatorEnum.Negative_Voltage.getCode(), false);
// }
// break;
// case Interhar_Voltage://间谐波电压
// Integer interharVoltageOvertime = this.maxOverTime(limitRate, InterharVoltage.class);
// if (interharVoltageOvertime > 0) {
// limitBoolMap.put(SteadyIndicatorEnum.Interhar_Voltage.getCode(), true);
// descriptionList.add(SteadyIndicatorEnum.Interhar_Voltage.getMessage().concat(interharVoltageOvertime + "次"));
// } else {
// limitBoolMap.put(SteadyIndicatorEnum.Interhar_Voltage.getCode(), false);
// }
// break;
// case Neg_Current://负序电流
// if (limitRate.getINegOvertime() > 0) {
// limitBoolMap.put(SteadyIndicatorEnum.Neg_Current.getCode(), true);
// descriptionList.add(SteadyIndicatorEnum.Neg_Current.getMessage().concat(limitRate.getINegOvertime() + "次"));
// } else {
// limitBoolMap.put(SteadyIndicatorEnum.Neg_Current.getCode(), false);
// }
// break;
// case Fre_Deviation://频率偏差
// if (limitRate.getFreqDevOvertime() > 0) {
// limitBoolMap.put(SteadyIndicatorEnum.Fre_Deviation.getCode(), true);
// descriptionList.add(SteadyIndicatorEnum.Fre_Deviation.getMessage().concat(limitRate.getFreqDevOvertime() + "次"));
// } else {
// limitBoolMap.put(SteadyIndicatorEnum.Fre_Deviation.getCode(), false);
// }
// break;
// case Voltage_Dev://电压偏差
// if (limitRate.getVoltageDevOvertime() > 0) {
// limitBoolMap.put(SteadyIndicatorEnum.Voltage_Dev.getCode(), true);
// descriptionList.add(SteadyIndicatorEnum.Voltage_Dev.getMessage().concat(limitRate.getVoltageDevOvertime() + "次"));
// } else {
// limitBoolMap.put(SteadyIndicatorEnum.Voltage_Dev.getCode(), false);
// }
// break;
// case Har_Current://谐波电流
// Integer harCurrentOvertime = this.maxOverTime(limitRate, HarCurrent.class);
// if (harCurrentOvertime > 0) {
// limitBoolMap.put(SteadyIndicatorEnum.Har_Current.getCode(), true);
// descriptionList.add(SteadyIndicatorEnum.Har_Current.getMessage().concat(harCurrentOvertime + "次"));
// } else {
// limitBoolMap.put(SteadyIndicatorEnum.Har_Current.getCode(), false);
// }
// break;
// case Voltage_Fluc://电压波动与闪变
// if (limitRate.getFlickerOvertime() > 0) {
// limitBoolMap.put(SteadyIndicatorEnum.Voltage_Fluc.getCode(), true);
// descriptionList.add(SteadyIndicatorEnum.Voltage_Fluc.getMessage().concat(limitRate.getFlickerOvertime() + "次"));
// } else {
// limitBoolMap.put(SteadyIndicatorEnum.Voltage_Fluc.getCode(), false);
// }
// break;
// case Har_Voltage://谐波电压
// Integer harVoltageOvertime = this.maxOverTime(limitRate, HarVoltage.class);
// if (harVoltageOvertime > 0) {
// limitBoolMap.put(SteadyIndicatorEnum.Har_Voltage.getCode(), true);
// descriptionList.add(SteadyIndicatorEnum.Har_Voltage.getMessage().concat(harVoltageOvertime + "次"));
// } else {
// limitBoolMap.put(SteadyIndicatorEnum.Har_Voltage.getCode(), false);
// }
// break;
// }
// }
// }
// });
// limitBoolMap.put(DESCRIPTION, descriptionList);
// return limitBoolMap;
// }
// return null;
// }
//
// /***
// * 获取越限最大值
// * @param object
// * @param annotation
// * @return
// */
// private Integer maxOverTime(Object object, Class annotation) {
// Integer maxValue = 0;
// try {
// Class objClass = object.getClass();
// Field[] fields = objClass.getDeclaredFields();
// for (Field field : fields) {
// field.setAccessible(true);
// boolean isAnon = field.isAnnotationPresent(annotation);
// if (isAnon) {
// Object objValue = field.get(object);
// if (objValue instanceof Integer) {
// if ((Integer) objValue > maxValue) {
// maxValue = (Integer) objValue;
// }
// }
// }
// }
// } catch (Exception e) {
// log.error("获取越限最大值异常：{}", e.toString());
// }
// 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;
import com.baomidou.mybatisplus.extension.service.IService;
import com.njcn.common.pojo.response.HttpResult;
import com.njcn.device.pms.pojo.po.Monitor;
import com.njcn.harmonic.pojo.po.day.RStatLimitRateDPO;
import com.njcn.harmonic.pojo.vo.SourceSteadyIndicator;
import com.njcn.harmonic.pojo.vo.ThsStrategyVo;
import com.njcn.prepare.enums.TypeEnum;
import com.njcn.prepare.harmonic.pojo.param.SuperviseParam;
import com.njcn.prepare.harmonic.pojo.po.ThsOverRunLog;
import com.njcn.prepare.harmonic.pojo.po.ThsSupervise;
import com.njcn.process.pojo.po.ThsWarnStrategyAss;
import com.njcn.user.pojo.po.Dept;
import java.util.List;
import java.util.Map;
/**
* <p>
* 服务类
* </p>
*
* @author lxp
* @since 2023-03-16
*/
public interface ThsSuperviseService extends IService<ThsSupervise> {
/**
* 初始化技术监督
*/
HttpResult<String> initSupervise(SuperviseParam superviseParam);
/**
* 查新策略集合
*
* @param superviseParam
* @return
*/
List<ThsStrategyVo> selectStrategyList(SuperviseParam superviseParam);
/**
* 查询LimitTarget数据
*
* @param monitorId
*/
RStatLimitRateDPO queryLimitTargetData(String monitorId);
/**
* 生成监督数据
*
* @param limitBoolMap
*/
void buildData(SourceSteadyIndicator steady, Map<String, Object> limitBoolMap, Monitor monitor, RStatLimitRateDPO limitRate, Integer initType, ThsSupervise thsSupervise, List<ThsOverRunLog> thsOverRunLogs);
/**
* 查询策略绑定的干扰源列表或指标参数列表
*
* @param id
* @param typeEnum
* @return
*/
List<ThsWarnStrategyAss> queryWarnStrategyAss(String id, TypeEnum typeEnum);
/**
* 生成监督数据
*
* @param steady
* @param monitor
* @return
*/
void buildSuperviseData(SourceSteadyIndicator steady, Monitor monitor, RStatLimitRateDPO limitRate, Map<String, Object> limitBoolMap, Integer initType, ThsSupervise thsSupervise, List<ThsOverRunLog> thsOverRunLogs);
/**
* 生成 告警/预警监测点列表 数据
*
* @param steady
* @param thsSupervise
* @param monitor
*/
void buildOverRunLog(SourceSteadyIndicator steady, ThsSupervise thsSupervise, Monitor monitor, RStatLimitRateDPO limitRate, Map<String, Object> limitBoolMap, Integer initType, List<ThsOverRunLog> thsOverRunLogs);
/**
* 生成技术监督数据
*
* @param thsSupervise
* @param overRunLogList
*/
void creatData(Dept dept, ThsSupervise thsSupervise, List<ThsOverRunLog> overRunLogList);
/**
* 创建技术监督
*
* @param superviseParam
* @return
*/
void creatSupervise(SuperviseParam superviseParam);
}
//package com.njcn.prepare.harmonic.service.mysql.line;
//
//import com.baomidou.mybatisplus.extension.service.IService;
//import com.njcn.common.pojo.response.HttpResult;
//import com.njcn.device.pms.pojo.po.Monitor;
//import com.njcn.harmonic.pojo.po.day.RStatLimitRateDPO;
//import com.njcn.harmonic.pojo.vo.SourceSteadyIndicator;
//import com.njcn.harmonic.pojo.vo.ThsStrategyVo;
//import com.njcn.prepare.enums.TypeEnum;
//import com.njcn.prepare.harmonic.pojo.param.SuperviseParam;
//import com.njcn.prepare.harmonic.pojo.po.ThsOverRunLog;
//import com.njcn.prepare.harmonic.pojo.po.ThsSupervise;
//import com.njcn.process.pojo.po.ThsWarnStrategyAss;
//import com.njcn.user.pojo.po.Dept;
//
//import java.util.List;
//import java.util.Map;
//
///**
// * <p>
// * 服务类
// * </p>
// *
// * @author lxp
// * @since 2023-03-16
// */
//public interface ThsSuperviseService extends IService<ThsSupervise> {
// /**
// * 初始化技术监督
// */
// HttpResult<String> initSupervise(SuperviseParam superviseParam);
//
// /**
// * 查新策略集合
// *
// * @param superviseParam
// * @return
// */
// List<ThsStrategyVo> selectStrategyList(SuperviseParam superviseParam);
//
// /**
// * 查询LimitTarget数据
// *
// * @param monitorId
// */
// RStatLimitRateDPO queryLimitTargetData(String monitorId);
//
// /**
// * 生成监督数据
// *
// * @param limitBoolMap
// */
// void buildData(SourceSteadyIndicator steady, Map<String, Object> limitBoolMap, Monitor monitor, RStatLimitRateDPO limitRate, Integer initType, ThsSupervise thsSupervise, List<ThsOverRunLog> thsOverRunLogs);
//
// /**
// * 查询策略绑定的干扰源列表或指标参数列表
// *
// * @param id
// * @param typeEnum
// * @return
// */
// List<ThsWarnStrategyAss> queryWarnStrategyAss(String id, TypeEnum typeEnum);
//
// /**
// * 生成监督数据
// *
// * @param steady
// * @param monitor
// * @return
// */
// void buildSuperviseData(SourceSteadyIndicator steady, Monitor monitor, RStatLimitRateDPO limitRate, Map<String, Object> limitBoolMap, Integer initType, ThsSupervise thsSupervise, List<ThsOverRunLog> thsOverRunLogs);
//
// /**
// * 生成 告警/预警监测点列表 数据
// *
// * @param steady
// * @param thsSupervise
// * @param monitor
// */
// void buildOverRunLog(SourceSteadyIndicator steady, ThsSupervise thsSupervise, Monitor monitor, RStatLimitRateDPO limitRate, Map<String, Object> limitBoolMap, Integer initType, List<ThsOverRunLog> thsOverRunLogs);
//
//
// /**
// * 生成技术监督数据
// *
// * @param thsSupervise
// * @param overRunLogList
// */
// void creatData(Dept dept, ThsSupervise thsSupervise, List<ThsOverRunLog> overRunLogList);
//
// /**
// * 创建技术监督
// *
// * @param superviseParam
// * @return
// */
//
// void creatSupervise(SuperviseParam superviseParam);
//}