加入状态反馈，还没具体测试

yangys

2024-09-27 26f8e5990686bdba2119024a260d986266506757

 collect/src/main/java/com/qianwen/mdc/collect/utils/FeedbackAnalyseUtils.java

@@ -1,24 +1,25 @@
package com.qianwen.mdc.collect.utils;

import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import java.lang.invoke.SerializedLambda;
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)) {
@@ -29,7 +30,7 @@
                temp.setWcs(item.getWorkstationWcsFeedback().getWcs());
                if (Func.isNotEmpty(item.getWorkstationWcsFeedbackDetails())) {
                    item.getWorkstationWcsFeedbackDetails().forEach(detail -> {
                        WorkstationFeedbackTimeQuantumDTO tempTime = (WorkstationFeedbackTimeQuantumDTO) BeanUtil.copyProperties(temp, WorkstationFeedbackTimeQuantumDTO.class);
                        WorkstationFeedbackTimeQuantumDTO tempTime = BeanUtil.copyProperties(temp, WorkstationFeedbackTimeQuantumDTO.class);
                        tempTime.setStartTime(detail.getStartTime());
                        tempTime.setFeedbackDetailId(detail.getId());
                        tempTime.setEndTime(detail.getEndTime());
@@ -44,7 +45,183 @@
        }
        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<>();
@@ -109,105 +286,9 @@
        return finallyResult;
    }

    private static void getCrossFeedbackTimePoints(List<WorkstationFeedbackTimePointDTO> timePointList) {
        new ArrayList();
        if (Func.isNotEmpty(timePointList)) {
            for (WorkstationFeedbackTimePointDTO item : timePointList) {
                WorkstationFeedbackTimePointDTO start = timePointList.stream().filter(x -> {
                    return x.getFeedbackTime().getTime() < item.getFeedbackTime().getTime() && x.getIndex().intValue() < item.getIndex().intValue() && !x.getFeedbackId().equals(item.getFeedbackId());
                }).max(Comparator.comparing((v0) -> {
                    return v0.getIndex();
                })).orElse(null);
                WorkstationFeedbackTimePointDTO end = timePointList.stream().filter(x2 -> {
                    return x2.getFeedbackTime().getTime() > item.getFeedbackTime().getTime() && x2.getIndex().intValue() < item.getIndex().intValue() && !x2.getFeedbackId().equals(item.getFeedbackId());
                }).min(Comparator.comparing((v0) -> {
                    return v0.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) {
        new ArrayList();
        if (Func.isNotEmpty(effectFeedbackList)) {
            effectFeedbackList = (List) effectFeedbackList.stream().sorted(Comparator.comparing((v0) -> {
                return v0.getFeedbackTime();
            })).collect(Collectors.toList());
            for (int i = 0; i < effectFeedbackList.size(); i++) {
                if (i == 0) {
                    effectFeedbackList.get(0).setPointEnum(FeedbackTimePointEnum.START_POINT);
                } else if (i == effectFeedbackList.size() - 1) {
                    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 -> {
                        return x.getFeedbackTime().getTime() < currentPoint.getFeedbackTime().getTime() && !x.getFeedbackId().equals(currentPoint.getFeedbackId());
                    }).max(Comparator.comparing((v0) -> {
                        return v0.getFeedbackTime();
                    })).orElse(null);
                    WorkstationFeedbackTimePointDTO end = effectFeedbackList.stream().filter(x2 -> {
                        return x2.getFeedbackTime().getTime() > currentPoint.getFeedbackTime().getTime() && !x2.getFeedbackId().equals(currentPoint.getFeedbackId());
                    }).min(Comparator.comparing((v0) -> {
                        return v0.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())) {
                            effectFeedbackList.get(i).setPointEnum(FeedbackTimePointEnum.END_POINT);
                        }
                        if (prePoint.getFeedbackId().equals(currentPoint.getFeedbackId())) {
                            effectFeedbackList.get(i).setPointEnum(FeedbackTimePointEnum.END_POINT);
                        } else {
                            if (prePoint.getPointEnum().isEqual(FeedbackTimePointEnum.START_POINT.getValue())) {
                                effectFeedbackList.get(i).setPointEnum(FeedbackTimePointEnum.CROSS_POINT);
                            }
                            if (prePoint.getPointEnum().isEqual(FeedbackTimePointEnum.END_POINT.getValue())) {
                                effectFeedbackList.get(i).setPointEnum(FeedbackTimePointEnum.START_POINT);
                            }
                        }
                    }
                }
            }
        }
        return effectFeedbackList;
    }

    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().intValue() > pointDTO.getIndex().intValue() && x2.getFeedbackTime().getTime() >= pointDTO.getFeedbackTime().getTime();
        }).count();
        if (max <= 0) {
            return true;
        }
        return false;
    }
    

    private static boolean checkIsCrossFeedbackTimePoint(WorkstationFeedbackTimePointDTO pointDTO, List<WorkstationFeedbackTimePointDTO> originalPointsList, List<WorkstationFeedbackTimePointDTO> removeList) {
        WorkstationFeedbackTimePointDTO exits;
@@ -247,10 +328,10 @@
        }
        return false;
    }

   */
    public static List<WorkstationFeedbackTimeQuantumDTO> buildFeedbackTimeQuantum(List<WorkstationFeedbackTimePointDTO> effectFeedbackList) {
        List<WorkstationFeedbackTimeQuantumDTO> result = new ArrayList<>();
        List<WorkstationFeedbackTimePointDTO> effectFeedbackList2 = (List) effectFeedbackList.stream().sorted(Comparator.comparing((v0) -> {
        List<WorkstationFeedbackTimePointDTO> effectFeedbackList2 = effectFeedbackList.stream().sorted(Comparator.comparing((v0) -> {
            return v0.getFeedbackTime();
        })).collect(Collectors.toList());
        for (int i = 0; i < effectFeedbackList2.size() - 1; i++) {
@@ -268,7 +349,7 @@
        }
        return result;
    }

    /*
    public static Long getStartFeedbackTimePoint(Long workstationId, WorkstationStateMapper stateMapper, List<WorkstationState> processingStateList) {
        if (Func.isNotEmpty(processingStateList)) {
           //未同步反馈点的最早一条数据