修复取消组托，收货数量修改错误问题

skyouc

2 天以前 8f7e1bf264a5beaca1cf563452bc9ef72dea848f

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

@@ -22,10 +22,7 @@
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.*;
import java.util.stream.Collectors;

@Service("taskService")
@@ -57,13 +54,18 @@
    private DeviceBindService deviceBindService;
    @Autowired
    private WarehouseAreasService warehouseAreasService;

    @Autowired
    private WarehouseAreasItemService warehouseAreasItemService;
    @Autowired
    private WaveItemService waveItemService;
    @Autowired
    private WaveService waveService;
    @Autowired
    private BasStationService basStationService;

    @Override
    @Transactional(rollbackFor = Exception.class)
    public synchronized R generateAGVTasks(WaitPakin pakins,String locCode,String orgSta, Long loginUserId) {
    public synchronized R generateAGVTasks(WaitPakin pakins, String locCode, String orgSta, Long loginUserId) {
        if (Cools.isEmpty(pakins) || Cools.isEmpty(locCode)) {
            throw new CoolException("参数不能为空！！");
        }
@@ -128,7 +130,7 @@
                throw new CoolException("任务明细保存失败！！");
            }
            waitPakinItems.forEach(item -> {
                if (! waitPakinItemService.update(new LambdaUpdateWrapper<WaitPakinItem>()
                if (!waitPakinItemService.update(new LambdaUpdateWrapper<WaitPakinItem>()
                        .set(WaitPakinItem::getWorkQty, item.getAnfme())
                        .eq(WaitPakinItem::getId, item.getId()))) {
                    throw new CoolException("组托明细修执行数量修改失败！！");
@@ -149,7 +151,7 @@

    @Override
    @Transactional(rollbackFor = Exception.class)
    public synchronized R generateFlatWarehouseTasks(WaitPakin pakins,String locCode, Long loginUserId) {
    public synchronized R generateFlatWarehouseTasks(WaitPakin pakins, String locCode, Long loginUserId) {
        if (Cools.isEmpty(pakins) || Cools.isEmpty(locCode)) {
            throw new CoolException("参数不能为空！！");
        }
@@ -213,7 +215,7 @@
                throw new CoolException("任务明细保存失败！！");
            }
            waitPakinItems.forEach(item -> {
                if (! waitPakinItemService.update(new LambdaUpdateWrapper<WaitPakinItem>()
                if (!waitPakinItemService.update(new LambdaUpdateWrapper<WaitPakinItem>()
                        .set(WaitPakinItem::getWorkQty, item.getAnfme())
                        .eq(WaitPakinItem::getId, item.getId()))) {
                    throw new CoolException("组托明细修执行数量修改失败！！");
@@ -330,6 +332,10 @@
                        .setOrderType(OrderType.ORDER_IN.type)
                        .setSource(item.getId())
                        .setTrackCode(item.getTrackCode())
                        .setPlatItemId(item.getPlatItemId())
                        .setPlatOrderCode(item.getPlatOrderCode())
                        .setPlatWorkCode(item.getPlatWorkCode())
                        .setProjectCode(item.getProjectCode())
                        .setCreateBy(loginUserId)
                        .setUpdateBy(loginUserId)
                        .setExtendFields(item.getExtendFields())
@@ -341,11 +347,11 @@
                throw new CoolException("任务明细保存失败！！");
            }
            waitPakinItems.forEach(item -> {
               if (! waitPakinItemService.update(new LambdaUpdateWrapper<WaitPakinItem>()
                       .set(WaitPakinItem::getWorkQty, item.getAnfme())
                       .eq(WaitPakinItem::getId, item.getId()))) {
                   throw new CoolException("组托明细修执行数量修改失败！！");
               }
                if (!waitPakinItemService.update(new LambdaUpdateWrapper<WaitPakinItem>()
                        .set(WaitPakinItem::getWorkQty, item.getAnfme())
                        .eq(WaitPakinItem::getId, item.getId()))) {
                    throw new CoolException("组托明细修执行数量修改失败！！");
                }
            });
        });

@@ -361,41 +367,258 @@

    /**
     * 完成任务 更新库位明细信息，将单据库存更新到单据库存表
     *
     * @param tasks
     * @throws Exception
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public void completeTask(List<Task> tasks) throws Exception {
    public synchronized void completeTask(List<Task> tasks) throws Exception {
        for (Task task : tasks) {
            if (task.getTaskType() < TaskType.TASK_TYPE_OUT.type) {
                //入库任务
                complateInstock(task);
            } else {
                //出库任务
                complateOutStock(task);
            }
        }
    }

    @Override
    public R removeTask(Long[] ids) {
        List<Short> longs = Arrays.asList(TaskStsType.GENERATE_IN.id, TaskStsType.GENERATE_OUT.id);
        List<Task> tasks = this.list(new LambdaQueryWrapper<Task>().in(Task::getId, ids).in(Task::getTaskStatus, longs));
        if (tasks.isEmpty()) {
            throw new CoolException("任务已处执行状态不可取消！！");
        }
        for (Task task : tasks) {
            //恢复组托状态
            WaitPakin waitPakin = waitPakinService.getOne(new LambdaQueryWrapper<WaitPakin>()
                    .eq(WaitPakin::getBarcode, task.getBarcode())
            );
            if (null != waitPakin) {
                waitPakin.setIoStatus(Short.valueOf(PakinIOStatus.PAKIN_IO_STATUS_DONE.val));
                if (!waitPakinService.updateById(waitPakin)) {
                    throw new CoolException("更新组托状态失败！！");
                }
            }
            Loc loc = locService.getOne(new LambdaQueryWrapper<Loc>().eq(Loc::getCode, task.getTaskType() < TaskStsType.UPDATED_IN.id ? task.getTargLoc() : task.getOrgLoc()));
            if (null != loc
                    && (loc.getUseStatus().equals(LocStsType.LOC_STS_TYPE_S.type)
                    || loc.getUseStatus().equals(LocStsType.LOC_STS_TYPE_R.type))) {

                loc.setUseStatus(LocStsType.LOC_STS_TYPE_O.type);
                if (!locService.updateById(loc)) {
                    throw new CoolException("更新库位状态失败！！");
                }
            }
            if (!Objects.isNull(task.getWarehType()) && task.getWarehType().equals(WarehType.WAREHOUSE_TYPE_AGV.id)) {
                BasStation basStation = null;
                if (task.getTaskType().equals(TaskType.TASK_TYPE_IN.type) || task.getTaskType().equals(TaskType.TASK_TYPE_EMPITY_IN.type) ) {
                    basStation = basStationService.getOne(new LambdaQueryWrapper<BasStation>()
                            .eq(BasStation::getStationName, task.getOrgSite())
                            .eq(BasStation::getUseStatus, StaUseStatusType.TYPE_R.type)
                    );
                } else if (task.getTaskType().equals(TaskType.TASK_TYPE_OUT.type)
                        || task.getTaskType().equals(TaskType.TASK_TYPE_PICK_AGAIN_IN.type)
                        || task.getTaskType().equals(TaskType.TASK_TYPE_MERGE_OUT.type)
                        || task.getTaskType().equals(TaskType.TASK_TYPE_CHECK_OUT.type)
                        || task.getTaskType().equals(TaskType.TASK_TYPE_EMPITY_OUT.type)
                ) {
                    basStation = basStationService.getOne(new LambdaQueryWrapper<BasStation>()
                            .eq(BasStation::getStationName, task.getTargLoc())
                            .eq(BasStation::getUseStatus, StaUseStatusType.TYPE_R.type)
                    );
                }
                if (null == basStation) {
                    throw new CoolException("站点状态错误！！");
                }
                basStation.setUseStatus(StaUseStatusType.TYPE_F.type);
                if (!basStationService.updateById(basStation)) {
                    throw new CoolException("更新站点状态失败！！");
                }
            }
        }
        if (!this.removeByIds(Arrays.asList(ids))) {
            throw new CoolException("Delete Fail");
        }

        return R.ok("操作成功");
    }

    /**
     * @author Ryan
     * @date 2025/5/20
     * @description: 完成出库任务，更新出库库存信息
     * @version 1.0
     */
    @Transactional(rollbackFor = Exception.class)
    public synchronized void complateOutStock(Task task) {
        if (Objects.isNull(task)) {
            return;
        }
        List<Long> list = tasks.stream().map(Task::getId).collect(Collectors.toList());
        List<TaskItem> taskItems = taskItemService.list(new LambdaQueryWrapper<TaskItem>().in(TaskItem::getTaskId, list));
        List<TaskItem> taskItems = taskItemService.list(new LambdaQueryWrapper<TaskItem>().eq(TaskItem::getTaskId, task.getId()));
        if (taskItems.isEmpty()) {
            throw new CoolException("任务明细不存在！！");
        }
        List<String> locCodes = tasks.stream().map(Task::getTargLoc).collect(Collectors.toList());
        Map<Long, List<TaskItem>> listMap = taskItems.stream().collect(Collectors.groupingBy(TaskItem::getTaskId));
        /**对任务明细按任务主单进行分组*/
        listMap.keySet().forEach(key -> {
            List<TaskItem> items = listMap.get(key);
            try {
                //更新库位明细
                saveLocItem(items, key);
            } catch (Exception e) {
                throw new CoolException("库位明细更新失败！！");
            }
        });
        try {
            //更新库位明细
            subtractLocItem(taskItems, task.getId());
        } catch (Exception e) {
            throw new RuntimeException(e.getMessage());
        }

        /**对任务明细按订单进行分组*/
        //添加出入库记录信息
        Map<Short, List<TaskItem>> listMap = taskItems.stream().collect(Collectors.groupingBy(TaskItem::getWkType));
        /***获取库存出库值，如果为空表示正常单据出库，非空表明是库存出库
         * 1. 库存出库没有单据信息，单据信息默认为空
         * 2. 单据库存需通过波次查询原始单据信息，将单据信息填入stock中
         * */
        List<TaskItem> list = listMap.get(Short.parseShort(OrderWorkType.ORDER_WORK_TYPE_STOCK_OUT.type));
        if (Objects.isNull(list) || list.isEmpty()) {
            Map<Long, List<TaskItem>> maps = taskItems.stream().collect(Collectors.groupingBy(TaskItem::getSource));
            maps.keySet().forEach(key -> {
                WaveItem waveItem = waveItemService.getById(key);
                if (Objects.isNull(waveItem)) {
                    throw new CoolException("波次明细不存在！！");
                }
                try {
                    saveOutStockItem(maps.get(key), waveItem);
                } catch (Exception e) {
                    throw new CoolException(e.getMessage());
                }
            });
        } else {
            try {
                saveOutStockItem(taskItems, null);
            } catch (Exception e) {
                throw new CoolException(e.getMessage());
            }
        }

        /**修改库位状态为F.在库*/
        List<Loc> locs = locService.list(new LambdaQueryWrapper<Loc>().eq(Loc::getCode, task.getTargLoc()));
        if (locs.isEmpty()) {
            //如单据明细为空，修改为库位状态为O.空库
            if (!locService.update(new LambdaUpdateWrapper<Loc>().set(Loc::getUseStatus, LocStsType.LOC_STS_TYPE_O.type).eq(Loc::getCode, task.getTargLoc()))) {
                throw new CoolException("库位状态修改失败！！");
            }
        }
        if (!this.update(new LambdaUpdateWrapper<Task>().eq(Task::getId, task.getId()).set(Task::getTaskStatus, TaskStsType.UPDATED_OUT.id))) {
            throw new CoolException("任务状态修改失败！！");
        }
    }

    /**
     * @author Ryan
     * @date 2025/5/20
     * @description: 出库信息保存至库存明细表
     * @version 1.0
     */
    @Transactional(rollbackFor = Exception.class)
    public void saveOutStockItem(List<TaskItem> taskItems, WaveItem waveItem) throws Exception {
        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)
                .setAnfme(sum);
        if (Objects.isNull(waveItem)) {
            stock.setWkType(Short.parseShort(OrderWorkType.ORDER_WORK_TYPE_STOCK_OUT.type))
                    .setMemo("出库单出库，无单据信息！！")
                    .setType(OrderType.ORDER_OUT.type);
        } else {
            //TODO 生成波次时需要将波次号写入单据，通过物料，批次，动态字段等唯一值反查单据信息
            stock.setSourceId(waveItem.getId()).setType(OrderType.ORDER_OUT.type);
        }
        if (!stockService.save(stock)) {
            throw new CoolException("库存保存失败！！");
        }
        List<StockItem> stockItems = new ArrayList<>();
        for (TaskItem item : taskItems) {
            /**通过任务明细中的taskId查询,获取TASK的目标库位信息*/
            StockItem stockItem = new StockItem();
            BeanUtils.copyProperties(item, stockItem);
            stockItem.setSourceItemId(item.getOrderItemId())
                    .setStockCode(stock.getCode())
                    .setId(null)
                    .setStockId(stock.getId());
            stockItems.add(stockItem);
        }
        if (!stockItemService.saveBatch(stockItems)) {
            throw new CoolException("库存修改架失败！！");
        }

    }

    /**
     * @author Ryan
     * @date 2025/5/20
     * @description: 扣减库存明细
     * @version 1.0
     */
    @Transactional(rollbackFor = Exception.class)
    public void subtractLocItem(List<TaskItem> items, Long taskId) throws Exception {
        Task task = this.getById(taskId);
        if (Objects.isNull(task)) {
            throw new CoolException("任务不存在!!");
        }
        for (TaskItem item : items) {
            LocItem locItem = locItemService.getOne(new LambdaQueryWrapper<LocItem>()
                    .eq(LocItem::getBatch, item.getBatch())
                    .eq(LocItem::getFieldsIndex, item.getFieldsIndex())
                    .eq(LocItem::getMatnrId, item.getMatnrId())
                    .eq(LocItem::getLocCode, task.getTargLoc()));
            if (Objects.isNull(locItem)) {
                throw new CoolException("库存明细不存在！！");
            }
            //剩余库存
            Double minuValue = (Math.round((locItem.getAnfme() - locItem.getWorkQty() - locItem.getQty()) * 10000.0) / 10000.0);
            if (minuValue.compareTo(item.getAnfme()) <= 0) {
                //剩余库存小于出库库存，移除当前库存信息
                if (!locItemService.removeById(locItem.getId())) {
                    throw new CoolException("库存删除失败！！");
                }
            } else {
                locItem.setWorkQty((Math.round((locItem.getWorkQty() - minuValue) * 10000.0) / 10000.0));
                locItem.setQty((Math.round((minuValue + locItem.getQty()) * 10000.0) / 10000.0));
                if (!locItemService.updateById(locItem)) {
                    throw new CoolException("库存信息更新失败！！");
                }
            }
        }
    }

    /**
     * @author Ryan
     * @date 2025/5/20
     * @description: 完成入库任务
     * @version 1.0
     */
    @Transactional(rollbackFor = Exception.class)
    public void complateInstock(Task task) {
        if (Objects.isNull(task)) {
            return;
        }
        List<TaskItem> taskItems = taskItemService.list(new LambdaQueryWrapper<TaskItem>().eq(TaskItem::getTaskId, task.getId()));
        if (taskItems.isEmpty()) {
            throw new CoolException("任务明细不存在！！");
        }
        try {
            //更新库位明细
            saveLocItem(taskItems, task.getId());
        } catch (Exception e) {
            throw new CoolException("库位明细更新失败！！");
        }

        /**对任务明细按组拖明细进行分组*/
        Map<Long, List<TaskItem>> orderMap = taskItems.stream().collect(Collectors.groupingBy(TaskItem::getSource));
        orderMap.keySet().forEach(key -> {
            WaitPakinItem pakinItem = waitPakinItemService.getById(key);
//            AsnOrder order = asnOrderService.getOne(new LambdaQueryWrapper<AsnOrder>()
//                    .eq(AsnOrder::getId, key)
//                    .select(AsnOrder::getId, AsnOrder::getPoCode, AsnOrder::getCode));
            if (null == pakinItem) {
            if (Objects.isNull(pakinItem)) {
                throw new CoolException("数据错误：组拖数据不存在，请联系管理员！！");
            }
            List<TaskItem> items = orderMap.get(key);
@@ -409,19 +632,19 @@
            }
        });
        /**修改库位状态为F.在库*/
        if (!locService.update(new LambdaUpdateWrapper<Loc>().set(Loc::getUseStatus, LocStsType.LOC_STS_TYPE_F.type).in(Loc::getCode, locCodes))) {
        if (!locService.update(new LambdaUpdateWrapper<Loc>().set(Loc::getUseStatus, LocStsType.LOC_STS_TYPE_F.type).eq(Loc::getCode, task.getTargLoc()))) {
            throw new CoolException("库位状态修改失败！！");
        }
        if (!this.update(new LambdaUpdateWrapper<Task>().in(Task::getId, list).set(Task::getTaskStatus, TaskStsType.UPDATED_IN.id))) {
        if (!this.update(new LambdaUpdateWrapper<Task>().eq(Task::getId, task.getId()).set(Task::getTaskStatus, TaskStsType.UPDATED_IN.id))) {
            throw new CoolException("任务状态修改失败！！");
        }
    }

    /**
     * @author Ryan
     * @description 移除收货区库存
     * @param
     * @return
     * @author Ryan
     * @description 移除收货区库存
     * @time 2025/4/30 16:32
     */
    @Transactional(rollbackFor = Exception.class)
@@ -453,10 +676,10 @@
    }

    /**
     * @author Ryan
     * @description 更新库位明细
     * @param
     * @return
     * @author Ryan
     * @description 更新库位明细
     * @time 2025/4/15 15:28
     */
    @Transactional(rollbackFor = Exception.class)
@@ -482,19 +705,14 @@
    }

    /**
     * 生成库存明细
     * 生成入库库存明细
     *
     * @param items
     * @return
     */
    @Transactional(rollbackFor = Exception.class)
    public void saveStockItems(List<TaskItem> items, WaitPakinItem order) throws Exception {
        Stock stock = new Stock();
//        if (!Objects.isNull(order.getPoCode()) && StringUtils.isNotBlank(order.getPoCode())) {
//            Purchase purchase = purchaseService.getOne(new LambdaQueryWrapper<Purchase>().eq(Purchase::getCode, order.getPoCode()));
//            if (!Objects.isNull(purchase)) {
//                stock.setPlatOrderNo(purchase.getPlatCode()).setPlatToken(purchase.getPlatId());
//            }
//        }
        String ruleCode = SerialRuleUtils.generateRuleCode(SerialRuleCode.SYS_STOCK_CODE, null);
        if (StringUtils.isBlank(ruleCode)) {
            throw new CoolException("当前业务：" + SerialRuleCode.SYS_STOCK_CODE + "，编码规则不存在！！");
@@ -513,10 +731,6 @@
        List<StockItem> stockItems = new ArrayList<>();
        for (TaskItem item : items) {
            /**通过任务明细中的taskId查询,获取TASK的目标库位信息*/
//            AsnOrderItem orderItem = asnOrderItemService.getOne(new LambdaQueryWrapper<AsnOrderItem>().eq(AsnOrderItem::getId, item.getOrderItemId()));
//            if (Objects.isNull(orderItem)) {
//                throw new CoolException("单据明细不存在！！");
//            }
            StockItem stockItem = new StockItem();
            BeanUtils.copyProperties(item, stockItem);
            stockItem.setSourceItemId(item.getOrderItemId())