wms功能完善

pjb

1 天以前 2ded9514aa9a93ee440af0b1437d788fb052028b

 src/main/java/com/zy/common/service/CommonService.java

@@ -185,160 +185,165 @@
                    throw new CoolException("入空桶库输送线缓存任务数："+count+"，超配置缓存数：" + value);
                }
            }
            locMast = new LocMast();
            locMast.setCrnNo(4);
            locMast.setLocNo("");
            List<WrkMast> wrkMastList = wrkMastMapper.selectLastInEmptyLoc(); // 前面入空桶库的任务(未执行堆垛机入库)

            if (wrkMastList.size() == 0) {
//            if (wrkMastList.size() == 0) {
                // 取新库位组的第一个库位
                List<LocMast> locMasts = locMastService.selectList(new EntityWrapper<LocMast>().eq("crn_no", 4).eq("loc_sts", "O"));
                List<LocMast> collect = locMasts.stream().filter(locMast1 -> locMast1.getRow1() == 9 || locMast1.getRow1() == 11).collect(Collectors.toList());
                List<LocMast> collect1 = locMasts.stream().filter(locMast1 -> locMast1.getRow1() == 10 || locMast1.getRow1() == 12).collect(Collectors.toList()); // 第一个先放这两排
                if (collect.size() == 0 || collect1.size() == 0) {
                if (collect.size() - wrkMastList.size() <= 0 && collect1.size()  - wrkMastList.size() <= 0) {
                    log.error("-----空桶库无空库位----");
                    throw new CoolException("空桶库无空库位");
                }
                // 可用库位组
                List<LocMast> locMastList = new ArrayList<>();
                for(LocMast locMast1:collect) {
                    Optional<LocMast> first = collect1.stream().filter(locMast2 -> locMast1.getRow1() + 1 == locMast2.getRow1() && Objects.equals(locMast1.getLev1(), locMast2.getLev1())
                            && Objects.equals(locMast1.getBay1(), locMast2.getBay1())).findFirst();
                    first.ifPresent(locMastList::add);
                }

                if (locMastList.size() == 0) {
                    log.error("-----空桶库无对应空空桶组----");
                    throw new CoolException("空桶库无对应空空桶组");
                }
                String model = findLocNoAttributeVo.getModel(); // 当前桶类型
                if (model.equals("208L") && locMastList.size() <= 40 * 2 * 2) { // 最上面一层只能放208L，库位剩余量不多时，如果是208L桶入库，则先从最顶层放
                    locMastList = locMastList.stream().sorted(Comparator.comparing(LocMast::getLev1).reversed().thenComparing(LocMast::getBay1).thenComparing(LocMast::getRow1)).collect(Collectors.toList());
                } else {
                    locMastList = locMastList.stream().sorted(Comparator.comparing(LocMast::getLev1).thenComparing(LocMast::getBay1).thenComparing(LocMast::getRow1)).collect(Collectors.toList());
                }
                locMast = locMastList.get(0);

            } else {
                WrkMast wrkMast = wrkMastList.get(0); // 最后一个入空桶库任务
                // 前一个任务桶类型
                String oldModel = wrkMast.getPdcType();
                // 前一个任务尾托标识
                Integer oldCtnType = wrkMast.getCtnType();
                // 当前桶类型
                String matnr = findLocNoAttributeVo.getMatnr();
                if(findLocNoAttributeVo.getMatnr().equals(wrkMast.getPdcType())) { // 当前桶与前桶是一种类型
                    // 当前桶类型的任务有几个
                    long count = wrkMastList.stream().filter(wrkMast1 -> wrkMast1.getPdcType().equals(matnr)).count();
                    if (count % 2  == 0) { // 偶数，取一组新库位
                        // 取新库位组的第一个库位
                        List<LocMast> locMasts = locMastService.selectList(new EntityWrapper<LocMast>().eq("crn_no", 4).eq("loc_sts", "O"));
                        List<LocMast> collect = locMasts.stream().filter(locMast1 -> locMast1.getRow1() == 9 || locMast1.getRow1() == 11).collect(Collectors.toList());
                        List<LocMast> collect1 = locMasts.stream().filter(locMast1 -> locMast1.getRow1() == 10 || locMast1.getRow1() == 12).collect(Collectors.toList()); // 第一个先放这两排
                        if (collect.size() == 0 || collect1.size() == 0) {
                            log.error("-----空桶库无空库位----");
                            throw new CoolException("空桶库无空库位");
                        }
                        // 可用库位组
                        List<LocMast> locMastList = new ArrayList<>();
                        for(LocMast locMast1:collect) {
                            Optional<LocMast> first = collect1.stream().filter(locMast2 -> locMast1.getRow1() + 1 == locMast2.getRow1() && Objects.equals(locMast1.getLev1(), locMast2.getLev1())
                                    && Objects.equals(locMast1.getBay1(), locMast2.getBay1())).findFirst();
                            first.ifPresent(locMastList::add);
                        }

                        if (locMastList.size() == 0) {
                            log.error("-----空桶库无对应空空桶组----");
                            throw new CoolException("空桶库无对应空空桶组");
                        }
                        String model = findLocNoAttributeVo.getModel(); // 当前桶类型
                        if (model.equals("208L") && locMastList.size() <= 40 * 2 * 2) { // 最上面一层只能放208L，库位剩余量不多时，如果是208L桶入库，则先从最顶层放
                            locMastList = locMastList.stream().sorted(Comparator.comparing(LocMast::getLev1).reversed().thenComparing(LocMast::getBay1).thenComparing(LocMast::getRow1)).collect(Collectors.toList());
                        } else {
                            locMastList = locMastList.stream().sorted(Comparator.comparing(LocMast::getLev1).thenComparing(LocMast::getBay1).thenComparing(LocMast::getRow1)).collect(Collectors.toList());
                        }
                        locMast = locMastList.get(0);
                    } else { // 奇数，取前一库位对应的空库位
                        String locNo = wrkMast.getLocNo();
                        int row = Integer.parseInt(locNo.substring(0, 2));
                        if(row == 10 || row == 12) {
                            String newLocNo =(row == 10 ? "09" : "11") + locNo.substring(2);
                            locMast = locMastService.selectOne(new EntityWrapper<LocMast>().eq("loc_no", newLocNo).eq("loc_sts","O"));
                            if (locMast == null) {
                                log.error("-----与前面桶类型一样，前面该桶类型任务数是奇数，10，12排,但是对应库位不为空----");
                                throw new CoolException("与前面桶类型一样，前面该桶类型任务数是奇数，是10，12排,但是对应库位不为空");
                            }
                        } else {
                            log.error("-----与前面桶类型一样，前面该桶类型任务数是奇数，但是不是10，12排----");
                            throw new CoolException("与前面桶类型一样，前面该桶类型任务数是奇数，但是不是10，12排");
                        }
                    }
                } else { // 当前桶与前桶不是一种类型
                      if(oldCtnType == 1) { // 前面是尾桶
                          // 取新库位组的第一个库位
                          List<LocMast> locMasts = locMastService.selectList(new EntityWrapper<LocMast>().eq("crn_no", 4).eq("loc_sts", "O"));
                          List<LocMast> collect = locMasts.stream().filter(locMast1 -> locMast1.getRow1() == 9 || locMast1.getRow1() == 11).collect(Collectors.toList());
                          List<LocMast> collect1 = locMasts.stream().filter(locMast1 -> locMast1.getRow1() == 10 || locMast1.getRow1() == 12).collect(Collectors.toList()); // 第一个先放这两排
                          if (collect.size() == 0 || collect1.size() == 0) {
                              log.error("-----空桶库无空库位----");
                              throw new CoolException("空桶库无空库位");
                          }
                          // 可用库位组
                          List<LocMast> locMastList = new ArrayList<>();
                          for(LocMast locMast1:collect) {
                              Optional<LocMast> first = collect1.stream().filter(locMast2 -> locMast1.getRow1() + 1 == locMast2.getRow1() && Objects.equals(locMast1.getLev1(), locMast2.getLev1())
                                      && Objects.equals(locMast1.getBay1(), locMast2.getBay1())).findFirst();
                              first.ifPresent(locMastList::add);
                          }

                          if (locMastList.size() == 0) {
                              log.error("-----空桶库无对应空空桶组----");
                              throw new CoolException("空桶库无对应空空桶组");
                          }
                          String model = findLocNoAttributeVo.getModel(); // 当前桶类型
                          if (model.equals("208L") && locMastList.size() <= 40 * 2 * 2) { // 最上面一层只能放208L，库位剩余量不多时，如果是208L桶入库，则先从最顶层放
                              locMastList = locMastList.stream().sorted(Comparator.comparing(LocMast::getLev1).reversed().thenComparing(LocMast::getBay1).thenComparing(LocMast::getRow1)).collect(Collectors.toList());
                          } else {
                              locMastList = locMastList.stream().sorted(Comparator.comparing(LocMast::getLev1).thenComparing(LocMast::getBay1).thenComparing(LocMast::getRow1)).collect(Collectors.toList());
                          }
                          locMast = locMastList.get(0);
                      } else { // 前面不是尾桶
                          // 判断前面入空桶库任务数量(未执行堆垛机入库)
                          long count = wrkMastList.stream().filter(wrkMast1 -> wrkMast1.getPdcType().equals(oldModel)).count();
                          if (count % 2 == 0) { // 偶数，可以入库
                              // 取新库位组的第一个库位
                              List<LocMast> locMasts = locMastService.selectList(new EntityWrapper<LocMast>().eq("crn_no", 4).eq("loc_sts", "O"));
                              List<LocMast> collect = locMasts.stream().filter(locMast1 -> locMast1.getRow1() == 9 || locMast1.getRow1() == 11).collect(Collectors.toList());
                              List<LocMast> collect1 = locMasts.stream().filter(locMast1 -> locMast1.getRow1() == 10 || locMast1.getRow1() == 12).collect(Collectors.toList()); // 第一个先放这两排
                              if (collect.size() == 0 || collect1.size() == 0) {
                                  log.error("-----空桶库无空库位----");
                                  throw new CoolException("空桶库无空库位");
                              }
                              // 可用库位组
                              List<LocMast> locMastList = new ArrayList<>();
                              for(LocMast locMast1:collect) {
                                  Optional<LocMast> first = collect1.stream().filter(locMast2 -> locMast1.getRow1() + 1 == locMast2.getRow1() && Objects.equals(locMast1.getLev1(), locMast2.getLev1())
                                          && Objects.equals(locMast1.getBay1(), locMast2.getBay1())).findFirst();
                                  first.ifPresent(locMastList::add);
                              }

                              if (locMastList.size() == 0) {
                                  log.error("-----空桶库无对应空空桶组----");
                                  throw new CoolException("空桶库无对应空空桶组");
                              }
                              String model = findLocNoAttributeVo.getModel(); // 当前桶类型
                              if (model.equals("208L") && locMastList.size() <= 40 * 2 * 2) { // 最上面一层只能放208L，库位剩余量不多时，如果是208L桶入库，则先从最顶层放
                                  locMastList = locMastList.stream().sorted(Comparator.comparing(LocMast::getLev1).reversed().thenComparing(LocMast::getBay1).thenComparing(LocMast::getRow1)).collect(Collectors.toList());
                              } else {
                                  locMastList = locMastList.stream().sorted(Comparator.comparing(LocMast::getLev1).thenComparing(LocMast::getBay1).thenComparing(LocMast::getRow1)).collect(Collectors.toList());
                              }
                              locMast = locMastList.get(0);
                          } else { // 奇数，不可以入库
                              // 自动给前面任务补尾桶信号
                              wrkMastService.updateCtnType(wrkMast);
                              log.error("-----与前面桶类型不一样，前面桶不是尾桶，前面该桶类型任务数不是偶数，不能入库----");
                              throw new CoolException("与前面桶类型不一样，前面桶不是尾桶，前面该桶类型任务数不是偶数，不能入库");
                          }
                      }
                }
            }
//                // 可用库位组
//                List<LocMast> locMastList = new ArrayList<>();
//                for(LocMast locMast1:collect) {
//                    Optional<LocMast> first = collect1.stream().filter(locMast2 -> locMast1.getRow1() + 1 == locMast2.getRow1() && Objects.equals(locMast1.getLev1(), locMast2.getLev1())
//                            && Objects.equals(locMast1.getBay1(), locMast2.getBay1())).findFirst();
//                    first.ifPresent(locMastList::add);
//                }
//
//                if (locMastList.size() == 0) {
//                    log.error("-----空桶库无对应空空桶组----");
//                    throw new CoolException("空桶库无对应空空桶组");
//                }
//                String model = findLocNoAttributeVo.getModel(); // 当前桶类型
//                if (model.equals("208L") && locMastList.size() <= 40 * 2 * 2) { // 最上面一层只能放208L，库位剩余量不多时，如果是208L桶入库，则先从最顶层放
//                    locMastList = locMastList.stream().sorted(Comparator.comparing(LocMast::getLev1).reversed().thenComparing(LocMast::getBay1).thenComparing(LocMast::getRow1)).collect(Collectors.toList());
//                } else {
//                    locMastList = locMastList.stream().sorted(Comparator.comparing(LocMast::getLev1).thenComparing(LocMast::getBay1).thenComparing(LocMast::getRow1)).collect(Collectors.toList());
//                }
//                locMast = locMastList.get(0);
//
//            } else {
//                WrkMast wrkMast = wrkMastList.get(0); // 最后一个入空桶库任务
//                // 前一个任务桶类型
//                String oldModel = wrkMast.getPdcType();
//                // 前一个任务尾托标识
//                Integer oldCtnType = wrkMast.getCtnType();
//                // 当前桶类型
//                String matnr = findLocNoAttributeVo.getMatnr();
//                if(findLocNoAttributeVo.getMatnr().equals(wrkMast.getPdcType())) { // 当前桶与前桶是一种类型
//                    // 当前桶类型的任务有几个
//                    long count = wrkMastList.stream().filter(wrkMast1 -> wrkMast1.getPdcType().equals(matnr)).count();
//                    if (count % 2  == 0) { // 偶数，取一组新库位
//                        // 取新库位组的第一个库位
//                        List<LocMast> locMasts = locMastService.selectList(new EntityWrapper<LocMast>().eq("crn_no", 4).eq("loc_sts", "O"));
//                        List<LocMast> collect = locMasts.stream().filter(locMast1 -> locMast1.getRow1() == 9 || locMast1.getRow1() == 11).collect(Collectors.toList());
//                        List<LocMast> collect1 = locMasts.stream().filter(locMast1 -> locMast1.getRow1() == 10 || locMast1.getRow1() == 12).collect(Collectors.toList()); // 第一个先放这两排
//                        if (collect.size() == 0 || collect1.size() == 0) {
//                            log.error("-----空桶库无空库位----");
//                            throw new CoolException("空桶库无空库位");
//                        }
//                        // 可用库位组
//                        List<LocMast> locMastList = new ArrayList<>();
//                        for(LocMast locMast1:collect) {
//                            Optional<LocMast> first = collect1.stream().filter(locMast2 -> locMast1.getRow1() + 1 == locMast2.getRow1() && Objects.equals(locMast1.getLev1(), locMast2.getLev1())
//                                    && Objects.equals(locMast1.getBay1(), locMast2.getBay1())).findFirst();
//                            first.ifPresent(locMastList::add);
//                        }
//
//                        if (locMastList.size() == 0) {
//                            log.error("-----空桶库无对应空空桶组----");
//                            throw new CoolException("空桶库无对应空空桶组");
//                        }
//                        String model = findLocNoAttributeVo.getModel(); // 当前桶类型
//                        if (model.equals("208L") && locMastList.size() <= 40 * 2 * 2) { // 最上面一层只能放208L，库位剩余量不多时，如果是208L桶入库，则先从最顶层放
//                            locMastList = locMastList.stream().sorted(Comparator.comparing(LocMast::getLev1).reversed().thenComparing(LocMast::getBay1).thenComparing(LocMast::getRow1)).collect(Collectors.toList());
//                        } else {
//                            locMastList = locMastList.stream().sorted(Comparator.comparing(LocMast::getLev1).thenComparing(LocMast::getBay1).thenComparing(LocMast::getRow1)).collect(Collectors.toList());
//                        }
//                        locMast = locMastList.get(0);
//                    } else { // 奇数，取前一库位对应的空库位
//                        String locNo = wrkMast.getLocNo();
//                        int row = Integer.parseInt(locNo.substring(0, 2));
//                        if(row == 10 || row == 12) {
//                            String newLocNo =(row == 10 ? "09" : "11") + locNo.substring(2);
//                            locMast = locMastService.selectOne(new EntityWrapper<LocMast>().eq("loc_no", newLocNo).eq("loc_sts","O"));
//                            if (locMast == null) {
//                                log.error("-----与前面桶类型一样，前面该桶类型任务数是奇数，10，12排,但是对应库位不为空----");
//                                throw new CoolException("与前面桶类型一样，前面该桶类型任务数是奇数，是10，12排,但是对应库位不为空");
//                            }
//                        } else {
//                            // 自动给前面任务补尾桶信号
//                            wrkMastService.updateCtnType(wrkMast);
//                            log.error("-----与前面桶类型一样，前面该桶类型任务数是奇数，但是不是10，12排----");
//                            throw new CoolException("与前面桶类型一样，前面该桶类型任务数是奇数，但是不是10，12排");
//                        }
//                    }
//                } else { // 当前桶与前桶不是一种类型
//                      if(oldCtnType == 1) { // 前面是尾桶
//                          // 取新库位组的第一个库位
//                          List<LocMast> locMasts = locMastService.selectList(new EntityWrapper<LocMast>().eq("crn_no", 4).eq("loc_sts", "O"));
//                          List<LocMast> collect = locMasts.stream().filter(locMast1 -> locMast1.getRow1() == 9 || locMast1.getRow1() == 11).collect(Collectors.toList());
//                          List<LocMast> collect1 = locMasts.stream().filter(locMast1 -> locMast1.getRow1() == 10 || locMast1.getRow1() == 12).collect(Collectors.toList()); // 第一个先放这两排
//                          if (collect.size() == 0 || collect1.size() == 0) {
//                              log.error("-----空桶库无空库位----");
//                              throw new CoolException("空桶库无空库位");
//                          }
//                          // 可用库位组
//                          List<LocMast> locMastList = new ArrayList<>();
//                          for(LocMast locMast1:collect) {
//                              Optional<LocMast> first = collect1.stream().filter(locMast2 -> locMast1.getRow1() + 1 == locMast2.getRow1() && Objects.equals(locMast1.getLev1(), locMast2.getLev1())
//                                      && Objects.equals(locMast1.getBay1(), locMast2.getBay1())).findFirst();
//                              first.ifPresent(locMastList::add);
//                          }
//
//                          if (locMastList.size() == 0) {
//                              log.error("-----空桶库无对应空空桶组----");
//                              throw new CoolException("空桶库无对应空空桶组");
//                          }
//                          String model = findLocNoAttributeVo.getModel(); // 当前桶类型
//                          if (model.equals("208L") && locMastList.size() <= 40 * 2 * 2) { // 最上面一层只能放208L，库位剩余量不多时，如果是208L桶入库，则先从最顶层放
//                              locMastList = locMastList.stream().sorted(Comparator.comparing(LocMast::getLev1).reversed().thenComparing(LocMast::getBay1).thenComparing(LocMast::getRow1)).collect(Collectors.toList());
//                          } else {
//                              locMastList = locMastList.stream().sorted(Comparator.comparing(LocMast::getLev1).thenComparing(LocMast::getBay1).thenComparing(LocMast::getRow1)).collect(Collectors.toList());
//                          }
//                          locMast = locMastList.get(0);
//                      } else { // 前面不是尾桶
//                          // 判断前面入空桶库任务数量(未执行堆垛机入库)
//                          long count = wrkMastList.stream().filter(wrkMast1 -> wrkMast1.getPdcType().equals(oldModel)).count();
//                          if (count % 2 == 0) { // 偶数，可以入库
//                              // 取新库位组的第一个库位
//                              List<LocMast> locMasts = locMastService.selectList(new EntityWrapper<LocMast>().eq("crn_no", 4).eq("loc_sts", "O"));
//                              List<LocMast> collect = locMasts.stream().filter(locMast1 -> locMast1.getRow1() == 9 || locMast1.getRow1() == 11).collect(Collectors.toList());
//                              List<LocMast> collect1 = locMasts.stream().filter(locMast1 -> locMast1.getRow1() == 10 || locMast1.getRow1() == 12).collect(Collectors.toList()); // 第一个先放这两排
//                              if (collect.size() == 0 || collect1.size() == 0) {
//                                  log.error("-----空桶库无空库位----");
//                                  throw new CoolException("空桶库无空库位");
//                              }
//                              // 可用库位组
//                              List<LocMast> locMastList = new ArrayList<>();
//                              for(LocMast locMast1:collect) {
//                                  Optional<LocMast> first = collect1.stream().filter(locMast2 -> locMast1.getRow1() + 1 == locMast2.getRow1() && Objects.equals(locMast1.getLev1(), locMast2.getLev1())
//                                          && Objects.equals(locMast1.getBay1(), locMast2.getBay1())).findFirst();
//                                  first.ifPresent(locMastList::add);
//                              }
//
//                              if (locMastList.size() == 0) {
//                                  log.error("-----空桶库无对应空空桶组----");
//                                  throw new CoolException("空桶库无对应空空桶组");
//                              }
//                              String model = findLocNoAttributeVo.getModel(); // 当前桶类型
//                              if (model.equals("208L") && locMastList.size() <= 40 * 2 * 2) { // 最上面一层只能放208L，库位剩余量不多时，如果是208L桶入库，则先从最顶层放
//                                  locMastList = locMastList.stream().sorted(Comparator.comparing(LocMast::getLev1).reversed().thenComparing(LocMast::getBay1).thenComparing(LocMast::getRow1)).collect(Collectors.toList());
//                              } else {
//                                  locMastList = locMastList.stream().sorted(Comparator.comparing(LocMast::getLev1).thenComparing(LocMast::getBay1).thenComparing(LocMast::getRow1)).collect(Collectors.toList());
//                              }
//                              locMast = locMastList.get(0);
//                          } else { // 奇数，不可以入库
//                              // 自动给前面任务补尾桶信号
//                              wrkMastService.updateCtnType(wrkMast);
//                              log.error("-----与前面桶类型不一样，前面桶不是尾桶，前面该桶类型任务数不是偶数，不能入库----");
//                              throw new CoolException("与前面桶类型不一样，前面桶不是尾桶，前面该桶类型任务数不是偶数，不能入库");
//                          }
//                      }
//                }
//            }

        } else if ((staDescId == 1 && locArea == 1) || staDescId == 10) { // 满板入成品库或者空板入成品库