修改入出库历史的拣料类型，不上传ERP

skyouc

1 天以前 d7355ce983c2bddcc5b95e4d84283f6631fb176a

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

@@ -8,18 +8,23 @@
import com.vincent.rsf.server.api.entity.params.ContainerWaveParam;
import com.vincent.rsf.server.api.entity.params.WavePickItemsParams;
import com.vincent.rsf.server.api.service.PdaOutStockService;
import com.vincent.rsf.server.common.utils.FieldsUtils;
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.LocItemWorkingServiceImpl;
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.GlobalConfigCode;
import com.vincent.rsf.server.system.constant.SerialRuleCode;
import com.vincent.rsf.server.system.entity.Config;
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.ConfigServiceImpl;
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;
@@ -62,6 +67,12 @@
    private StockService stockService;
    @Autowired
    private StockItemServiceImpl stockItemService;
    @Autowired
    private LocItemService locItemService;
    @Autowired
    private LocItemWorkingService locItemWorkingService;
    @Autowired
    private ConfigServiceImpl configService;

    @Override
    public R getOutStockTaskItem(String barcode) {
@@ -269,12 +280,20 @@
            if (Objects.isNull(orderItem)) {
                throw new CoolException("数据错误，拣料不在单据需求中！！");
            }
            //taskItems为拣货明细，作参数上报
            Double summed = items.stream().mapToDouble(TaskItem::getAnfme).sum();
            //加上历史拣料数量
            Double pickQty = Math.round((orderItem.getQty() + summed) * 100) / 100.0;
            if (pickQty.compareTo(orderItem.getAnfme()) > 0.0) {
                throw new CoolException("播种数量不能超出订单需求数量");
            Config config = configService.getOne(new LambdaQueryWrapper<Config>().eq(Config::getFlag, GlobalConfigCode.ALLOW_OVER_CHANGE));
            //判断是否允许超收，不允许超收添加拒收判断
            if (!Objects.isNull(config)) {
                if (!Boolean.parseBoolean(config.getVal())) {
                    if (pickQty.compareTo(orderItem.getAnfme()) > 0.0) {
                        throw new CoolException("播种数量不能超出订单需求数量");
                    }
                }
            }

            orderItem.setQty(pickQty);

            if (!asnOrderItemService.updateById(orderItem)) {
@@ -304,13 +323,32 @@

           List<StockItem> stockItems = new ArrayList<>();
            items.forEach(taskItem -> {
                taskItem.setQty(taskItem.getAnfme()).setOrderId(order.getId()).setOrderItemId(orderItem.getId());
                if (!taskItemService.updateById(taskItem)) {
                TaskItem item = taskItemService.getById(taskItem.getId());
                //判断是否允许超收，不允许超收添加拒收判断
                if (!Objects.isNull(config)) {
                    LocItemWorking serviceOne = locItemWorkingService.getOne(new LambdaQueryWrapper<LocItemWorking>().eq(LocItemWorking::getFieldsIndex, item.getFieldsIndex()));
                    if (Objects.isNull(serviceOne)) {
                        throw new CoolException("缓存数据丢失！！");
                    }
                    //不管是否允许超收，都需判断是否超出库存范围
                    if (taskItem.getAnfme().compareTo(serviceOne.getAnfme()) > 0) {
                        throw new CoolException("拣货数量超出当前票号库存数量！！");
                    }
                    if (!Boolean.parseBoolean(config.getVal())) {
                        if (item.getAnfme().compareTo(item.getQty() + taskItem.getAnfme()) < 0.0) {
                            throw new CoolException("前当物料已超出可拣范围，请核对后再操作！！");
                        }
                    }
                }

                item.setQty(item.getQty() + taskItem.getAnfme()).setOrderId(order.getId()).setOrderItemId(orderItem.getId());
                if (!taskItemService.updateById(item)) {
                    throw new CoolException("状态完成失败！！");
                }
                StockItem stockItem = new StockItem();
                BeanUtils.copyProperties(taskItem, stockItem);
                stockItem.setStockId(stock.getId()).setStockCode(stock.getCode()).setSourceItemId(orderItem.getId());
                BeanUtils.copyProperties(item, stockItem);
                //taskItem为上报数据
                stockItem.setStockId(stock.getId()).setAnfme(taskItem.getAnfme()).setStockCode(stock.getCode()).setSourceItemId(orderItem.getId());
                stockItems.add(stockItem);
            });
            if (!stockItemService.saveBatch(stockItems)) {
@@ -320,8 +358,8 @@

        List<WkOrderItem> orderItems = asnOrderItemService.list(new LambdaQueryWrapper<WkOrderItem>().eq(WkOrderItem::getOrderId, params.getOrderId()));
        double total = orderItems.stream().mapToDouble(WkOrderItem::getQty).sum();
        double wkQty = orderItems.stream().mapToDouble(WkOrderItem::getWorkQty).sum();
        order.setQty(total).setWorkQty(order.getWorkQty() - wkQty);
        Double wkQty = orderItems.stream().mapToDouble(WkOrderItem::getWorkQty).sum();
        order.setQty(total).setWorkQty(order.getWorkQty().compareTo(wkQty) < 0 ? 0.0 : (total - wkQty));
        if (!asnOrderService.updateById(order)) {
            throw new CoolException("订单数量更新失败！！");
        }
@@ -332,6 +370,92 @@
//                throw new CoolException("出库单更新状态失败");
//            }
//        }
        return R.ok();
    }

    /**
     * @author Ryan
     * @date 2025/11/19
     * @description: 获取出库任务拣货明细
     * @version 1.0
     */
    @Override
    public R getTaskItems(Map<String, String> params) {
        if (Objects.isNull(params.get("barcode"))) {
            throw new CoolException("拖盘码不能为空！！");
        }
        List<Integer> integers = Arrays.asList(TaskType.TASK_TYPE_OUT.type, TaskType.TASK_TYPE_EMPITY_OUT.type, TaskType.TASK_TYPE_PICK_AGAIN_OUT.type, TaskType.TASK_TYPE_CHECK_OUT.type);
        Task task = taskService.getOne(new LambdaQueryWrapper<Task>()
                .in(Task::getTaskType, integers)
                .eq(Task::getBarcode, params.get("barcode")), false);
        if (Objects.isNull(task)) {
            return R.error("托盘所在任务不存在！！");
        }
        List<TaskItem> taskItems = taskItemService.list(new LambdaQueryWrapper<TaskItem>().eq(TaskItem::getTaskId, task.getId()));
        taskItems.forEach(taskItem -> {
            if (!Objects.isNull(taskItem.getFieldsIndex())) {
                Map<String, String> fields = FieldsUtils.getFields(taskItem.getFieldsIndex());
                taskItem.setExtendFields(fields);
            }
        });
        return R.ok().add(taskItems);
    }

    /**
     * @author Ryan
     * @date 2025/11/19
     * @description: 修改出库任务档明细票号
     * @version 1.0
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public R modifyTaskItem(List<TaskItem> items) {
        if (Objects.isNull(items) || items.isEmpty()) {
            return R.error("参数不能为空！！");
        }
        for (TaskItem item : items) {
            if (Objects.isNull(item.getCrushNo())) {
                continue;
            }
            TaskItem byId = taskItemService.getById(item.getId());
            if (!Objects.isNull(byId.getFieldsIndex())) {
                Map<String, String> fields = FieldsUtils.getFields(byId.getFieldsIndex());
                byId.setExtendFields(fields);
            }
            if (byId.getExtendFields().get("crushNo").equals(item.getCrushNo())) {
                continue;
            }
            FieldsItem fieldsItem = fieldsItemService.getOne(new LambdaQueryWrapper<FieldsItem>()
                    .eq(FieldsItem::getValue, item.getCrushNo())
                    .last("limit 1"));
            if (Objects.isNull(fieldsItem)) {
                throw new CoolException("库存不存在!!");
            }
            String uuid = fieldsItem.getUuid();
            item.setFieldsIndex(uuid).setExtendFields(null);
            if (!taskItemService.updateById(item)) {
               throw new CoolException("任务明细修改失败");
            }
            LocItemWorking oldOne = locItemWorkingService.getOne(new LambdaQueryWrapper<LocItemWorking>()
                    .eq(LocItemWorking::getMatnrCode, byId.getMatnrCode())
                    .eq(LocItemWorking::getFieldsIndex, byId.getFieldsIndex()));
            if (Objects.isNull(oldOne)) {
                throw new CoolException("明细不存在或已出库！！");
            }
            LocItemWorking one = locItemWorkingService.getOne(new LambdaQueryWrapper<LocItemWorking>()
                            .eq(LocItemWorking::getMatnrCode, byId.getMatnrCode())
                    .eq(LocItemWorking::getFieldsIndex, uuid));
            if (Objects.isNull(one)) {
                throw new CoolException("明细不存在或已出库！！");
            }
            one.setWorkQty(oldOne.getWorkQty());
            oldOne.setWorkQty(0.0);

            //更新库位信息
            locItemWorkingService.updateById(oldOne);
            locItemWorkingService.updateById(one);

        }
        return R.ok();
    }

@@ -362,12 +486,19 @@
            return R.error("任务状态不是待揀狀態");
        }

        List<TaskItem> taskItems = taskItemService.list(new LambdaQueryWrapper<TaskItem>().eq(TaskItem::getTaskId, task.getId()));
        taskItems.forEach(taskItem -> {
           if (!(taskItem.getQty().compareTo(taskItem.getAnfme()) == 0)) {
               throw new CoolException("有单据物料未拣，请拣完后再确认！！");
           }
        });
        Config config = configService.getOne(new LambdaQueryWrapper<Config>().eq(Config::getFlag, GlobalConfigCode.ALLOW_OVER_CHANGE));
        //判断是否允许超收，不允许超收添加拒收判断
        if (!Objects.isNull(config)) {
            if (!Boolean.parseBoolean(config.getVal())) {
                List<TaskItem> taskItems = taskItemService.list(new LambdaQueryWrapper<TaskItem>().eq(TaskItem::getTaskId, task.getId()));
                taskItems.forEach(taskItem -> {
                    if ((taskItem.getQty().compareTo(taskItem.getAnfme()) < 0)) {
                        throw new CoolException("有单据物料未拣，请拣完后再确认！！");
                    }
                });
            }
        }


        try {
            if (task.getTaskType().equals(TaskType.TASK_TYPE_PICK_AGAIN_OUT.type) || task.getTaskType().equals(TaskType.TASK_TYPE_CHECK_OUT.type)) {
@@ -379,7 +510,7 @@
                }
            }
        } catch (Exception e) {
            throw new CoolException("分揀失败");
            throw new CoolException("分拣失败");
        }
        return R.ok();
    }