/**
 * @Description: 入库单主表
 * @Author: jeecg-boot
 * @Date:   2025-08-05
 * @Version: V1.0
 */
public interface IWmsStockInOrdersService extends IService<WmsStockInOrders> {

   /**
    * 添加入库单
    */
   public void add(WmsStockInOrders wmsStockInOrders);
   ...
}

@Service
public class WmsStockInOrdersServiceImpl extends ServiceImpl<WmsStockInOrdersMapper, WmsStockInOrders> implements IWmsStockInOrdersService {

@Override
@Transactional(rollbackFor = Exception.class)
public void updateMain(WmsStockInOrders wmsStockInOrders,List<WmsStockInOrderItems> wmsStockInOrderItemsList) {
   //初始状态、审核失败状态可以修改
   if(!(WarehouseDictEnum.INBOUND_INITIAL.getCode().equals(wmsStockInOrders.getStatus())
         || WarehouseDictEnum.INBOUND_REJECTED.getCode().equals(wmsStockInOrders.getStatus()))){
      throw new JeecgBootException("非初始状态、审核失败状态入库单不允许修改");
   }

   if(wmsStockInOrderItemsList==null || wmsStockInOrderItemsList.size()<=0){
      //抛出异常
      throw new JeecgBootException("请选择入库单明细");
   }
   //删除入库单明细数据
   wmsStockInOrderItemsMapper.deleteByMainId(wmsStockInOrders.getId());
   //对子表数据按商品分组,使用Stream流实现
    Map<String, List<WmsStockInOrderItems>> collect = wmsStockInOrderItemsList.stream().collect(Collectors.groupingBy(WmsStockInOrderItems::getProductId));
    //对List<WmsStockInOrderItems>进行合并
    List<WmsStockInOrderItems> mergeList = new ArrayList<>();
    collect.entrySet().stream().forEach(entry -> {
       List<WmsStockInOrderItems> value = entry.getValue();
       WmsStockInOrderItems merge = value.get(0);
       //明细的状态为初始状态
       merge.setStatus(WarehouseDictEnum.INBOUND_DETAIL_INITIAL.getCode());
       //入库单主表id
       merge.setOrderId(wmsStockInOrders.getId());
       if(value!=null && value.size()>1){
          merge.setExpectedQuantity(value.stream().mapToInt(WmsStockInOrderItems::getExpectedQuantity).sum());
          mergeList.add( merge);
       }else{
          mergeList.add(merge);
       }
    });

    int sum = mergeList.stream().mapToInt(WmsStockInOrderItems::getExpectedQuantity).sum();
    wmsStockInOrders.setTotalExpectedQuantity(sum);

    //添加子表数据
    boolean b = wmsStockInOrderItemsService.saveBatch(mergeList);
    if(!b){
       throw new JeecgBootException("保存入库单明细失败");
    }
    //更新入库单
    int i = wmsStockInOrdersMapper.updateById(wmsStockInOrders);
    if(i<=0){
       throw new JeecgBootException("更新入库单失败");
    }

}

...

}

package org.jeecg.modules.wms.wmstask.service.impl;

import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import org.jeecg.common.exception.JeecgBootException;
import org.jeecg.common.util.DateUtils;
import org.jeecg.common.util.RedisUtil;
import org.jeecg.modules.wms.config.WarehouseDictEnum;
import org.jeecg.modules.wms.inorder.entity.WmsStockInOrderItems;
import org.jeecg.modules.wms.inorder.entity.WmsStockInOrders;
import org.jeecg.modules.wms.inorder.service.IWmsStockInOrderItemsService;
import org.jeecg.modules.wms.inorder.service.IWmsStockInOrdersService;
import org.jeecg.modules.wms.wmstask.entity.WmsTasks;
import org.jeecg.modules.wms.wmstask.mapper.WmsTasksMapper;
import org.jeecg.modules.wms.wmstask.service.IWmsTasksService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.transaction.annotation.Transactional;

import java.util.Date;
import java.util.List;

/**
 * @Description: 任务表
 * @Author: jeecg-boot
 * @Date:   2025-08-05
 * @Version: V1.0
 */
@Service
public class WmsTasksServiceImpl extends ServiceImpl<WmsTasksMapper, WmsTasks> implements IWmsTasksService {

    @Autowired
    private IWmsStockInOrdersService stockInOrdersService;

    @Autowired
    private IWmsStockInOrderItemsService stockInOrderItemsService;

    @Autowired
    private RedisUtil redisUtil;

    @Override
    @Transactional(rollbackFor = Exception.class)
   @Transactional(rollbackFor = Exception.class)
    public void createReceiveTask(String inOrderId, String operator) {
        //查询入库单信息
        WmsStockInOrders stockInOrders = stockInOrdersService.getById(inOrderId);
        //仓库
        String warehouseId = stockInOrders.getWarehouseId();
        //入库单状态
        String status = stockInOrders.getStatus();
        //入库单状态非审核通过时不允许创建收货任务
        if(!WarehouseDictEnum.INBOUND_APPROVED.getCode().equals(status)){
            throw new JeecgBootException("入库单审核通过方可创建收货任务");
        }
        //根据入库单id查询入库单明细列表
        List<WmsStockInOrderItems> stockInOrderItems = stockInOrderItemsService.selectByMainId(inOrderId);

        //根据入库明细列表创建收货任务
        for (WmsStockInOrderItems stockInOrderItem : stockInOrderItems) {
            //创建收货任务
            WmsTasks wmsTasks = new WmsTasks();
            //任务类型,收货任务
            wmsTasks.setTaskType(WarehouseDictEnum.TASK_TYPE_RECEIVING.getCode());
            //任务状态，已创建
            wmsTasks.setTaskStatus(WarehouseDictEnum.TASK_STATUS_CREATED.getCode());
            //任务创建时间
            wmsTasks.setCreateTime(new Date());
            //任务号
            wmsTasks.setTaskNumber(generateTaskCode());
            //目的仓库
            wmsTasks.setTargetWarehouseId(warehouseId);
            //入库单id
            wmsTasks.setStockInOrderId(stockInOrderItem.getOrderId());
            //入库单明细id
            wmsTasks.setStockInOrderItemId(stockInOrderItem.getId());
            //商品id
            wmsTasks.setProductId(stockInOrderItem.getProductId());
            //商品采购数量
            wmsTasks.setQuantity(stockInOrderItem.getExpectedQuantity());
            //完成数量为0
            wmsTasks.setCompletedQuantity(0);
            //执行人
            wmsTasks.setOperator(operator);
            //创建任务
            save(wmsTasks);

        }
       //更新入库单状态为收货中
        WmsStockInOrders stockInOrdersUpdate = new WmsStockInOrders();
        stockInOrdersUpdate.setId(inOrderId);//入库单id
        stockInOrdersUpdate.setStatus(WarehouseDictEnum.INBOUND_RECEIVING.getCode());//收货中
        boolean b = wmsStockInOrdersService.updateById(stockInOrdersUpdate);
        if(!b){
            throw new JeecgBootException("创建收货任务过程中更新入库单状态失败");
        }

        //根据入库单id更新入库单明细状态为收货中
        boolean update = wmsStockInOrderItemsService.update(null,
                new LambdaUpdateWrapper<WmsStockInOrderItems>().eq(WmsStockInOrderItems::getOrderId, inOrderId)
                        .set(WmsStockInOrderItems::getStatus, WarehouseDictEnum.INBOUND_DETAIL_RECEIVING.getCode()));
        if(!update){
            throw new JeecgBootException("创建收货任务过程中更新入库单明细状态失败");
        }

    }
    /**
     * 生成任务编号
     * 规则: TSK+年月日+5位序号，序号使用redis自增序号实现
     */
    public String generateTaskCode() {
        //参考上边的代码实现
        String time = DateUtils.now().substring(0, 10).replace("-", "");
        String key = "tsk_number"+time;
        long incr = redisUtil.incr(key, 1);
        if(incr == 1){
            //设置过期时间，设置24小时+10秒的目的是避免并发产生订单号重复
            redisUtil.expire(key, 24*60*60+10);
        }
        //将incr组成4位字符串
        String incrStr = String.format("%05d", incr);
        String taskNumber = "TSK"+time+incrStr;

        return taskNumber;
    }
}

/**
 * @Description: 任务表
 * @Author: jeecg-boot
 * @Date:   2025-08-05
 * @Version: V1.0
 */
public interface WmsTasksMapper extends BaseMapper<WmsTasks> {
    //关联查询任务列表
    List<WmsTasks> queryTaskList(WmsTasks wmsTasks);
}

public interface IWmsTasksService extends IService<WmsTasks> {

    /**
     * 查询待办理任务列表
     * @param wmsTasks
     * @return
     */
    public IPage<WmsTasks> list(WmsTasks wmsTasks, Integer pageNo, Integer pageSize);
    ...

}

/**
 * 分页查询任务列表
 * @param wmsTasks
 * @return
 */
@Override
public IPage<WmsTasks> list(WmsTasks wmsTasks, Integer pageNo, Integer pageSize) {
    Page<WmsTasks> page = PageHelper.startPage(pageNo, pageSize);
    List<WmsTasks> list = baseMapper.queryTaskList(wmsTasks);
    PageDTO<WmsTasks> wmsTasksPageDTO = new PageDTO<>();
    wmsTasksPageDTO.setRecords(list);
    wmsTasksPageDTO.setTotal(page.getTotal());
    wmsTasksPageDTO.setSize(page.getPageSize());
    wmsTasksPageDTO.setCurrent(page.getPageNum());
    wmsTasksPageDTO.setPages(page.getPages());
    return wmsTasksPageDTO;
}

/**
 * @Description: 任务表
 * @Author: jeecg-boot
 * @Date:   2025-08-05
 * @Version: V1.0
 */
public interface IWmsTasksService extends IService<WmsTasks> {

   ......

    /**
     * 收货方法
     */
    public void receive(WmsTasksRecords wmsTasksRecords);

    /**
     * 执行任务
     */
    public WmsTasks execute(WmsTasksRecords wmsTasksRecords);
}

 /**
     * 收货
     * @param wmsTasksRecords
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public void receive(WmsTasksRecords wmsTasksRecords) {
        //执行收货任务 向任务表更新收货数量，如果收货完成更新状态为收货完成，记录收货记录
        WmsTasks wmsTasks = execute(wmsTasksRecords);

        //todo 更新入库单明细中的收货数量及不良品数量，当良品数量加不良品数量等采购数量，更新状态为收货完成

        //todo 更新入库单中收货总数量，如果所有明细的状态为收货完成则么入库单的状态为收货完成

        //todo 如果入库单收货完成则创建上架任务,根据收货记录创建上架任务

    }
    /**
     * 执行任务
     */
    @Transactional(rollbackFor = Exception.class)
    public WmsTasks execute(WmsTasksRecords wmsTasksRecords) {
        //任务id
        String taskId = wmsTasksRecords.getTaskId();
        //查询任务信息
        WmsTasks wmsTasks = getById(taskId);
        //已完成数量
        Integer completedQuantity = ObjectUtils.defaultIfNull(wmsTasks.getCompletedQuantity(), 0);
//        Integer completedQuantity = wmsTasks.getCompletedQuantity()==null?0:wmsTasks.getCompletedQuantity();
        //执行数量
        Integer quantity = wmsTasksRecords.getExecQuantity();
        if(completedQuantity + quantity > wmsTasks.getQuantity()){
            throw new JeecgBootException("执行数量不能大于计划数量");
        }
        //拷贝执行任务的信息到任务记录对象、商品id,任务号,任务类型
        //仓库id
        wmsTasksRecords.setTargetWarehouseId(wmsTasks.getTargetWarehouseId());
        //入库单id
        wmsTasksRecords.setStockInOrderId(wmsTasks.getStockInOrderId());
        //入库单明细id
        wmsTasksRecords.setStockInOrderItemId(wmsTasks.getStockInOrderItemId());
        //波次id 用于波次管理
        wmsTasksRecords.setWaveOrderId(wmsTasks.getWaveOrderId());
        //波次拣货明细id 用于波次管理
        wmsTasksRecords.setWaveSkuSummaryId(wmsTasks.getWaveSkuSummaryId());
        //任务id
        wmsTasksRecords.setTaskId(wmsTasks.getId());
        //商品 id
        wmsTasksRecords.setProductId(wmsTasks.getProductId());
        //任务编码
        wmsTasksRecords.setTaskNumber(wmsTasks.getTaskNumber());
        //任务类型
        wmsTasksRecords.setTaskType(wmsTasks.getTaskType());
        //执行时间
        wmsTasksRecords.setOperationTime(new Date());
        //执行人
        wmsTasksRecords.setOperator(wmsTasks.getOperator());
        //添加执行任务记录
       boolean save = wmsTasksRecordsService.save(wmsTasksRecords);
        if(!save){
            throw new JeecgBootException("添加任务执行记录失败!");
        }

        //更新任务表中的完成数量,新的完成数量为原有完成数量加收货记录的完成数量
        //        String sql = "update wms_tasks set completed_quantity = completed_quantity + #{ExecQuantity } where id = #{taskId} and completed_quantity <= quantity-#{ExecQuantity }";
        LambdaUpdateWrapper<WmsTasks> wmsTasksLambdaUpdateWrapper = new LambdaUpdateWrapper<>();
        wmsTasksLambdaUpdateWrapper.setSql("completed_quantity = completed_quantity + "+wmsTasksRecords.getExecQuantity())
                .eq(WmsTasks::getId,taskId)
                .le(WmsTasks::getCompletedQuantity,wmsTasks.getQuantity()-wmsTasksRecords.getExecQuantity());
        int update = getBaseMapper().update(null, wmsTasksLambdaUpdateWrapper);
        if(update <= 0){
            throw new JeecgBootException("执行数量不能大于计划数量!");
        }
        //如果完成数量等于计划数量,更新任务状态为已完成
        //查询新的任务信息
        wmsTasks = getById(taskId);
        //完成数量
        completedQuantity = wmsTasks.getCompletedQuantity();
        //更新任务为已完成
        if(completedQuantity==wmsTasks.getQuantity()) {
            wmsTasks.setTaskStatus(WarehouseDictEnum.TASK_STATUS_COMPLETED.getCode());
            boolean b = updateById(wmsTasks);
            if(!b){
                throw new JeecgBootException("更新任务状态失败!");
            }
        }
        return wmsTasks;

    }

/**
 * 更新收货完成状态
 * @param stockInOrderItemId 入库单明细id
 */
@Override
public void updateReceivedStatus(String stockInOrderItemId){
   //查询入库单明细
      WmsStockInOrderItems stockInOrderItemUpdate = getById(stockInOrderItemId);

      //根据入库单明细id查询任务记录表
      LambdaQueryWrapper<WmsTasksRecords> eq = new LambdaQueryWrapper<WmsTasksRecords>().eq(WmsTasksRecords::getStockInOrderItemId, stockInOrderItemId);
      List<WmsTasksRecords> wmsTasksRecordsList = wmsTasksRecordsService.list(eq);
      //使用stream流汇总wmsTasksRecordsList中的不良品数量
      int badQuantity = wmsTasksRecordsList.stream().filter(wmsTasksRecord -> wmsTasksRecord.getInventoryAttribute().equals(WarehouseDictEnum.INVENTORY_ATTRIBUTE_DEFECTIVE.getCode())).mapToInt(WmsTasksRecords::getExecQuantity).sum();
      //良品数量
      int goodQuantity = wmsTasksRecordsList.stream().filter(wmsTasksRecord -> wmsTasksRecord.getInventoryAttribute().equals(WarehouseDictEnum.INVENTORY_ATTRIBUTE_GOOD.getCode())).mapToInt(WmsTasksRecords::getExecQuantity).sum();
      if(badQuantity > 0){
         stockInOrderItemUpdate.setDefectiveQuantity(badQuantity);
      }
      if(goodQuantity > 0){
         stockInOrderItemUpdate.setReceivedQuantity(goodQuantity);
      }
      //如果良品数量加不良品数量等于入库单明细采购数量则更新入库单明细状态为已完成
      if(stockInOrderItemUpdate.getExpectedQuantity().equals(stockInOrderItemUpdate.getReceivedQuantity() + stockInOrderItemUpdate.getDefectiveQuantity())){
         stockInOrderItemUpdate.setStatus(WarehouseDictEnum.INBOUND_DETAIL_RECEIVED.getCode());
      }

      updateById(stockInOrderItemUpdate);
}

/**
 * 更新收货完成状态
 * @param stockInOrderId 入库单id
 */
public String updateReceivedStatus(String stockInOrderId){
       WmsStockInOrders stockInOrdersUpdate = getById(stockInOrderId);
    if(stockInOrdersUpdate==null) {
       //异常
       throw new JeecgBootException("入库单不存在");
    }
    //当前状态只有是收货中或审核通过时方可更新收货状态
    if(!(WarehouseDictEnum.INBOUND_RECEIVING.getCode().equals(stockInOrdersUpdate.getStatus())
    || WarehouseDictEnum.INBOUND_APPROVED.getCode().equals(stockInOrdersUpdate.getStatus()))){
       throw new JeecgBootException("非收货中、审核通过状态入库单不允许更新收货状态");
    }
    //根据入库单id查询所有入库单明细的完成数量总和
    List<WmsStockInOrderItems> stockInOrderItems = stockInOrderItemsService.selectByMainId(stockInOrderId);
    //使用stream流汇总stockInOrderItems中完成收货数量总和
    int totalCompletedQuantity = stockInOrderItems.stream().mapToInt(WmsStockInOrderItems::getReceivedQuantity).sum();
    //不良品数量
    int totalBadQuantity = stockInOrderItems.stream().mapToInt(WmsStockInOrderItems::getDefectiveQuantity).sum();
    // 如果stockInOrderItems中存在一个未收货完成则最终状态为未收货完成，否则为收货完成
    boolean b1 = stockInOrderItems.stream().anyMatch(stockInOrderItem -> !stockInOrderItem.getStatus().equals(WarehouseDictEnum.INBOUND_DETAIL_RECEIVED.getCode()));
    //新状态
    String status = b1 ? WarehouseDictEnum.INBOUND_RECEIVING.getCode() : WarehouseDictEnum.INBOUND_RECEIVED.getCode();
    //更新收货总量
    stockInOrdersUpdate.setTotalReceivedQuantity(totalCompletedQuantity);
    //更新不良品数量
    stockInOrdersUpdate.setTotalDefectiveQuantity(totalBadQuantity);
    stockInOrdersUpdate.setStatus(status);
    updateById(stockInOrdersUpdate);
    return status;
}

/**
 * 收货
 * @param wmsTasksRecords
 */
@Override
@Transactional(rollbackFor = Exception.class)
public void receive(WmsTasksRecords wmsTasksRecords) {
    //执行收货任务
    WmsTasks wmsTasks = execute(wmsTasksRecords);
    //更新入库单明细中的收货数量及不良品数量，当良品数量加不良品数量等采购数量，更新状态为收货完成
    stockInOrderItemsService.updateReceivedStatus(wmsTasks.getStockInOrderItemId());
    //更新入库单状态为收货完成或收货中
    String inOrderStatus = stockInOrdersService.updateReceivedStatus(wmsTasks.getStockInOrderId());

    //todo 如果入库单收货完成则创建上架任务,根据收货记录创建上架任务

}

@Data
@TableName("wms_tasks_records")
@Accessors(chain = true)
@EqualsAndHashCode(callSuper = false)
@Schema(description="任务表")
public class WmsTasksRecords implements Serializable {
.....
//入库单号
@TableField(exist = false)
private java.lang.String stockInOrderNumber;

//商品名称
@TableField(exist = false)
private java.lang.String productName;

//货主
@TableField(exist = false)
private java.lang.String ownerName;
//仓库名称
@TableField(exist = false)
private java.lang.String warehouseName;

}

@Service
public class WmsInventoryTransByReceiving extends ServiceImpl<WmsInventoryTransMapper, WmsInventoryTrans> implements IWmsInventoryTransService {

    @Autowired
    private IWmsInventoryService wmsInventoryService;

    //注入储位表service
    @Autowired
    private IWmsStorageLocationsService wmsStorageLocationsService;

    //注入储区service
    @Autowired
    private IWmsStorageZonesService wmsStorageZonesService;

    //注入商品service
    @Autowired
    private IWmsProductsService wmsProductsService;

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void transfer(WmsInventoryTransParam inventoryTransParam) {
        //非空判断，目标储位、商品id、执行数量,是否可售
        if (StringUtils.isEmpty(inventoryTransParam.getTargetLocationCode())
                || StringUtils.isEmpty(inventoryTransParam.getProductId())
                ||  inventoryTransParam.getExecQuantity() == null
                || StringUtils.isEmpty(inventoryTransParam.getIsSellable())) {
            throw new RuntimeException("目标储位、商品id、执行数量、是否可售不能为空");
        }

        //查询商品信息
        WmsProducts products = wmsProductsService.getById(inventoryTransParam.getProductId());
        if (products == null) {
            //抛出异常
            throw new RuntimeException("商品id在商品表中不存在");
        }
        //根据储位编码查询储位 信息
        LambdaQueryWrapper<WmsStorageLocations> eq = new LambdaQueryWrapper<WmsStorageLocations>().eq(WmsStorageLocations::getLocationCode, inventoryTransParam.getTargetLocationCode());
        WmsStorageLocations wmsStorageLocations = wmsStorageLocationsService.getBaseMapper().selectOne(eq);
        if (wmsStorageLocations == null) {
            //抛出异常
            throw new RuntimeException("储位编码在储位表中不存在");
        }
        //库存属性 1：可售 2：不可售
        String isSellable = inventoryTransParam.getIsSellable();

        //根据唯一key获取库存
        WmsInventory wmsInventoryDb = wmsInventoryService.getInventoryByUniqueKey(inventoryTransParam.getProductId(), inventoryTransParam.getTargetLocationCode(), inventoryTransParam.getBatchNumber());
        //判断库存是否为空
        if (wmsInventoryDb == null) {

            //创建库存对象
            wmsInventoryDb = new WmsInventory();
            BeanUtils.copyProperties(inventoryTransParam,wmsInventoryDb);
            wmsInventoryDb.setOwnerId(products.getOwnerId());
            wmsInventoryDb.setStockQuantity(inventoryTransParam.getExecQuantity());
            wmsInventoryDb.setLocationCode(inventoryTransParam.getTargetLocationCode());
            //如果储位是可售库存，则设置可用库存为数量
            wmsInventoryDb.setAvailableQuantity(isSellable.equals("1")?inventoryTransParam.getExecQuantity():0);
            wmsInventoryDb.setAllocatedQuantity(0);
            //是否可售
            wmsInventoryDb.setIsSellable(isSellable);
            //入库时间
            wmsInventoryDb.setStockInTime(inventoryTransParam.getOperationTime());
            wmsInventoryService.save(wmsInventoryDb);
        }else{
            LambdaUpdateWrapper<WmsInventory> wmsInventoryLambdaUpdateWrapper = new LambdaUpdateWrapper<WmsInventory>()
                    .eq(WmsInventory::getId, wmsInventoryDb.getId())
                    .setSql("stock_quantity=stock_quantity+{0}", inventoryTransParam.getExecQuantity())
                    .setSql(isSellable.equals("1"),"available_quantity=available_quantity+{0}", inventoryTransParam.getExecQuantity());
            wmsInventoryService.update(null,wmsInventoryLambdaUpdateWrapper);

        }

    }
}