#

Administrator

13 小时以前 458923f646c708059fe5691e33d6ae327e911401

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

@@ -21,6 +21,8 @@
import com.zy.common.constant.ArmConstant;
import com.zy.common.model.DetlDto;
import com.zy.common.model.LocDetlDto;
import com.zy.common.model.LocDto;
import com.zy.common.model.TaskDto;
import com.zy.common.model.enums.WorkNoType;
import com.zy.common.service.CommonService;
import com.zy.common.utils.HttpHandler;
@@ -92,6 +94,10 @@
    private WrkMastService wrkMastService;
    @Autowired
    private WcsApiService wcsApiService;
    @Autowired
    private WorkService workService;
    @Autowired
    private BasCrnpService basCrnpService;

    @Override
    @Transactional
@@ -368,18 +374,18 @@
    @Override
    @Transactional
    public R pakoutOrderPause(OpenOrderPakoutPauseParam param) {
        if (param == null || Cools.isEmpty(param.getOrderNo())) {
        if (param == null || Cools.isEmpty(param.getOrderId())) {
            throw new CoolException("orderNo is empty");
        }
        Order order = orderService.selectByNo(param.getOrderNo());
        Order order = orderService.selectByNo(param.getOrderId());
        if (order == null) {
            order = OrderInAndOutUtil.selectByNo(Boolean.FALSE, param.getOrderNo());
            order = OrderInAndOutUtil.selectByNo(Boolean.FALSE, param.getOrderId());
        }
        if (order == null) {
            throw new CoolException("order not found: " + param.getOrderNo());
            throw new CoolException("order not found: " + param.getOrderId());
        }

        List<WrkMast> activeTasks = findActiveOutboundTasks(param.getOrderNo());
        List<WrkMast> activeTasks = findActiveOutboundTasks(param.getOrderId());
        if (activeTasks.isEmpty()) {
            return R.ok("no active out tasks");
        }
@@ -414,10 +420,31 @@
        }

        Map<String, Object> result = new HashMap<>();
        result.put("orderNo", param.getOrderNo());
        result.put("orderNo", param.getOrderId());
        result.put("pausedCount", pausedCount);
        result.put("wcsStopCount", issuedTasks.size());
        return R.ok("pause out success").add(result);
    }

    @Override
    @Transactional
    public R pakoutOrderExecute(OpenOrderPakoutExecuteParam param) {
        if (param == null || Cools.isEmpty(param.getOrderId())) {
            throw new CoolException("orderId is empty");
        }
        if (param.getExecute() == null) {
            throw new CoolException("execute is empty");
        }
        if (Objects.equals(param.getExecute(), 1)) {
            return createPakoutTasks(param.getOrderId());
        }
        if (Objects.equals(param.getExecute(), 2)) {
            OpenOrderPakoutPauseParam pauseParam = new OpenOrderPakoutPauseParam();
//            pauseParam.getOrderId(param.getOrderId());
//            pauseParam.setReason("OPEN_API_PAUSE");
            return pakoutOrderPause(pauseParam);
        }
        throw new CoolException("execute only supports 1 or 2");
    }

    private List<WrkMast> findActiveOutboundTasks(String orderNo) {
@@ -434,13 +461,116 @@
        }
        List<WrkMast> wrkMasts = wrkMastService.selectList(new EntityWrapper<WrkMast>()
                .in("wrk_no", wrkNos)
                .in("io_type", Arrays.asList(101, 108, 110))
                .in("io_type", Arrays.asList(101, 103, 107, 108, 110))
                .lt("wrk_sts", 14L));
        if (wrkMasts == null || wrkMasts.isEmpty()) {
            return Collections.emptyList();
        }
        wrkMasts.sort(Comparator.comparing(WrkMast::getWrkNo));
        return wrkMasts;
    }

    private R createPakoutTasks(String orderNo) {
        Order order = orderService.selectByNo(orderNo);
        if (order == null) {
            throw new CoolException("order not found: " + orderNo);
        }
        if (order.getSettle() != 1L && order.getSettle() != 2L) {
            throw new CoolException("该订单已处理");
        }

        List<OrderDetl> orderDetls = orderDetlService.selectByOrderId(order.getId());
        if (Cools.isEmpty(orderDetls)) {
            throw new CoolException("订单明细为空");
        }

        Set<String> exist = new HashSet<>();
        List<LocDto> locDtos = new ArrayList<>();
        List<String> lackDetails = new ArrayList<>();
        for (OrderDetl orderDetl : orderDetls) {
            double issued = Optional.ofNullable(orderDetl.getAnfme()).orElse(0.0D) - Optional.ofNullable(orderDetl.getWorkQty()).orElse(0.0D);
            if (issued <= 0.0D) {
                continue;
            }
            List<LocDetl> locDetls = locDetlService.queryStockAll(null, exist,
                    orderDetl.getMatnr(), orderDetl.getBatch(), orderDetl.getBrand(),
                    orderDetl.getStandby1(), orderDetl.getStandby2(), orderDetl.getStandby3(),
                    orderDetl.getBoxType1(), orderDetl.getBoxType2());
            for (LocDetl locDetl : locDetls) {
                if (issued <= 0.0D) {
                    break;
                }
                LocMast locMast = locMastService.selectOne(new EntityWrapper<LocMast>().eq("loc_no", locDetl.getLocNo()));
                if (locMast == null) {
                    continue;
                }
                BasCrnp basCrnp = basCrnpService.selectOne(new EntityWrapper<BasCrnp>().eq("crn_no", locMast.getCrnNo()));
                if (basCrnp == null || !"Y".equalsIgnoreCase(basCrnp.getOutEnable())) {
                    continue;
                }

                double allocateQty = issued >= locDetl.getAnfme() ? locDetl.getAnfme() : issued;
                LocDto locDto = new LocDto(locDetl.getLocNo(), locDetl.getMatnr(), locDetl.getMaktx(), locDetl.getBatch(), orderDetl.getOrderNo(), allocateQty);
                locDto.setFrozen(locDetl.getFrozen());
                locDto.setFrozenLoc(locMast.getFrozen());
                locDto.setBrand(orderDetl.getBrand());
                locDto.setStandby1(orderDetl.getStandby1());
                locDto.setStandby2(orderDetl.getStandby2());
                locDto.setStandby3(orderDetl.getStandby3());
                locDto.setBoxType1(orderDetl.getBoxType1());
                locDto.setBoxType2(orderDetl.getBoxType2());
                locDto.setBoxType3(orderDetl.getBoxType3());
                locDto.setStaNos(staDescService.queryOutStaNosByLocNo(locDetl.getLocNo(), allocateQty >= locDetl.getAnfme() ? 101 : 103));
                if (Cools.isEmpty(locDto.getStaNos())) {
                    continue;
                }
                locDtos.add(locDto);
                exist.add(locDetl.getLocNo());
                issued -= allocateQty;
            }
            if (issued > 0.0D) {
                lackDetails.add(buildLackDetail(orderDetl, issued));
            }
        }

        List<LocDto> availableLocDtos = new ArrayList<>();
        for (LocDto locDto : locDtos) {
            if (locDto.getFrozen() != 1 && locDto.getFrozenLoc() != 1) {
                availableLocDtos.add(locDto);
            }
        }
        if (Cools.isEmpty(availableLocDtos)) {
            throw new CoolException(Cools.isEmpty(lackDetails) ? "未生成任何出库任务" : "库存不足");
        }

        List<TaskDto> taskDtos = new ArrayList<>();
        for (LocDto locDto : availableLocDtos) {
            TaskDto taskDto = new TaskDto(locDto.getLocNo(), locDto.getStaNo(), locDto);
            if (TaskDto.has(taskDtos, taskDto)) {
                TaskDto dto = TaskDto.find(taskDtos, taskDto);
                if (dto != null) {
                    dto.getLocDtos().addAll(taskDto.getLocDtos());
                }
            } else {
                taskDtos.add(taskDto);
            }
        }
        for (TaskDto taskDto : taskDtos) {
            BasDevp staNo = basDevpService.checkSiteStatus(taskDto.getStaNo());
            workService.stockOut(staNo, taskDto, 9527L);
        }

        Map<String, Object> result = new LinkedHashMap<>();
        result.put("orderId", orderNo);
        result.put("createdTaskCount", taskDtos.size());
        result.put("allocatedDetailCount", availableLocDtos.size());
        result.put("lackDetailCount", lackDetails.size());
        result.put("lackDetails", lackDetails);
        return R.ok("execute out success").add(result);
    }

    private String buildLackDetail(OrderDetl orderDetl, double lackQty) {
        return orderDetl.getMatnr() + "|batch=" + (orderDetl.getBatch() == null ? "" : orderDetl.getBatch()) + "|lack=" + lackQty;
    }

    private boolean needNotifyWcsStop(WrkMast wrkMast) {
@@ -452,7 +582,7 @@

    private StopOutTaskParams buildStopOutTaskParams(OpenOrderPakoutPauseParam param, List<WrkMast> wrkMasts) {
        StopOutTaskParams stopParams = new StopOutTaskParams();
        stopParams.setOrderNo(param.getOrderNo());
        stopParams.setOrderNo(param.getOrderId());
        stopParams.setReason(param.getReason());
        for (WrkMast wrkMast : wrkMasts) {
            StopOutTaskParams.TaskItem item = new StopOutTaskParams.TaskItem();
@@ -1253,3 +1383,4 @@
        return R.ok();
    }
}