流程更改

pang.jiabao

7 天以前 b6e0bec71de45cad64e9de14977770053be7e010

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

@@ -3,29 +3,28 @@
import com.alibaba.fastjson.JSON;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.baomidou.mybatisplus.mapper.Wrapper;
import com.core.common.Arith;
import com.core.common.Cools;
import com.core.exception.CoolException;
import com.zy.asrs.entity.*;
import com.zy.asrs.entity.result.FindLocNoAttributeVo;
import com.zy.asrs.entity.result.KeyValueVo;
import com.zy.asrs.mapper.LocMastMapper;
import com.zy.asrs.mapper.WrkMastMapper;
import com.zy.asrs.service.*;
import com.zy.asrs.utils.Utils;
import com.zy.asrs.utils.VersionUtils;
import com.zy.common.model.LocTypeDto;
import com.zy.common.model.Shelves;
import com.zy.common.model.StartupDto;
import com.zy.common.properties.SlaveProperties;
import com.zy.common.web.param.SearchLocParam;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.time.temporal.ChronoUnit;
import java.util.ArrayList;
import java.util.List;
import javax.annotation.Resource;
import java.util.*;
import java.util.stream.Collectors;

/**
 * 货架核心功能
@@ -57,6 +56,12 @@
    private SlaveProperties slaveProperties;
    @Autowired
    private WrkDetlService wrkDetlService;

    @Resource
    private WrkMastMapper wrkMastMapper;

    @Resource
    private LocMastMapper locMastMapper;

    /**
     * 生成工作号
@@ -156,6 +161,245 @@
        return null;
    }

    @Transactional(propagation = Propagation.REQUIRED)
    public StartupDto getLocNoNew(Integer staDescId, Integer sourceStaNo, FindLocNoAttributeVo findLocNoAttributeVo, int locArea) {

        // 目标库位
        LocMast locMast;

        // 入空桶库
        if (staDescId == 1 && locArea == 2) {
            List<WrkMast> wrkMastList = wrkMastMapper.selectLastInEmptyLoc(); // 前面入空桶库的任务(未执行堆垛机入库)

            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) {
                    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 { // 奇数，不可以入库
                              log.error("-----与前面桶类型不一样，前面桶不是尾桶，前面该桶类型任务数不是偶数，不能入库----");
                              throw new CoolException("与前面桶类型不一样，前面桶不是尾桶，前面该桶类型任务数不是偶数，不能入库");
                          }
                      }
                }
            }

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

            // 入成品库摆放规则 判断可用堆垛机自动-无报警 按层列排顺序从下往上，从前往后排 先深库位在浅库位 最上面一层只能放208L桶(剩余库位达到一个阈值208L就先从最上面开始放，下面留给其他货物-后续优化)

            List<BasCrnp> basCrnps = basCrnpService.selectList(new EntityWrapper<BasCrnp>().eq("crn_sts", 3).eq("crn_err", 0).in("crn_no",1,2,3));
            if (basCrnps.size() == 0) {
                log.error("入库请求库位失败，没有联机堆垛机或堆垛机异常");
                throw new CoolException("入库请求库位失败，没有联机堆垛机或堆垛机异常");
            }

            List<Integer> crnList = basCrnps.stream().map(BasCrnp::getCrnNo).collect(Collectors.toList());

            // 入库桶型
            String model = findLocNoAttributeVo.getModel();
            Wrapper<LocMast> wrapper = new EntityWrapper<LocMast>().eq("loc_sts", 'O')
                    .in("crn_no", crnList).orderBy("lev1").orderBy("bay1").orderBy("row1");
            // 入库桶型是不是208L
            if (model == null || !model.equals("208L")) {
                wrapper.ne("lev1", 11);
            }
            locMast = locMastService.selectOne(wrapper.in("row1", 1, 4, 5, 6, 7, 8));
            // 深库位没有了则获取一个浅库位
            if (locMast == null) {
                locMast = locMastService.selectOne(wrapper.in("row1", 2, 3));
                if (locMast == null) {
                    log.error("-----库位不足----");
                    throw new CoolException("库位不足");
                } else {
                    int count = locMastService.selectCount(wrapper.in("row1", 2, 3));
                    if (count <= 10) {
                        log.error("-----库位不足，预留10个库位用来库位转移----");
                        throw new CoolException("库位不足，预留10个库位用来库位转移");
                    }
                }
            }
        } else {
            log.error("入库类型错误，staDescId={}", staDescId);
            throw new CoolException("入库类型错误，staDescId=" + staDescId);
        }
        // 返回dto
        StartupDto startupDto = new StartupDto();
        StaDesc staDesc = staDescService.selectOne(new EntityWrapper<StaDesc>()
                .eq("type_no", staDescId)
                .eq("stn_no", sourceStaNo)
                .eq("crn_no", locMast.getCrnNo()));
        if (Cools.isEmpty(staDesc)) {
            log.error("type_no={},stn_no={},crn_no={}", staDescId, sourceStaNo, locMast.getCrnNo());
            throw new CoolException("入库路径不存在");
        } else {
            BasDevp staNo = basDevpService.selectById(staDesc.getCrnStn());
            if (!staNo.getAutoing().equals("Y")) {
                log.error("目标站" + staDesc.getCrnStn() + "不可用");
                throw new CoolException("目标站" + staDesc.getCrnStn() + "不可用");
            }
            startupDto.setStaNo(staNo.getDevNo());
        }

        // 生成工作号
        int workNo = getWorkNo(0);
        startupDto.setWorkNo(workNo);
        startupDto.setCrnNo(locMast.getCrnNo());
        startupDto.setSourceStaNo(sourceStaNo);
        startupDto.setLocNo(locMast.getLocNo());
        return startupDto;
    }

    @Transactional(propagation = Propagation.REQUIRED)
    public StartupDto getLocNo(SearchLocParam param, Integer staNo) {

        // 返回dto
        StartupDto startupDto = new StartupDto();

        startupDto.setWorkNo(getWorkNo(0)); // 工作号
        startupDto.setSourceStaNo(param.getSourceStaNo()); // 源站点
        startupDto.setStaNo(staNo); // 目标站点
        return startupDto;
    }

    /**
     * 检索库位号
     *