件数计算

fhKeeper/formulahousekeeper/management-workshop/src/main/java/com/management/platform/service/impl/ReportServiceImpl.java

@@ -4798,8 +4798,12 @@ public class ReportServiceImpl extends ServiceImpl<ReportMapper, Report> impleme
                 //过滤日报所填了哪些工序
                 List<Integer> hasReportProdProduceIds = hasReportList.stream().map(Report::getProdProcedureId).collect(Collectors.toList());
                 //如果全包含了所需路过的全部工序内容 就算完整件数
+                System.out.println("steelNum=="+steelNum);
                 if(hasReportProdProduceIds.containsAll(targetProdProduceIds)){
                     integrated+=1;
+                    if (product.getName().equals("测试001")) {
+                        System.out.println("测试001==="+integrated);
+                    }
                     integratedSteelNums.add(steelNum);
                     List<ReportSteelNum> newReportSteelNums=new ArrayList<>();
                     //作为完整的钢印号直接去掉
@@ -4820,94 +4824,167 @@ public class ReportServiceImpl extends ServiceImpl<ReportMapper, Report> impleme
                     steelNums=newSteelNums;
                 }
             }
-            //计算凑整件数
-            for (String steelNum : steelNums) {
-                if(roundingSteelNums.contains(steelNum)){
-                    continue;
-                }
+
+            //以钢印号为基准，进行计算，剔除完整件数的钢印号
+            List<String> noCompleteSteelNums = steelNums.stream().filter(s->!integratedSteelNums.contains(s)).collect(Collectors.toList());
+            //列出每一道工序上的钢印号集合
+            HashMap<Integer, List> prodProcedureSteelNumMap = new HashMap<>();
+            for (String steelNum : noCompleteSteelNums) {
                 //找到该产品下填报了该钢印号的所有日报数据
                 List<Integer> hasReportIds = reportSteelNums.stream().filter(r -> r.getSteelNum().equals(steelNum)).collect(Collectors.toList()).stream().map(ReportSteelNum::getReportId).collect(Collectors.toList());
                 List<Report> hasReportList = targetReportList.stream().filter(r->hasReportIds.contains(r.getId())).collect(Collectors.toList());
                 //过滤日报所填了哪些工序
                 List<Integer> hasReportProdProduceIds = hasReportList.stream().map(Report::getProdProcedureId).collect(Collectors.toList());
-                //如果没有包含所需路过的全部工序内容 (有任意工序可以共同完成)-->凑整
-                //根据当前钢印号已经填报的内容 对比出没有填报的工序内容
-                if(!hasReportProdProduceIds.containsAll(targetProdProduceIds)){
-                    List<Integer> hasNotReportProdProduceIds=new ArrayList<>();
-                    targetProdProduceIds.forEach(tp->{
-                        if(!hasReportProdProduceIds.contains(tp)){
-                            hasNotReportProdProduceIds.add(tp);
-                        }
-                    });
-                    //所有已填报的钢印号有任意满足 上面未填报工序集合 就算凑整件数
-                    //找到所有可能填报了未填报其工序日报数据
-                    List<Report> comparatorReportList = targetReportList.stream().filter(r ->r.getSteelNumArray()!=null&&JSONArray.parseArray(r.getSteelNumArray()).stream().anyMatch(a->!integratedSteelNums.contains(a))&&r.getProdProcedureId()!=null && hasNotReportProdProduceIds.contains(r.getProdProcedureId())).collect(Collectors.toList());
-                    //过滤这些日报下的工序数据
-                    List<Integer> targetComparator = comparatorReportList.stream().map(Report::getProdProcedureId).distinct().collect(Collectors.toList());
-                    boolean match = targetComparator.containsAll(hasNotReportProdProduceIds);
-                    if(match){
-                        rounding+=1;
-                        roundingSteelNums.add(steelNum);
-                        //找到参与凑整的钢印号
-                        List<Integer> hasJoinReportIds = comparatorReportList.stream().map(Report::getId).collect(Collectors.toList());
-                        roundingSteelNums.addAll(reportSteelNums.stream().filter(r -> hasJoinReportIds.contains(r.getReportId())).map(ReportSteelNum::getSteelNum).collect(Collectors.toList()));
-                        List<ReportSteelNum> newReportSteelNums=new ArrayList<>();
-                        //作为凑整的钢印号直接去掉
-                        for (int i = 0; i < reportSteelNums.size(); i++) {
-                            if(reportSteelNums.get(i).getSteelNum().equals(steelNum)||roundingSteelNums.contains(reportSteelNums.get(i).getSteelNum())){
-                                continue;
-                            }
-                            newReportSteelNums.add(reportSteelNums.get(i));
-                        }
-                        reportSteelNums=newReportSteelNums;
-                        List<String> newSteelNums=new ArrayList<>();
-                        for (int i = 0; i < steelNums.size(); i++) {
-                            if(steelNums.get(i).equals(steelNum)){
-                                continue;
-                            }
-                            newSteelNums.add(steelNums.get(i));
-                        }
-                        steelNums=newSteelNums;
+                for (Integer targetProdProduceId : hasReportProdProduceIds) {
+                    if (prodProcedureSteelNumMap.containsKey(targetProdProduceId)) {
+                        List<String> prodProcedureSteelNum = prodProcedureSteelNumMap.get(targetProdProduceId);
+                        prodProcedureSteelNum.add(steelNum);
+                        prodProcedureSteelNumMap.put(targetProdProduceId, prodProcedureSteelNum);
+                    } else {
+                        List<String> prodProcedureSteelNum = new ArrayList<>();
+                        prodProcedureSteelNum.add(steelNum);
+                        prodProcedureSteelNumMap.put(targetProdProduceId, prodProcedureSteelNum);
                     }
                 }
             }
-            for(String steelNum : steelNums){
-                //找到该产品下填报了该钢印号的所有日报数据
-                List<Integer> hasReportIds = reportSteelNums.stream().filter(r -> r.getSteelNum().equals(steelNum)).collect(Collectors.toList()).stream().map(ReportSteelNum::getReportId).collect(Collectors.toList());
-                List<Report> hasReportList = targetReportList.stream().filter(r->hasReportIds.contains(r.getId())).collect(Collectors.toList());
-                //过滤日报所填了哪些工序
-                List<Integer> hasReportProdProduceIds = hasReportList.stream().map(Report::getProdProcedureId).collect(Collectors.toList());
-                if(!hasReportProdProduceIds.containsAll(targetProdProduceIds)){
-                    List<Integer> hasNotReportProdProduceIds=new ArrayList<>();
-                    targetProdProduceIds.forEach(tp->{
-                        if(!hasReportProdProduceIds.contains(tp)){
-                            hasNotReportProdProduceIds.add(tp);
-                        }
-                    });
-                    //所有已填报的钢印号有任意满足 上面未填报工序集合 就算凑整件数
-                    //找到所有填报了未填报其工序日报数据
-                    List<Report> comparatorReportList = targetReportList.stream().filter(r ->r.getProdProcedureId()!=null && hasNotReportProdProduceIds.contains(r.getProdProcedureId())).collect(Collectors.toList());
-                    //过滤这些日报下的工序数据
-                    List<Integer> targetComparator = comparatorReportList.stream().map(Report::getProdProcedureId).distinct().collect(Collectors.toList());
-                    boolean match = targetComparator.containsAll(hasNotReportProdProduceIds);
-                    if(match){
-                        //计算当前产品的总预算工时
-                        BigDecimal reduce = targetProdProcedures.stream().map(i -> new BigDecimal(i.getWorkingTime())).reduce(BigDecimal.ZERO, BigDecimal::add);
-                        //利用上面找到的所填了哪些工序 按照所在工序占比计算
-                        List<ProdProcedure> hasReportProcedures = targetProdProcedures.stream().filter(ts -> hasReportProdProduceIds.contains(ts.getId())).collect(Collectors.toList());
-                        BigDecimal bigDecimal=new BigDecimal(0);
-                        for (ProdProcedure hasReportProcedure : hasReportProcedures) {
-                            //找到当前工序所在产品总预算工时
-                            BigDecimal decimal = new BigDecimal(hasReportProcedure.getWorkingTime());
-                            BigDecimal divide = decimal.divide(reduce, 2,BigDecimal.ROUND_HALF_UP);
-                            BigDecimal check = new BigDecimal(1);
-                            check=check.multiply(divide).setScale(2,BigDecimal.ROUND_HALF_UP);
-                            bigDecimal=bigDecimal.add(check).setScale(2,BigDecimal.ROUND_HALF_UP);
+            //得到了一个工序对应的钢印号集合，然后进行计算工序是否能够匹配到完整产品的工序
+            boolean allMatch = true;
+            //计算最小堆高度，就是凑整的数量
+            int minHeapHeight = Integer.MAX_VALUE;
+            for (Integer curProcedureId : targetProdProduceIds) {
+                boolean find = false;
+                for (Integer integer : prodProcedureSteelNumMap.keySet()) {
+                    if (integer.equals(curProcedureId)) {
+                        find = true;
+                        break;
+                    }
+                }
+                if (find) {
+                    int size = prodProcedureSteelNumMap.get(curProcedureId).size();
+                    if (size < minHeapHeight) {
+                        minHeapHeight = size;
+                    }
+                } else {
+                    //有一个工序凑不完整，就不算凑整件数
+                    allMatch = false;
+                    break;
+                }
+            }
+
+            List<String> leftSteelNums =new ArrayList<>();
+            if (allMatch) {
+                rounding = minHeapHeight;
+                //去掉凑整的钢印号，按堆中的高度进行去除
+                for (Integer curProcedureId : prodProcedureSteelNumMap.keySet()) {
+                    List<String> prodProcedureSteelNum = prodProcedureSteelNumMap.get(curProcedureId);
+                    for (int i = 0; i < prodProcedureSteelNum.size(); i++) {
+                        if (i < minHeapHeight) {
+                            roundingSteelNums.add(prodProcedureSteelNum.get(i));
+                        } else {
+                            leftSteelNums.add(prodProcedureSteelNum.get(i));
                         }
-                        converted=converted.add(bigDecimal);
                     }
                 }
+            } else {
+                leftSteelNums = noCompleteSteelNums;
             }
+            if (product.getName().equals("测试001")) {
+                System.out.println("测试001  leftSteelNums=="+leftSteelNums);
+                for (String left : leftSteelNums) {
+                    System.out.println("折算的工序：：" + left);
+                }
+            }
+
+
+
+            //计算凑整件数
+//            for (String steelNum : steelNums) {
+//                if(roundingSteelNums.contains(steelNum)){
+//                    continue;
+//                }
+//                //找到该产品下填报了该钢印号的所有日报数据
+//                List<Integer> hasReportIds = reportSteelNums.stream().filter(r -> r.getSteelNum().equals(steelNum)).collect(Collectors.toList()).stream().map(ReportSteelNum::getReportId).collect(Collectors.toList());
+//                List<Report> hasReportList = targetReportList.stream().filter(r->hasReportIds.contains(r.getId())).collect(Collectors.toList());
+//                //过滤日报所填了哪些工序
+//                List<Integer> hasReportProdProduceIds = hasReportList.stream().map(Report::getProdProcedureId).collect(Collectors.toList());
+//                //如果没有包含所需路过的全部工序内容 (有任意工序可以共同完成)-->凑整
+//                //根据当前钢印号已经填报的内容 对比出没有填报的工序内容
+//                if(!hasReportProdProduceIds.containsAll(targetProdProduceIds)){
+//                    List<Integer> hasNotReportProdProduceIds=new ArrayList<>();
+//                    targetProdProduceIds.forEach(tp->{
+//                        if(!hasReportProdProduceIds.contains(tp)){
+//                            hasNotReportProdProduceIds.add(tp);
+//                        }
+//                    });
+//                    //所有已填报的钢印号有任意满足 上面未填报工序集合 就算凑整件数
+//                    //找到所有可能填报了未填报其工序日报数据
+//                    List<Report> comparatorReportList = targetReportList.stream().filter(r ->r.getSteelNumArray()!=null&&JSONArray.parseArray(r.getSteelNumArray()).stream().anyMatch(a->!integratedSteelNums.contains(a))&&r.getProdProcedureId()!=null && hasNotReportProdProduceIds.contains(r.getProdProcedureId())).collect(Collectors.toList());
+//                    //过滤这些日报下的工序数据
+//                    List<Integer> targetComparator = comparatorReportList.stream().map(Report::getProdProcedureId).distinct().collect(Collectors.toList());
+//                    boolean match = targetComparator.containsAll(hasNotReportProdProduceIds);
+//                    if(match){
+//                        rounding+=1;
+//                        roundingSteelNums.add(steelNum);
+//                        //找到参与凑整的钢印号
+//                        List<Integer> hasJoinReportIds = comparatorReportList.stream().map(Report::getId).collect(Collectors.toList());
+//                        roundingSteelNums.addAll(reportSteelNums.stream().filter(r -> hasJoinReportIds.contains(r.getReportId())).map(ReportSteelNum::getSteelNum).collect(Collectors.toList()));
+//                        List<ReportSteelNum> newReportSteelNums=new ArrayList<>();
+//                        //作为凑整的钢印号直接去掉
+//                        for (int i = 0; i < reportSteelNums.size(); i++) {
+//                            if(reportSteelNums.get(i).getSteelNum().equals(steelNum)||roundingSteelNums.contains(reportSteelNums.get(i).getSteelNum())){
+//                                continue;
+//                            }
+//                            newReportSteelNums.add(reportSteelNums.get(i));
+//                        }
+//                        reportSteelNums=newReportSteelNums;
+//                        List<String> newSteelNums=new ArrayList<>();
+//                        for (int i = 0; i < steelNums.size(); i++) {
+//                            if(steelNums.get(i).equals(steelNum)){
+//                                continue;
+//                            }
+//                            newSteelNums.add(steelNums.get(i));
+//                        }
+//                        steelNums=newSteelNums;
+//                    }
+//                }
+//            }
+//            for(String steelNum : steelNums){
+//                //找到该产品下填报了该钢印号的所有日报数据
+//                List<Integer> hasReportIds = reportSteelNums.stream().filter(r -> r.getSteelNum().equals(steelNum)).collect(Collectors.toList()).stream().map(ReportSteelNum::getReportId).collect(Collectors.toList());
+//                List<Report> hasReportList = targetReportList.stream().filter(r->hasReportIds.contains(r.getId())).collect(Collectors.toList());
+//                //过滤日报所填了哪些工序
+//                List<Integer> hasReportProdProduceIds = hasReportList.stream().map(Report::getProdProcedureId).collect(Collectors.toList());
+//                if(!hasReportProdProduceIds.containsAll(targetProdProduceIds)){
+//                    List<Integer> hasNotReportProdProduceIds=new ArrayList<>();
+//                    targetProdProduceIds.forEach(tp->{
+//                        if(!hasReportProdProduceIds.contains(tp)){
+//                            hasNotReportProdProduceIds.add(tp);
+//                        }
+//                    });
+//                    //所有已填报的钢印号有任意满足 上面未填报工序集合 就算凑整件数
+//                    //找到所有填报了未填报其工序日报数据
+//                    List<Report> comparatorReportList = targetReportList.stream().filter(r ->r.getProdProcedureId()!=null && hasNotReportProdProduceIds.contains(r.getProdProcedureId())).collect(Collectors.toList());
+//                    //过滤这些日报下的工序数据
+//                    List<Integer> targetComparator = comparatorReportList.stream().map(Report::getProdProcedureId).distinct().collect(Collectors.toList());
+//                    boolean match = targetComparator.containsAll(hasNotReportProdProduceIds);
+//                    if(match){
+//                        //计算当前产品的总预算工时
+//                        BigDecimal reduce = targetProdProcedures.stream().map(i -> new BigDecimal(i.getWorkingTime())).reduce(BigDecimal.ZERO, BigDecimal::add);
+//                        //利用上面找到的所填了哪些工序 按照所在工序占比计算
+//                        List<ProdProcedure> hasReportProcedures = targetProdProcedures.stream().filter(ts -> hasReportProdProduceIds.contains(ts.getId())).collect(Collectors.toList());
+//                        BigDecimal bigDecimal=new BigDecimal(0);
+//                        for (ProdProcedure hasReportProcedure : hasReportProcedures) {
+//                            //找到当前工序所在产品总预算工时
+//                            BigDecimal decimal = new BigDecimal(hasReportProcedure.getWorkingTime());
+//                            BigDecimal divide = decimal.divide(reduce, 2,BigDecimal.ROUND_HALF_UP);
+//                            BigDecimal check = new BigDecimal(1);
+//                            check=check.multiply(divide).setScale(2,BigDecimal.ROUND_HALF_UP);
+//                            bigDecimal=bigDecimal.add(check).setScale(2,BigDecimal.ROUND_HALF_UP);
+//                        }
+//                        converted=converted.add(bigDecimal);
+//                    }
+//                }
+//            }
             resultMap.put("integratedSteelNums",integratedSteelNums);
             resultMap.put("roundingSteelNums",roundingSteelNums);
             converted = converted.setScale(2, BigDecimal.ROUND_HALF_UP);