齣庫功能優化

zc

昨天 ecf0bb23387e5d33d5c802fa21bb9f84089d3567

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

@@ -11,17 +11,25 @@
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;
import com.vincent.rsf.server.system.constant.SerialRuleCode;
import com.vincent.rsf.server.system.entity.Fields;
import com.vincent.rsf.server.system.entity.FieldsItem;
import com.vincent.rsf.server.system.service.FieldsItemService;
import com.vincent.rsf.server.system.service.FieldsService;
import com.vincent.rsf.server.system.service.impl.FieldsItemServiceImpl;
import com.vincent.rsf.server.system.service.impl.FieldsServiceImpl;
import com.vincent.rsf.server.system.utils.SerialRuleUtils;
import com.vincent.rsf.server.system.utils.SystemAuthUtils;
import lombok.Synchronized;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.RequestBody;
@@ -50,6 +58,10 @@
    private FieldsItemService fieldsItemService;
    @Autowired
    private FieldsService fieldsService;
    @Autowired
    private StockService stockService;
    @Autowired
    private StockItemServiceImpl stockItemService;

    @Override
    public R getOutStockTaskItem(String barcode) {
@@ -113,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());
@@ -240,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)) {
@@ -260,7 +272,7 @@
            }
            Double summed = items.stream().mapToDouble(TaskItem::getAnfme).sum();
            //加上历史拣料数量
            Double pickQty = Math.round((orderItem.getQty() + summed) * 10000) / 10000.0;
            Double pickQty = Math.round((orderItem.getQty() + summed) * 100) / 100.0;
            if (pickQty.compareTo(orderItem.getAnfme()) > 0.0) {
                throw new CoolException("播种数量不能超出订单需求数量");
            }
@@ -270,12 +282,41 @@
                throw new CoolException("出库单明细更新失败！！");
            }

            Stock stock = new Stock();
            String ruleCode = SerialRuleUtils.generateRuleCode(SerialRuleCode.SYS_STOCK_CODE, null);
            if (StringUtils.isBlank(ruleCode)) {
                throw new CoolException("当前业务：" + SerialRuleCode.SYS_STOCK_CODE + "，编码规则不存在！！");
            }
            Double sum = taskItems.stream().mapToDouble(TaskItem::getAnfme).sum();
            stock.setCode(ruleCode)
                    .setUpdateBy(SystemAuthUtils.getLoginUserId())
                    .setBarcode(task.getBarcode())
                    .setLocCode(task.getOrgLoc())
                    .setType(order.getType())
                    .setWkType(Short.parseShort(order.getWkType()))
                    .setSourceId(orderItem.getOrderId())
                    .setSourceCode(orderItem.getOrderCode())
                    .setUpdateTime(new Date())
                    .setAnfme(sum);

            if (!stockService.save(stock)) {
                throw new CoolException("出入库历史保存失败！！");
            }

           List<StockItem> stockItems = new ArrayList<>();
            items.forEach(taskItem -> {
                taskItem.setQty(taskItem.getAnfme());
                taskItem.setQty(taskItem.getAnfme()).setOrderId(order.getId()).setOrderItemId(orderItem.getId());
                if (!taskItemService.updateById(taskItem)) {
                    throw new CoolException("状态完成失败！！");
                }
                StockItem stockItem = new StockItem();
                BeanUtils.copyProperties(taskItem, stockItem);
                stockItem.setStockId(stock.getId()).setStockCode(stock.getCode()).setSourceItemId(orderItem.getId());
                stockItems.add(stockItem);
            });
            if (!stockItemService.saveBatch(stockItems)) {
                throw new CoolException("出入库历史明细保存失败！！");
            }
        });

        List<WkOrderItem> orderItems = asnOrderItemService.list(new LambdaQueryWrapper<WkOrderItem>().eq(WkOrderItem::getOrderId, params.getOrderId()));
@@ -286,15 +327,15 @@
            throw new CoolException("订单数量更新失败！！");
        }
        //检查单据是否完成
        if (order.getAnfme().compareTo(order.getQty()) == 0) {
            order.setExceStatus(AsnExceStatus.OUT_STOCK_STATUS_TASK_DONE.val);
            if (!asnOrderService.updateById(order)) {
                throw new CoolException("出库单更新状态失败");
            }
        }

//        if (order.getAnfme().compareTo(order.getQty()) == 0) {
//            order.setExceStatus(AsnExceStatus.OUT_STOCK_STATUS_TASK_DONE.val);
//            if (!asnOrderService.updateById(order)) {
//                throw new CoolException("出库单更新状态失败");
//            }
//        }
        return R.ok();
    }


    /**
     * @author Ryan
@@ -318,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()));
@@ -329,84 +370,18 @@
           }
        });

        orderItems.forEach(orderItem -> {
            try {
                taskService.saveOutStockItem(taskItems, orderItem, null, null, SystemAuthUtils.getLoginUserId());
            } catch (Exception e) {
                throw new RuntimeException(e);
        try {
            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("任务状态更新失败");
                }
            }
        });

//        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("波次单更新状态失败");
////                }
////            }
//        }

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

        return R.ok();
    }