出库时，检测到选择的站点没有空的暂存位，则等成等待任务，等待任务的出库站点暂时不分配。 新增定时处理等待任务

zyx

2023-11-07 559b2321be06967f32eb40ba434790b735d7fa33

出库时，检测到选择的站点没有空的暂存位，则等成等待任务，等待任务的出库站点暂时不分配。
新增定时处理等待任务

 src/main/java/com/zy/asrs/controller/OutController.java

@@ -71,38 +71,6 @@
    @ManagerAuth
    public R pakoutPreview(@RequestBody List<Long> ids) {

//        Order order = orderService.selectById(ids.get(0));
//
//        DocType docType = docTypeService.selectById(order.getDocType());
//
//        if("人工补货单".equals(docType.getDocName())){
//            List<OrderDetl> orderDetlList = orderDetlService.selectBatchIds(ids);
//            //返回给前端的库位以及站点信息
//            List<LocDto> locDtoList = new ArrayList<>();
//
//            for (OrderDetl orderDetl : orderDetlList) {
//
//                double issued = Optional.of(orderDetl.getAnfme() - orderDetl.getQty()).orElse(0.0D);
//                if (issued <= 0.0D) { continue; }
//
//                //从平库寻找
//                //issued = manLocDetlService.queryStockAndSetLocDto(orderDetl.getMatnr(),orderDetl.getBatch(),orderDetl.getOrderNo(),locDtoList,issued,orderDetl.getThreeCode(),orderDetl.getDeadTime());
//
//                //先找AGV的库存，如果返回的issued大于0，则去四项库找
//                //issued = agvLocDetlService.queryStockAndSetLocDto(orderDetl.getMatnr(),orderDetl.getBatch(),orderDetl.getOrderNo(),locDtoList,issued,orderDetl.getThreeCode(),orderDetl.getDeadTime());
//
//                //从四项库的库存里面找，
//                issued = locDetlService.queryStockAndSetLocDto1(orderDetl.getMatnr(),orderDetl.getBatch(),orderDetl.getOrderNo(),locDtoList,issued,orderDetl.getThreeCode(),orderDetl.getDeadTime());
//
//                if (issued > 0) {
//                    LocDto locDto = new LocDto(null, orderDetl.getMatnr(), orderDetl.getMaktx(), orderDetl.getBatch(), orderDetl.getOrderNo(), issued);
//                    locDto.setLack(Boolean.TRUE);
//                    locDtoList.add(locDto);
//                }
//            }
//            return R.ok().add(locDtoList);
//        }

        List<OrderDetl> orderDetlList = orderDetlService.selectBatchIds(ids);
        //返回给前端的库位以及站点信息
        List<LocDto> locDtoList = new ArrayList<>();
@@ -120,7 +88,6 @@
                    locDtoList.add(locDto);
                }
            }else {
                //double issued = Optional.of(orderDetl.getAnfme() - orderDetl.getQty()).orElse(0.0D);
                if (issued <= 0.0D) { continue; }

                //从平库寻找
@@ -187,96 +154,6 @@
            workService.stockOut(staNo, taskDto, getUserId());
        }
        return R.ok();

        /*
        if (Cools.isEmpty(locDtos)) {
            return R.parse(BaseRes.PARAM);
        }
        boolean lack = true;
        for (LocDto locDto : locDtos) {
            if (Cools.isEmpty(locDto.getStaNo()) && !locDto.isLack()) {
                return R.error(locDto.getLocNo()+"库位请选择出库站");
            }
        }
        for (LocDto locDto : locDtos) {
            if (!locDto.isLack()) {
                lack = false;
                break;
            }
        }
        if (lack) {
            return R.error("库存不足");
        }

        Thread.sleep(500L);

        // 订单预校验  ===>> 1.订单状态； 2.订单带出数量
        List<OrderDto> orderDtos = new ArrayList<>();
        for (LocDto locDto : locDtos) {
            if (!isJSON(locDto.getOrderNo())) {
                if (Cools.isEmpty(locDto.getOrderNo())) { continue; }
                OrderDto orderDto = new OrderDto(locDto.getOrderNo(), locDto.getMatnr(), locDto.getBatch(), locDto.getAnfme());
                if (OrderDto.has(orderDtos, orderDto)) {
                    OrderDto dto = OrderDto.find(orderDtos, orderDto);
                    assert dto != null;
                    dto.setAnfme(dto.getAnfme() + orderDto.getAnfme());
                } else {
                    orderDtos.add(orderDto);
                }
            } else {
                // 订单合并出库
                List<OrderDto> orderDtoList = JSON.parseArray(locDto.getOrderNo(), OrderDto.class);
                for (OrderDto one : orderDtoList) {
                    OrderDto orderDto = new OrderDto(one.getOrderNo(), locDto.getMatnr(), locDto.getBatch(), one.getAnfme());
                    if (OrderDto.has(orderDtos, orderDto)) {
                        OrderDto dto = OrderDto.find(orderDtos, orderDto);
                        assert dto != null;
                        dto.setAnfme(dto.getAnfme() + orderDto.getAnfme());
                    } else {
                        orderDtos.add(orderDto);
                    }
                }
            }
        }
        for (OrderDto orderDto : orderDtos) {
            Order order = orderService.selectByNo(orderDto.getOrderNo());
            if (order.getSettle() > 2) {
                return R.error(orderDto.getOrderNo() + "订单已失效，请及时刷新页面");
            }
//            OrderDetl orderDetl = orderDetlService.selectItemNoneOfBatch(orderDto.getOrderNo(), orderDto.getMatnr());
//            if (orderDetl.getAnfme() - orderDetl.getQty() < orderDto.getAnfme()) {
//                return R.ok(orderDto.getOrderNo() + "订单已作业，请及时刷新页面");
//            }
        }

        List<TaskDto> taskDtos = new ArrayList<>();
        // 根据 （库位 & 出库站） 分组； 理想状态：一组为一次出库任务
        for (LocDto locDto : locDtos) {
            if (locDto.isLack()) { continue; }
            // 防止前端页面提取库位信息后，在其他地方对该库位生成了出库任务(库位状态非F状态)
            LocMast locMast = locMastService.selectById(locDto.getLocNo());
            if(!Cools.isEmpty(locMast) && !locMast.getLocSts().equals("F")){
                return R.error("库位号非在库状态，请重新选择出库库位===>>" + locDto.getLocNo());
            }

            TaskDto taskDto = new TaskDto(locDto.getLocNo(), locDto.getStaNo(), locDto);
            if (TaskDto.has(taskDtos, taskDto)) {
                TaskDto dto = TaskDto.find(taskDtos, taskDto);
                assert dto != null;
                dto.getLocDtos().addAll(taskDto.getLocDtos());
            } else {
                taskDtos.add(taskDto);
            }
        }

        // -----------------------------------------------------------------------------------------------
        List<String> excludeLocNos = taskDtos.stream().map(TaskDto::getLocNo).distinct().collect(Collectors.toList());
        for (TaskDto taskDto : taskDtos) {
            BasDevp staNo = basDevpService.checkSiteStatus(taskDto.getStaNo());
            workService.stockOut(staNo, taskDto, getUserId());
            locMastService.breakUp(taskDto.getLocNo(), excludeLocNos);
        }
        return R.ok();*/
    }


@@ -389,17 +266,18 @@
        if(!Cools.isEmpty(agvLocMast) && !agvLocMast.getLocSts().equals("F")){
            throw new CoolException("库位号非在库状态，请重新选择出库库位===>>" + locDto.getLocNo());
        }
        AgvBasDevp agvBasDevp = agvBasDevpService.selectOne(new EntityWrapper<AgvBasDevp>()
                .eq("station_code", locDto.getAgvStaNo())
                .eq("loc_sts", "O"));
        //寻找空站点位置
        AgvBasDevp agvBasDevp = agvBasDevpService.selectEmptyDevpByStation(locDto.getAgvStaNo());
        if(Cools.isEmpty(agvBasDevp)){
            //TODO 假如出库站点不足，记录未出库的库位；
            //如果没有找到空站点，则生成准备任务
            TaskDto taskDto = new TaskDto(locDto.getLocNo(), locDto.getAgvStaNo(), locDto);
            agvTaskDtos.add(taskDto);
            return;
        }
        agvBasDevp.setLocSts("S");
        agvBasDevpService.updateById(agvBasDevp);
//        agvBasDevp.setLocSts("S");
//        agvBasDevpService.updateById(agvBasDevp);
        agvBasDevpService.updateLocStsAndBarcodeByDevNo(agvBasDevp.getDevNo(),"S",null);
        TaskDto taskDto = new TaskDto(locDto.getLocNo(), agvBasDevp.getDevNo(), locDto);
        //TODO 暂不考虑库位混载状态（后续看情况是否需要判断）
        agvTaskDtos.add(taskDto);

    }
@@ -433,6 +311,7 @@
        if (!Cools.isEmpty(manLocDetl) && !(locDto.getAnfme()>manLocDetl.getAnfme())) {
            manLocDetl.setStatus(0);
            manLocDetlService.update(manLocDetl, new EntityWrapper<ManLocDetl>().eq("loc_no", manLocDetl.getLocNo()).eq("matnr",manLocDetl.getMatnr()));
            //addPakOUT 生成拣货单成功
            if (addPakOUT(locDto).equals(R.ok())) {
                Order order = orderService.selectByNo(locDto.getOrderNo());
                if (Cools.isEmpty(order)){

 src/main/java/com/zy/asrs/service/AgvBasDevpService.java

@@ -19,4 +19,6 @@
    public List<String> getAvailableEmptyInSite();

    public AgvBasDevp getByDevNo(String devNo);

    public AgvBasDevp selectEmptyDevpByStation(String stationCode);
}

 src/main/java/com/zy/asrs/service/impl/AgvBasDevpServiceImpl.java

@@ -194,4 +194,11 @@
        return this.selectOne(new EntityWrapper<AgvBasDevp>().eq("dev_no",devNo));
    }

    @Override
    public AgvBasDevp selectEmptyDevpByStation(String stationCode) {
        return this.selectOne(new EntityWrapper<AgvBasDevp>()
                .eq("station_code", stationCode)
                .eq("loc_sts", "O"));
    }

}

 src/main/java/com/zy/asrs/service/impl/AgvWorkServiceImpl.java

@@ -533,8 +533,10 @@
    更新源站点信息
     */
    private void updateAgvBasDevp(AgvBasDevp agvBasDevp, String locSts){
        agvBasDevp.setLocSts(locSts);
        agvBasDevpService.updateById(agvBasDevp);
        if(!Cools.isEmpty(agvBasDevp)){
            agvBasDevp.setLocSts(locSts);
            agvBasDevpService.updateById(agvBasDevp);
        }
    }

    /*
@@ -599,9 +601,6 @@
     */
    private AgvWrkMast createWrkMast(int ioType, long wrkSts, String sourceLocNo, String locNo, String barcode,  Date now, Long userId, boolean isConveyor){
        AgvWrkMast wrkMast = new AgvWrkMast();
        //生成工作号
//        int workNo = agvCommonService.getWorkNo(WorkNoType.getWorkNoType(ioType));
//        wrkMast.setWrkNo();
        //工作状态
        wrkMast.setWrkSts(wrkSts);
        //入出库类型
@@ -617,15 +616,6 @@
        wrkMast.setBarcode(barcode);
        //标记是否为输送线入库
        wrkMast.setMk(isConveyor ? "Y" : "N");
        // 满板：Y
        //wrkMast.setFullPlt("Y");
        // 拣料
        //wrkMast.setPicking("N");
        // 退出
        //wrkMast.setExitMk("N");
        // 空板
        //wrkMast.setEmptyMk("N");
        //wrkMast.setLinkMis("N");
        wrkMast.setAppeUser(userId);
        wrkMast.setAppeTime(now);
        wrkMast.setModiUser(userId);
@@ -634,10 +624,6 @@
        if (!agvWrkMastService.insertByIncrease(wrkMast)) {
            throw new CoolException("保存工作档失败");
        }

        int i = agvWrkMastService.selectCount(new EntityWrapper<AgvWrkMast>());
        log.info(i + "");


        wrkMast = agvWrkMastService.selectOne(new EntityWrapper<AgvWrkMast>().eq("loc_no", locNo).eq("source_loc_no",sourceLocNo));


 src/main/java/com/zy/asrs/task/AgvWrkMastScheduler.java

@@ -100,6 +100,7 @@
        List<AgvWrkMast> agvWrkMastList = agvWrkMastService.selectPage(new Page<>(1, 50)
                ,new EntityWrapper<AgvWrkMast>()
                        .eq("wrk_sts", 21)
                        .like("loc_no","@")
                        .andNew().eq("io_type", 101)
                        .or().eq("io_type", 103)
                        .or().eq("io_type", 11)
@@ -114,4 +115,20 @@
            }
        }
    }

    /*
    定时处理等待执行的任务 工作状态为21.生成出库任务 且目标库位中不含@字符
     */
    @Scheduled(cron = "0/5 * * * * ? ")
    public void dealWatiWrk(){
        List<AgvWrkMast> agvWrkMastList = agvWrkMastService.selectList(new EntityWrapper<AgvWrkMast>().eq("wrk_sts", 21).like(false, "loc_no", "@"));
        if(!Cools.isEmpty(agvWrkMastList)){
            try {
                ReturnT<String> returnT = agvWrkMastHandler.dealWatiWrk(agvWrkMastList);
            } catch (IOException e) {
                log.error(e.getMessage());
            }
        }

    }
}

 src/main/java/com/zy/asrs/task/handler/AgvWrkMastHandler.java

@@ -4,10 +4,7 @@
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.core.common.Cools;
import com.core.exception.CoolException;
import com.zy.asrs.entity.AgvLocDetl;
import com.zy.asrs.entity.AgvWaitPakin;
import com.zy.asrs.entity.AgvWrkDetl;
import com.zy.asrs.entity.AgvWrkMast;
import com.zy.asrs.entity.*;
import com.zy.asrs.service.*;
import com.zy.asrs.task.AbstractHandler;
import com.zy.asrs.task.core.ReturnT;
@@ -25,23 +22,25 @@
public class AgvWrkMastHandler extends AbstractHandler<String> {

    @Autowired
    AgvWrkMastService agvWrkMastService;
    private AgvWrkMastService agvWrkMastService;
    @Autowired
    AgvLocMastService agvLocMastService;
    private AgvLocMastService agvLocMastService;
    @Autowired
    AgvLocDetlService agvLocDetlService;
    private AgvLocDetlService agvLocDetlService;
    @Autowired
    AgvWrkMastLogService agvWrkMastLogService;
    private AgvWrkMastLogService agvWrkMastLogService;
    @Autowired
    AgvWrkDetlService agvWrkDetlService;
    private AgvWrkDetlService agvWrkDetlService;
    @Autowired
    AgvWrkDetlLogService agvWrkDetlLogService;
    private AgvWrkDetlLogService agvWrkDetlLogService;
    @Autowired
    AgvWaitPakinService agvWaitPakinService;
    private AgvWaitPakinService agvWaitPakinService;
    @Autowired
    AgvWaitPakinLogService agvWaitPakinLogService;
    private AgvWaitPakinLogService agvWaitPakinLogService;
    @Autowired
    OrderService orderService;
    private OrderService orderService;
    @Autowired
    private AgvBasDevpService agvBasDevpService;

    @Transactional
    public ReturnT<String> completedPutWayWrk(AgvWrkMast agvWrkMast) {
@@ -192,6 +191,21 @@
        return FAIL;
    }

    public ReturnT<String> dealWatiWrk(List<AgvWrkMast> agvWrkMastList) throws IOException {

        agvWrkMastList.forEach(agvWrkMast -> {
            //寻找空站点位置
            AgvBasDevp agvBasDevp = agvBasDevpService.selectEmptyDevpByStation(agvWrkMast.getLocNo());
            if(!Cools.isEmpty(agvBasDevp)){
                agvBasDevpService.updateLocStsAndBarcodeByDevNo(agvBasDevp.getDevNo(),"S",null);
                agvWrkMast.setLocNo(agvBasDevp.getDevNo());
                agvWrkMastService.updateById(agvWrkMast);
            }
        });

        return SUCCESS;
    }

    private String getOrderNoByWrkNo(int wrkNo){
        AgvWrkDetl agvWrkDetl = agvWrkDetlService.selectOne(new EntityWrapper<AgvWrkDetl>().eq("wrk_no", wrkNo));
        if(Cools.isEmpty(agvWrkDetl)){