package com.qianwen.mdc.collect.utils;
|
|
import java.util.ArrayList;
|
import java.util.Comparator;
|
import java.util.List;
|
import java.util.stream.Collectors;
|
|
import org.slf4j.Logger;
|
import org.slf4j.LoggerFactory;
|
|
import com.qianwen.core.tool.utils.BeanUtil;
|
import com.qianwen.core.tool.utils.Func;
|
import com.qianwen.mdc.collect.dto.WorkstationFeedbackTimePointDTO;
|
import com.qianwen.mdc.collect.dto.WorkstationFeedbackTimeQuantumDTO;
|
import com.qianwen.mdc.collect.dto.WorkstationFeedbackViewDTO;
|
import com.qianwen.mdc.collect.entity.iotdb.DeviceState;
|
import com.qianwen.mdc.collect.enums.FeedbackTimePointEnum;
|
import com.qianwen.mdc.collect.mapper.iotdb.DeviceStateMapper;
|
|
public class FeedbackAnalyseUtils {
|
private static final Logger log = LoggerFactory.getLogger(FeedbackAnalyseUtils.class);
|
|
public static List<WorkstationFeedbackTimeQuantumDTO> getRelatedFeedbackTimeQuantumInfo(List<WorkstationFeedbackViewDTO> workstationFeedbackViewList) {
|
List<WorkstationFeedbackTimeQuantumDTO> result = new ArrayList<>();
|
if (Func.isNotEmpty(workstationFeedbackViewList)) {
|
workstationFeedbackViewList.forEach(item -> {
|
WorkstationFeedbackTimeQuantumDTO temp = new WorkstationFeedbackTimeQuantumDTO();
|
temp.setFeedbackId(item.getWorkstationWcsFeedback().getId());
|
temp.setFeedbackTime(item.getWorkstationWcsFeedback().getFeedbackTime());
|
temp.setWcs(item.getWorkstationWcsFeedback().getWcs());
|
if (Func.isNotEmpty(item.getWorkstationWcsFeedbackDetails())) {
|
item.getWorkstationWcsFeedbackDetails().forEach(detail -> {
|
WorkstationFeedbackTimeQuantumDTO tempTime = BeanUtil.copyProperties(temp, WorkstationFeedbackTimeQuantumDTO.class);
|
tempTime.setStartTime(detail.getStartTime());
|
tempTime.setFeedbackDetailId(detail.getId());
|
tempTime.setEndTime(detail.getEndTime());
|
result.add(tempTime);
|
});
|
} else if (!item.getIsDeleted().booleanValue()) {
|
temp.setStartTime(item.getWorkstationWcsFeedback().getStartTime());
|
temp.setEndTime(item.getWorkstationWcsFeedback().getEndTime());
|
result.add(temp);
|
}
|
});
|
}
|
return result;
|
}
|
|
public static List<WorkstationFeedbackTimePointDTO> buildFeedbackTimePointInfo(List<WorkstationFeedbackTimeQuantumDTO> feedbackTimeQuantumDTOList) {
|
List<WorkstationFeedbackTimePointDTO> result = new ArrayList<>();
|
List<WorkstationFeedbackTimePointDTO> remove = new ArrayList<>();
|
if (Func.isNotEmpty(feedbackTimeQuantumDTOList))
|
for (int j = 0; j < feedbackTimeQuantumDTOList.size(); j++) {
|
WorkstationFeedbackTimeQuantumDTO x = feedbackTimeQuantumDTOList.get(j);
|
WorkstationFeedbackTimePointDTO startTimePoint = new WorkstationFeedbackTimePointDTO().setFeedbackId(x.getFeedbackId()).setReportTime(x.getFeedbackTime()).setFeedbackDetailId(x.getFeedbackDetailId()).setFeedbackTime(x.getStartTime()).setWcs(x.getWcs());
|
WorkstationFeedbackTimePointDTO endTimePoint = new WorkstationFeedbackTimePointDTO().setFeedbackId(x.getFeedbackId()).setReportTime(x.getFeedbackTime()).setFeedbackTime(x.getEndTime()).setFeedbackDetailId(x.getFeedbackDetailId()).setWcs(x.getWcs());
|
result.add(startTimePoint);
|
result.add(endTimePoint);
|
}
|
if (Func.isNotEmpty(result)) {
|
result = result.stream().sorted(Comparator.comparing(WorkstationFeedbackTimePointDTO::getReportTime)
|
.thenComparing(WorkstationFeedbackTimePointDTO::getFeedbackTime)).collect(Collectors.toList());
|
}
|
for (int i = 0; i < result.size(); i++) {
|
result.get(i).setIndex(i);
|
}
|
getCrossFeedbackTimePoints(result);
|
List<WorkstationFeedbackTimePointDTO> finalResult = getEffectFeedbackTimePoints(result, remove);
|
finalResult = buildFeedbackTimePointsCompleteInfo(finalResult, remove);
|
finalResult = fixFeedbackTimePointInfo(feedbackTimeQuantumDTOList, finalResult);
|
return finalResult;
|
}
|
|
private static void getCrossFeedbackTimePoints(List<WorkstationFeedbackTimePointDTO> timePointList) {
|
//List<WorkstationFeedbackTimePointDTO> finalResult = new ArrayList<>();
|
if (Func.isNotEmpty(timePointList)) {
|
for (WorkstationFeedbackTimePointDTO item : timePointList) {
|
WorkstationFeedbackTimePointDTO start = timePointList.stream().filter(x -> (x.getFeedbackTime().getTime() < item.getFeedbackTime().getTime() && x.getIndex() < item.getIndex() && !x.getFeedbackId().equals(item.getFeedbackId()))).max(Comparator.comparing(WorkstationFeedbackTimePointDTO::getIndex)).orElse(null);
|
WorkstationFeedbackTimePointDTO end = timePointList.stream().filter(x -> (x.getFeedbackTime().getTime() > item.getFeedbackTime().getTime() && x.getIndex() < item.getIndex() && !x.getFeedbackId().equals(item.getFeedbackId()))).min(Comparator.comparing(WorkstationFeedbackTimePointDTO::getIndex)).orElse(null);
|
if (Func.isNotEmpty(start) && Func.isNotEmpty(end) &&
|
start.getFeedbackId().equals(end.getFeedbackId()))
|
item.setPointEnum(FeedbackTimePointEnum.CROSS_POINT);
|
}
|
}
|
}
|
|
private static List<WorkstationFeedbackTimePointDTO> buildFeedbackTimePointsCompleteInfo(
|
List<WorkstationFeedbackTimePointDTO> effectFeedbackList,
|
List<WorkstationFeedbackTimePointDTO> removeList) {
|
//List<WorkstationFeedbackTimePointDTO> feedBackTimePointList = new ArrayList<>();
|
if (Func.isNotEmpty(effectFeedbackList)) {
|
effectFeedbackList = (List<WorkstationFeedbackTimePointDTO>) effectFeedbackList.stream()
|
.sorted(Comparator.comparing(WorkstationFeedbackTimePointDTO::getFeedbackTime))
|
.collect(Collectors.toList());
|
for (int i = 0; i < effectFeedbackList.size(); i++) {
|
if (i == 0) {
|
((WorkstationFeedbackTimePointDTO) effectFeedbackList.get(0))
|
.setPointEnum(FeedbackTimePointEnum.START_POINT);
|
} else if (i == effectFeedbackList.size() - 1) {
|
((WorkstationFeedbackTimePointDTO) effectFeedbackList.get(i))
|
.setPointEnum(FeedbackTimePointEnum.END_POINT);
|
} else {
|
WorkstationFeedbackTimePointDTO prePoint = effectFeedbackList.get(i - 1);
|
WorkstationFeedbackTimePointDTO currentPoint = effectFeedbackList.get(i);
|
WorkstationFeedbackTimePointDTO start = effectFeedbackList.stream()
|
.filter(x -> (x.getFeedbackTime().getTime() < currentPoint.getFeedbackTime().getTime()
|
&& !x.getFeedbackId().equals(currentPoint.getFeedbackId())))
|
.max(Comparator.comparing(WorkstationFeedbackTimePointDTO::getFeedbackTime)).orElse(null);
|
WorkstationFeedbackTimePointDTO end = effectFeedbackList.stream()
|
.filter(x -> (x.getFeedbackTime().getTime() > currentPoint.getFeedbackTime().getTime()
|
&& !x.getFeedbackId().equals(currentPoint.getFeedbackId())))
|
.min(Comparator.comparing(WorkstationFeedbackTimePointDTO::getFeedbackTime)).orElse(null);
|
if (Func.isNotEmpty(start) && Func.isNotEmpty(end)
|
&& start.getFeedbackId().equals(end.getFeedbackId()))
|
currentPoint.setPointEnum(FeedbackTimePointEnum.CROSS_POINT);
|
if (checkIsCrossFeedbackTimePoint(currentPoint, effectFeedbackList, removeList))
|
currentPoint.setPointEnum(FeedbackTimePointEnum.CROSS_POINT);
|
if (!Func.isNotEmpty(currentPoint.getPointEnum())) {
|
if (Func.isNotEmpty(prePoint.getPointEnum())
|
&& FeedbackTimePointEnum.CROSS_POINT.isEqual(prePoint.getPointEnum().getValue()))
|
((WorkstationFeedbackTimePointDTO) effectFeedbackList.get(i))
|
.setPointEnum(FeedbackTimePointEnum.END_POINT);
|
if (prePoint.getFeedbackId().equals(currentPoint.getFeedbackId())) {
|
((WorkstationFeedbackTimePointDTO) effectFeedbackList.get(i))
|
.setPointEnum(FeedbackTimePointEnum.END_POINT);
|
} else {
|
if (prePoint.getPointEnum().isEqual(FeedbackTimePointEnum.START_POINT.getValue()))
|
((WorkstationFeedbackTimePointDTO) effectFeedbackList.get(i))
|
.setPointEnum(FeedbackTimePointEnum.CROSS_POINT);
|
if (prePoint.getPointEnum().isEqual(FeedbackTimePointEnum.END_POINT.getValue()))
|
((WorkstationFeedbackTimePointDTO) effectFeedbackList.get(i))
|
.setPointEnum(FeedbackTimePointEnum.START_POINT);
|
}
|
}
|
}
|
}
|
}
|
return effectFeedbackList;
|
}
|
|
private static boolean checkIsCrossFeedbackTimePoint(WorkstationFeedbackTimePointDTO pointDTO, List<WorkstationFeedbackTimePointDTO> originalPointsList, List<WorkstationFeedbackTimePointDTO> removeList) {
|
List<WorkstationFeedbackTimePointDTO> minList = (List<WorkstationFeedbackTimePointDTO>)originalPointsList.stream().filter(x -> (x.getFeedbackTime().getTime() < pointDTO.getFeedbackTime().getTime())).collect(Collectors.toList());
|
if (Func.isEmpty(minList))
|
return false;
|
List<WorkstationFeedbackTimePointDTO> maxList = (List<WorkstationFeedbackTimePointDTO>)originalPointsList.stream().filter(x -> (x.getFeedbackTime().getTime() > pointDTO.getFeedbackTime().getTime())).collect(Collectors.toList());
|
if (Func.isEmpty(maxList))
|
return false;
|
for (WorkstationFeedbackTimePointDTO item : minList) {
|
WorkstationFeedbackTimePointDTO exits = maxList.stream().filter(x -> x.getFeedbackId().equals(item.getFeedbackId())).findAny().orElse(null);
|
if (Func.isNotEmpty(exits))
|
return true;
|
}
|
for (WorkstationFeedbackTimePointDTO item : maxList) {
|
WorkstationFeedbackTimePointDTO exits = null;
|
if (Func.isNotEmpty(item.getFeedbackDetailId())) {
|
exits = removeList.stream().filter(x -> (Func.isNotEmpty(x.getFeedbackDetailId()) && x.getFeedbackDetailId().equals(item.getFeedbackDetailId()) && x.getFeedbackTime().getTime() <= pointDTO.getFeedbackTime().getTime())).findAny().orElse(null);
|
} else {
|
exits = removeList.stream().filter(x -> (x.getFeedbackId().equals(item.getFeedbackId()) && x.getFeedbackTime().getTime() <= pointDTO.getFeedbackTime().getTime())).findAny().orElse(null);
|
}
|
if (Func.isNotEmpty(exits))
|
return true;
|
}
|
return false;
|
}
|
|
private static List<WorkstationFeedbackTimePointDTO> getEffectFeedbackTimePoints(List<WorkstationFeedbackTimePointDTO> originalPointsList, List<WorkstationFeedbackTimePointDTO> removeList) {
|
List<WorkstationFeedbackTimePointDTO> result = new ArrayList<>();
|
for (WorkstationFeedbackTimePointDTO item : originalPointsList) {
|
if (checkIsKeepFeedbackTimePoint(item, originalPointsList)) {
|
result.add(item);
|
} else {
|
removeList.add(item);
|
}
|
}
|
return result;
|
}
|
|
private static boolean checkIsKeepFeedbackTimePoint(WorkstationFeedbackTimePointDTO pointDTO, List<WorkstationFeedbackTimePointDTO> originalPointsList) {
|
long min = originalPointsList.stream().filter(x -> {
|
return x.getIndex().intValue() > pointDTO.getIndex().intValue() && x.getFeedbackTime().getTime() <= pointDTO.getFeedbackTime().getTime();
|
}).count();
|
if (min <= 0) {
|
return true;
|
}
|
long max = originalPointsList.stream().filter(x2 -> {
|
return x2.getIndex() > pointDTO.getIndex() && x2.getFeedbackTime().getTime() >= pointDTO.getFeedbackTime().getTime();
|
}).count();
|
if (max <= 0) {
|
return true;
|
}
|
return false;
|
}
|
|
private static List<WorkstationFeedbackTimePointDTO> fixFeedbackTimePointInfo(List<WorkstationFeedbackTimeQuantumDTO> feedbackTimeQuantumDTOList, List<WorkstationFeedbackTimePointDTO> finalResult) {
|
List<WorkstationFeedbackTimePointDTO> result = new ArrayList<>();
|
List<WorkstationFeedbackTimePointDTO> finallyResult = new ArrayList<>();
|
List<WorkstationFeedbackTimeQuantumDTO> effectFeedbackTimeQuantumList = new ArrayList<>();
|
effectFeedbackTimeQuantumList = (List<WorkstationFeedbackTimeQuantumDTO>)feedbackTimeQuantumDTOList.stream().sorted(Comparator.comparing(WorkstationFeedbackTimeQuantumDTO::getFeedbackTime).thenComparing(WorkstationFeedbackTimeQuantumDTO::getStartTime).reversed()).collect(Collectors.toList());
|
for (WorkstationFeedbackTimePointDTO item : finalResult) {
|
if (FeedbackTimePointEnum.CROSS_POINT.isEqual(item.getPointEnum().getValue())) {
|
WorkstationFeedbackTimeQuantumDTO matchDto = effectFeedbackTimeQuantumList.stream().filter(x -> (x.getStartTime().getTime() <= item.getFeedbackTime().getTime() && x.getEndTime().getTime() > item.getFeedbackTime().getTime())).findFirst().orElse(null);
|
if (Func.isNotEmpty(matchDto)) {
|
WorkstationFeedbackTimePointDTO tempTime = (WorkstationFeedbackTimePointDTO)BeanUtil.copyProperties(item, WorkstationFeedbackTimePointDTO.class);
|
tempTime.setFeedbackId(matchDto.getFeedbackId());
|
tempTime.setFeedbackDetailId(matchDto.getFeedbackDetailId());
|
tempTime.setWcs(matchDto.getWcs());
|
result.add(tempTime);
|
}
|
continue;
|
}
|
result.add(item);
|
}
|
for (int i = 0; i < result.size(); i++) {
|
WorkstationFeedbackTimePointDTO temp = result.get(i);
|
if (FeedbackTimePointEnum.CROSS_POINT.isEqual(temp.getPointEnum().getValue()))
|
if (FeedbackTimePointEnum.END_POINT.isEqual(((WorkstationFeedbackTimePointDTO)result.get(i + 1)).getPointEnum().getValue())) {
|
temp.setWcs(((WorkstationFeedbackTimePointDTO)result.get(i + 1)).getWcs());
|
temp.setFeedbackId(((WorkstationFeedbackTimePointDTO)result.get(i + 1)).getFeedbackId());
|
}
|
finallyResult.add(temp);
|
}
|
return finallyResult;
|
}
|
/*
|
// JADX WARN: Multi-variable type inference failed
|
public static List<WorkstationFeedbackTimePointDTO> buildFeedbackTimePointInfo(List<WorkstationFeedbackTimeQuantumDTO> feedbackTimeQuantumDTOList) {
|
List<WorkstationFeedbackTimePointDTO> result = new ArrayList<>();
|
List<WorkstationFeedbackTimePointDTO> remove = new ArrayList<>();
|
if (Func.isNotEmpty(feedbackTimeQuantumDTOList)) {
|
for (int i = 0; i < feedbackTimeQuantumDTOList.size(); i++) {
|
WorkstationFeedbackTimeQuantumDTO x = feedbackTimeQuantumDTOList.get(i);
|
WorkstationFeedbackTimePointDTO startTimePoint = new WorkstationFeedbackTimePointDTO().setFeedbackId(x.getFeedbackId()).setReportTime(x.getFeedbackTime()).setFeedbackDetailId(x.getFeedbackDetailId()).setFeedbackTime(x.getStartTime()).setWcs(x.getWcs());
|
WorkstationFeedbackTimePointDTO endTimePoint = new WorkstationFeedbackTimePointDTO().setFeedbackId(x.getFeedbackId()).setReportTime(x.getFeedbackTime()).setFeedbackTime(x.getEndTime()).setFeedbackDetailId(x.getFeedbackDetailId()).setWcs(x.getWcs());
|
result.add(startTimePoint);
|
result.add(endTimePoint);
|
}
|
}
|
if (Func.isNotEmpty(result)) {
|
result = (List) result.stream().sorted(Comparator.comparing((v0) -> {
|
return v0.getReportTime();
|
}).thenComparing((v0) -> {
|
return v0.getFeedbackTime();
|
})).collect(Collectors.toList());
|
}
|
for (int i2 = 0; i2 < result.size(); i2++) {
|
result.get(i2).setIndex(Integer.valueOf(i2));
|
}
|
getCrossFeedbackTimePoints(result);
|
List<WorkstationFeedbackTimePointDTO> finalResult = getEffectFeedbackTimePoints(result, remove);
|
return fixFeedbackTimePointInfo(feedbackTimeQuantumDTOList, buildFeedbackTimePointsCompleteInfo(finalResult, remove));
|
}
|
|
private static List<WorkstationFeedbackTimePointDTO> fixFeedbackTimePointInfo(List<WorkstationFeedbackTimeQuantumDTO> feedbackTimeQuantumDTOList, List<WorkstationFeedbackTimePointDTO> finalResult) {
|
List<WorkstationFeedbackTimePointDTO> result = new ArrayList<>();
|
List<WorkstationFeedbackTimePointDTO> finallyResult = new ArrayList<>();
|
new ArrayList();
|
List<WorkstationFeedbackTimeQuantumDTO> effectFeedbackTimeQuantumList = (List) feedbackTimeQuantumDTOList.stream().sorted(Comparator.comparing((v0) -> {
|
return v0.getFeedbackTime();
|
}).thenComparing((v0) -> {
|
return v0.getStartTime();
|
}).reversed()).collect(Collectors.toList());
|
for (WorkstationFeedbackTimePointDTO item : finalResult) {
|
if (FeedbackTimePointEnum.CROSS_POINT.isEqual(item.getPointEnum().getValue())) {
|
WorkstationFeedbackTimeQuantumDTO matchDto = effectFeedbackTimeQuantumList.stream().filter(x -> {
|
return x.getStartTime().getTime() <= item.getFeedbackTime().getTime() && x.getEndTime().getTime() > item.getFeedbackTime().getTime();
|
}).findFirst().orElse(null);
|
if (Func.isNotEmpty(matchDto)) {
|
WorkstationFeedbackTimePointDTO tempTime = (WorkstationFeedbackTimePointDTO) BeanUtil.copyProperties(item, WorkstationFeedbackTimePointDTO.class);
|
tempTime.setFeedbackId(matchDto.getFeedbackId());
|
tempTime.setFeedbackDetailId(matchDto.getFeedbackDetailId());
|
tempTime.setWcs(matchDto.getWcs());
|
result.add(tempTime);
|
}
|
} else {
|
result.add(item);
|
}
|
}
|
for (int i = 0; i < result.size(); i++) {
|
WorkstationFeedbackTimePointDTO temp = result.get(i);
|
if (FeedbackTimePointEnum.CROSS_POINT.isEqual(temp.getPointEnum().getValue()) && FeedbackTimePointEnum.END_POINT.isEqual(result.get(i + 1).getPointEnum().getValue())) {
|
temp.setWcs(result.get(i + 1).getWcs());
|
temp.setFeedbackId(result.get(i + 1).getFeedbackId());
|
}
|
finallyResult.add(temp);
|
}
|
return finallyResult;
|
}
|
|
|
|
|
|
private static boolean checkIsCrossFeedbackTimePoint(WorkstationFeedbackTimePointDTO pointDTO, List<WorkstationFeedbackTimePointDTO> originalPointsList, List<WorkstationFeedbackTimePointDTO> removeList) {
|
WorkstationFeedbackTimePointDTO exits;
|
List<WorkstationFeedbackTimePointDTO> minList = (List) originalPointsList.stream().filter(x -> {
|
return x.getFeedbackTime().getTime() < pointDTO.getFeedbackTime().getTime();
|
}).collect(Collectors.toList());
|
if (Func.isEmpty(minList)) {
|
return false;
|
}
|
List<WorkstationFeedbackTimePointDTO> maxList = (List) originalPointsList.stream().filter(x2 -> {
|
return x2.getFeedbackTime().getTime() > pointDTO.getFeedbackTime().getTime();
|
}).collect(Collectors.toList());
|
if (Func.isEmpty(maxList)) {
|
return false;
|
}
|
for (WorkstationFeedbackTimePointDTO item : minList) {
|
WorkstationFeedbackTimePointDTO exits2 = maxList.stream().filter(x3 -> {
|
return x3.getFeedbackId().equals(item.getFeedbackId());
|
}).findAny().orElse(null);
|
if (Func.isNotEmpty(exits2)) {
|
return true;
|
}
|
}
|
for (WorkstationFeedbackTimePointDTO item2 : maxList) {
|
if (Func.isNotEmpty(item2.getFeedbackDetailId())) {
|
exits = removeList.stream().filter(x4 -> {
|
return Func.isNotEmpty(x4.getFeedbackDetailId()) && x4.getFeedbackDetailId().equals(item2.getFeedbackDetailId()) && x4.getFeedbackTime().getTime() <= pointDTO.getFeedbackTime().getTime();
|
}).findAny().orElse(null);
|
} else {
|
exits = removeList.stream().filter(x5 -> {
|
return x5.getFeedbackId().equals(item2.getFeedbackId()) && x5.getFeedbackTime().getTime() <= pointDTO.getFeedbackTime().getTime();
|
}).findAny().orElse(null);
|
}
|
if (Func.isNotEmpty(exits)) {
|
return true;
|
}
|
}
|
return false;
|
}
|
*/
|
public static List<WorkstationFeedbackTimeQuantumDTO> buildFeedbackTimeQuantum(List<WorkstationFeedbackTimePointDTO> effectFeedbackList) {
|
List<WorkstationFeedbackTimeQuantumDTO> result = new ArrayList<>();
|
List<WorkstationFeedbackTimePointDTO> effectFeedbackList2 = effectFeedbackList.stream().sorted(Comparator.comparing((v0) -> {
|
return v0.getFeedbackTime();
|
})).collect(Collectors.toList());
|
for (int i = 0; i < effectFeedbackList2.size() - 1; i++) {
|
WorkstationFeedbackTimePointDTO currentFeedbackPoint = effectFeedbackList2.get(i);
|
if (FeedbackTimePointEnum.END_POINT.isEqual(currentFeedbackPoint.getPointEnum().getValue())) {
|
break;
|
}
|
WorkstationFeedbackTimePointDTO nextFeedbackPoint = effectFeedbackList2.get(i + 1);
|
WorkstationFeedbackTimeQuantumDTO tempFeedback = new WorkstationFeedbackTimeQuantumDTO();
|
tempFeedback.setFeedbackId(currentFeedbackPoint.getFeedbackId());
|
tempFeedback.setStartTime(currentFeedbackPoint.getFeedbackTime());
|
tempFeedback.setEndTime(nextFeedbackPoint.getFeedbackTime());
|
tempFeedback.setWcs(currentFeedbackPoint.getWcs());
|
result.add(tempFeedback);
|
}
|
return result;
|
}
|
/*
|
public static Long getStartFeedbackTimePoint(Long workstationId, WorkstationStateMapper stateMapper, List<WorkstationState> processingStateList) {
|
if (Func.isNotEmpty(processingStateList)) {
|
//未同步反馈点的最早一条数据
|
Long startTime = processingStateList.stream().sorted(Comparator.comparing(WorkstationState::getTs)).collect(Collectors.toList()).get(0).getTs();//最早一条的ts
|
|
//查询在反馈点之前一条已同步的数据(小于startTime的最后一条、已同步，IsFixPoint=false的数据)
|
WorkstationState startNoFixpoint = stateMapper.getLastWorkstationState(Wrappers.<WorkstationState>lambdaQuery()
|
.eq(WorkstationState::getWorkstationId, workstationId)
|
.lt(WorkstationState::getTs, startTime)
|
.eq(WorkstationState::getIsSync, Boolean.TRUE)
|
.eq(WorkstationState::getIsFixPoint, Boolean.FALSE)
|
|
.ne(WorkstationState::getIsDeleted, Boolean.TRUE));
|
|
|
if (Func.isNotEmpty(startNoFixpoint)) {
|
startTime = startNoFixpoint.getTs();
|
}
|
return startTime;
|
}
|
return null;
|
}
|
*/
|
/**
|
*
|
* @param workstationId
|
* @param stateMapper
|
* @param processingStateList 未同步反馈点集合
|
* @return
|
*/
|
/*
|
public static Long getEndFeedbackTimePoint(Long workstationId, WorkstationStateMapper stateMapper, List<WorkstationState> processingStateList) {
|
Long result = null;
|
if (Func.isNotEmpty(processingStateList)) {
|
List<WorkstationState> processingStateList2 = processingStateList.stream().sorted(Comparator.comparing(WorkstationState::getTs)).collect(Collectors.toList());
|
WorkstationState endTimePoint = processingStateList2.get(processingStateList2.size() - 1);//最晚的一条时间
|
|
if (FeedbackTimePointEnum.END_POINT.isEqual(endTimePoint.getFeedbackPointType())) {//如果该反馈点是结束时间，则查找 第一个 时间晚于该反馈点的已同步状态点
|
WorkstationState endNoFixPoint = stateMapper.getFirstWorkstationState(Wrappers.<WorkstationState>lambdaQuery()
|
.eq(WorkstationState::getWorkstationId, workstationId).
|
gt(WorkstationState::getTs, endTimePoint.getTs())
|
.eq(WorkstationState::getIsSync, Boolean.TRUE)
|
.eq(WorkstationState::getIsFixPoint, Boolean.FALSE)
|
.ne(WorkstationState::getIsDeleted, Boolean.TRUE));
|
if (Func.isNotEmpty(endNoFixPoint)) {
|
result = endNoFixPoint.getTs();
|
}
|
}
|
}
|
return result;
|
}
|
*/
|
/**
|
* 获得最后一个已同步非反馈点的时间，或者最早一个未同步非反馈点时间
|
* @param workstationId
|
* @param stateMapper
|
* @return
|
*/
|
public static Long getNormalStartTimePoint(Long workstationId, DeviceStateMapper stateMapper) {
|
//isFixPoint 必须是false
|
//获取isSync=true，NO_FEED_BACK_POINT的状态数据
|
/*
|
DeviceState resultTimePoint = stateMapper.getLastWorkstationState( Wrappers.<DeviceState>lambdaQuery()
|
.eq(DeviceState::getWorkstationId, workstationId).eq(DeviceState::getIsSync, Boolean.TRUE).eq(DeviceState::getIsFixPoint, Boolean.FALSE)
|
.eq(DeviceState::getFeedbackPointType, FeedbackTimePointEnum.NO_FEED_BACK_POINT.getValue()).ne(DeviceState::getIsDeleted, Boolean.TRUE));
|
*/
|
DeviceState resultTimePoint = stateMapper.lastSyncedNoFeedbackPointState(workstationId);
|
if (Func.isEmpty(resultTimePoint)) {
|
//获取isSync=false,fixpoint=false，NO_FEED_BACK_POINT的数据
|
/*
|
resultTimePoint = stateMapper.getFirstWorkstationState(Wrappers.<DeviceState>lambdaQuery().eq(DeviceState::getWorkstationId, workstationId)
|
.eq(DeviceState::getIsSync, Boolean.FALSE)
|
.eq(DeviceState::getIsFixPoint, Boolean.FALSE)
|
.eq(DeviceState::getFeedbackPointType, FeedbackTimePointEnum.NO_FEED_BACK_POINT.getValue())
|
.ne(DeviceState::getIsDeleted, Boolean.TRUE));
|
*/
|
resultTimePoint = stateMapper.firstNotSyncedNofeedbackPointState(workstationId);
|
}
|
if (Func.isNotEmpty(resultTimePoint)) {
|
return resultTimePoint.getTime();
|
}
|
return null;
|
}
|
}
|
