齣庫功能優化

zc

17 小时以前 ecf0bb23387e5d33d5c802fa21bb9f84089d3567

齣庫功能優化

 rsf-server/src/main/java/com/vincent/rsf/server/api/service/impl/PdaOutStockServiceImpl.java

@@ -11,6 +11,7 @@
import com.vincent.rsf.server.manager.entity.*;
import com.vincent.rsf.server.manager.enums.AsnExceStatus;
import com.vincent.rsf.server.manager.enums.TaskStsType;
import com.vincent.rsf.server.manager.enums.TaskType;
import com.vincent.rsf.server.manager.service.*;
import com.vincent.rsf.server.manager.service.impl.StockItemServiceImpl;
import com.vincent.rsf.server.manager.service.impl.StockServiceImpl;
@@ -124,8 +125,8 @@
        if (null == task) {
            throw new CoolException("未找到容器号对应任务");
        }
        if (!task.getTaskStatus().equals(TaskStsType.AWAIT.id)) {
            return R.error("任务状态不是等待确认");
        if (!task.getTaskStatus().equals(TaskStsType.WAVE_SEED.id)) {
            return R.error("任务状态不是揀料狀態");
        }
        List<TaskItem> taskItems = taskItemService.list(new LambdaQueryWrapper<TaskItem>().eq(TaskItem::getTaskId, task.getId()));
        Set<Long> longSet = taskItems.stream().map(TaskItem::getSourceId).collect(Collectors.toSet());
@@ -251,8 +252,8 @@
        if (null == task) {
            return R.error("未找到托盘对应的任务");
        }
        if (!task.getTaskStatus().equals(TaskStsType.AWAIT.id)) {
            return R.error("任务状态不是等待确认");
        if (!task.getTaskStatus().equals(TaskStsType.WAVE_SEED.id)) {
            return R.error("任务状态不是揀料狀態");
        }
        WkOrder order = asnOrderService.getById(params.getOrderId());
        if (Objects.isNull(order)) {
@@ -358,8 +359,8 @@
        if (null == task) {
            return R.error("未找到托盘对应的任务");
        }
        if (!task.getTaskStatus().equals(TaskStsType.AWAIT.id)) {
            return R.error("任务状态不是等待确认");
        if (!task.getTaskStatus().equals(TaskStsType.WAVE_SEED.id)) {
            return R.error("任务状态不是待揀狀態");
        }

        List<TaskItem> taskItems = taskItemService.list(new LambdaQueryWrapper<TaskItem>().eq(TaskItem::getTaskId, task.getId()));
@@ -369,90 +370,18 @@
           }
        });

//        orderItems.forEach(orderItem -> {
//            try {
//                taskService.saveOutStockItem(taskItems, orderItem, null, null, SystemAuthUtils.getLoginUserId());
//            } catch (Exception e) {
//                throw new RuntimeException(e);
//            }
//        });

//        containerWaveParam.getOrderItems().forEach(orderItem -> {
//
//        });
//        for (ContainerWaveDto containerWaveDto : containerWaveParam.getContainerWaveDtos()) {
//            //做一次校验，判断前端所有出库数量是否超过本托出库数量
//            double sum = containerWaveDto.getWkOrderItems().stream().mapToDouble(WkOrderItem::getDemandQty).sum();
//            BigDecimal total = new BigDecimal(String.valueOf(sum));
//            BigDecimal anfme = new BigDecimal(containerWaveDto.getTaskItem().getAnfme().toString());
//            if (!anfme.equals(total)) {
//                throw new CoolException("播种数量不等于容器出库数量，请检查");
//            }
//            for (WkOrderItem oldOrderItem : containerWaveDto.getWkOrderItems()) {
//                if (Double.compare(oldOrderItem.getDemandQty(), 0.0) == 0) {
//                    continue;
//                }
//                WkOrderItem orderItem = asnOrderItemService.getById(oldOrderItem.getId());
//                BigDecimal num = new BigDecimal(orderItem.getWorkQty().toString()).subtract(new BigDecimal(orderItem.getQty().toString()));
//                BigDecimal orderDemandQty = new BigDecimal(oldOrderItem.getDemandQty().toString());
//                if (num.compareTo(orderDemandQty) < 0) {
//                    throw new CoolException("播种数量大于单据出库数量，请检查");
//                }
//                WkOrder wkOrder = asnOrderService.getById(orderItem.getOrderId());
//                if (Cools.isEmpty(wkOrder)) {
//                    throw new CoolException("出库单主单未找到");
//                }
//                wkOrder.setQty(new BigDecimal(wkOrder.getQty().toString()).add(orderDemandQty).doubleValue());
//                if (!asnOrderService.updateById(wkOrder)) {
//                    throw new CoolException("出库单更新状态失败");
//                }
//
//                if (Objects.isNull(oldOrderItem.getFieldsIndex())) {
//                    throw new CoolException("票号不能为空！！");
//                }
//                //Fix 这里只针对希日项目的票号功能，票号和uuid为一对一的情况，不会出现重复的情况
//                FieldsItem fieldsItem = fieldsItemService.getOne(new LambdaQueryWrapper<FieldsItem>().eq(FieldsItem::getValue, oldOrderItem.getFieldsIndex()).last("limit 1"));
//                if (!Objects.isNull(fieldsItem)) {
//                    orderItem.setFieldsIndex(fieldsItem.getUuid());
//                }
//                orderItem.setQty(new BigDecimal(orderItem.getQty().toString()).add(orderDemandQty).doubleValue());
//                if (!asnOrderItemService.updateById(orderItem)) {
//                    throw new CoolException("单据明细更新失败");
//                }
//                //检查单据是否完成
//                Boolean orderChecked = checkOrderComplete(orderItem);
//                if (orderChecked) {
//                    wkOrder.setExceStatus(AsnExceStatus.OUT_STOCK_STATUS_TASK_DONE.val);
//                    if (!asnOrderService.updateById(wkOrder)) {
//                        throw new CoolException("出库单更新状态失败");
//                    }
//                }
//            }
//        //检查波次是否完成
////            Boolean waveChecked = checkWaveComplete(containerWaveDto.getTaskItem());
////            if (waveChecked){
////                Wave wave = waveService.getById(containerWaveDto.getTaskItem().getSourceId());
////                if (null == wave){
////                    throw new CoolException("未找到容器号对应波次");
////                }
////                wave.setExceStatus(WaveExceStatus.WAVE_EXCE_STATUS_TASK.val);
////                if (!waveService.updateById(wave)){
////                    throw new CoolException("波次单更新状态失败");
////                }
////            }
//        }

        try {
            taskService.pickOrCheckTask(task.getId(), "");
            if (task.getTaskType().equals(TaskType.TASK_TYPE_PICK_AGAIN_OUT.type) || task.getTaskType().equals(TaskType.TASK_TYPE_CHECK_OUT.type)) {
                taskService.pickOrCheckTask(task.getId(), "");
            } else {
                task.setTaskStatus(TaskStsType.UPDATED_OUT.id);
                if (!taskService.updateById(task)) {
                    throw new CoolException("任务状态更新失败");
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
            throw new CoolException("分揀失败");
        }

//        task.setTaskStatus(TaskStsType.COMPLETE_OUT.id);
//        if (!taskService.updateById(task)) {
//            throw new CoolException("任务状态更新失败");
//        }

        return R.ok();
    }


 rsf-server/src/main/java/com/vincent/rsf/server/api/service/impl/WcsServiceImpl.java

@@ -515,7 +515,6 @@
                    || task.getTaskType().equals(TaskType.TASK_TYPE_CHECK_OUT.type)
                    || task.getTaskType().equals(TaskType.TASK_TYPE_EMPITY_OUT.type)) {


                /**修改出库站点状态*/
                BasStation station = basStationService.getOne(new LambdaQueryWrapper<BasStation>()
                        .eq(BasStation::getStationName, task.getTargSite()));
@@ -528,10 +527,9 @@
                        throw new CoolException("站点状态修改失败！！");
                    }
                }

                if (!taskService.update(new LambdaUpdateWrapper<Task>().eq(Task::getTaskCode, task.getTaskCode())
                        .lt(Task::getTaskStatus, TaskStsType.COMPLETE_OUT.id)
                        .set(Task::getTaskStatus, TaskStsType.AWAIT.id))) {
                        .set(Task::getTaskStatus, TaskStsType.COMPLETE_OUT.id))) {
                    throw new CoolException("任务状态修改失败！！");
                }
            }

 rsf-server/src/main/java/com/vincent/rsf/server/manager/service/impl/TaskServiceImpl.java

@@ -683,9 +683,9 @@
        if (Objects.isNull(loc)) {
            throw new CoolException("库存不存在！！");
        }
//        if (!loc.getUseStatus().equals(LocStsType.LOC_STS_TYPE_S.type)) {
//            throw new CoolException("当前库位状态不处于S.入库预约，不可执行入库操作！");
//        }
        if (!loc.getUseStatus().equals(LocStsType.LOC_STS_TYPE_S.type)) {
            throw new CoolException("当前库位状态不处于S.入库预约，不可执行入库操作！");
        }

        loc.setUseStatus(LocStsType.LOC_STS_TYPE_F.type)
                .setBarcode(task.getBarcode())
@@ -788,7 +788,6 @@
            } else if (task.getTaskType().equals(TaskType.TASK_TYPE_CHECK_OUT.type)) {
                List<TaskItem> taskItems = taskItemService.list(new LambdaQueryWrapper<TaskItem>().in(TaskItem::getTaskId, Arrays.asList(ids)));
                if (!taskItems.isEmpty()) {

                    taskItems.forEach(taskItem -> {
                        if (!checkOrderItemService.update(new LambdaUpdateWrapper<WkOrderItem>()
                                .eq(WkOrderItem::getId, taskItem.getOrderItemId())
@@ -1035,10 +1034,10 @@
                }
            });
        });
        List<Long> matnrIds = taskItems.stream().map(TaskItem::getMatnrId).collect(Collectors.toList());
        List<String> matnrIds = taskItems.stream().map(TaskItem::getFieldsIndex).collect(Collectors.toList());
        //删除与任务明细重复的库存信息，以任务明细为准
        List<LocItemWorking> itemWorkings = tempLocs.stream()
                .filter(working -> !matnrIds.contains(working.getMatnrId()))
                .filter(working -> !matnrIds.contains(working.getFieldsIndex()))
                .collect(Collectors.toList());
        itemWorkings.forEach(working -> {
            TaskItem taskItem = taskItems.stream().findFirst().get();
@@ -1214,7 +1213,6 @@
                    .set(Task::getTaskStatus, TaskStsType.WAVE_SEED.id))) {
                throw new CoolException("库存状态更新失败！！");
            }

        } else {
            if (!this.update(new LambdaUpdateWrapper<Task>()
                    .eq(Task::getId, task.getId())