@Service
public class WmsOutOrdersServiceImpl extends ServiceImpl<WmsOutOrdersMapper, WmsOutOrders> implements IWmsOutOrdersService {
....
    
    /**
     * 分配库存
     * @param orderId 出库单ID
     * @return 分配状态 ："ALLOCATED"-分配成功 分配失败 "ALLOCATED_FAILED"-分配失败
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public String allocateStock(String orderId) {
    
       //查询出库单
       WmsOutOrders wmsOutOrders = wmsOutOrdersMapper.selectById(orderId);
       //仓库id
       String warehouseId = wmsOutOrders.getWarehouseId();
       //出库单状态
       String status = wmsOutOrders.getStatus();
       //状态为审核通过状态或分配失败时才能继续
       if(!(WarehouseDictEnum.OUTBOUND_APPROVED.getCode().equals(status))
             &&!(WarehouseDictEnum.OUTBOUND_FAILED.getCode().equals(status))){
          throw new JeecgBootException("非审核通过状态、分配失败状态出库单不允许分配库存");
       }
       //查询出库单明细
       List<WmsOutOrdersItems> skuItems = wmsOutOrdersItemsService.selectByMainId(orderId);
       //找到未分配的出库单明细(状态为创建状态为分配失败状态)
       List<WmsOutOrdersItems> unAllocatedItems = skuItems.stream()
             .filter(item -> WarehouseDictEnum.OUTBOUND_DETAIL_CREATED.getCode().equals(item.getStatus()) || WarehouseDictEnum.OUTBOUND_DETAIL_FAILED.getCode().equals(item.getStatus()))
             .collect(Collectors.toList());
       //如果未分配的出库单明细为空则返回已分配
       if(CollectionUtils.isEmpty(unAllocatedItems)){
          return WarehouseDictEnum.OUTBOUND_ALLOCATED.getCode();
       }
       //遍历未分配的出库单明细
        for(WmsOutOrdersItems skuItem:unAllocatedItems) {
           //todo 查询可用库存列表

    
           //todo 进行库存分配
 
        }
    
        //todo更新出库单分配状态

    }
 ....
 
}

/**
 * 分配库存
 * @param orderId 出库单ID
 * @return 分配状态 ："ALLOCATED"-分配成功 分配失败 "ALLOCATED_FAILED"-分配失败
 */
@Override
@Transactional(rollbackFor = Exception.class)
@Override
@Transactional(rollbackFor = Exception.class)
public String allocateStock(String orderId) {

   //查询出库单
   WmsOutOrders wmsOutOrders = wmsOutOrdersMapper.selectById(orderId);
   //仓库id
   String warehouseId = wmsOutOrders.getWarehouseId();
   //出库单状态
   String status = wmsOutOrders.getStatus();
   //状态为审核通过状态或分配失败时才能继续
   if(!(WarehouseDictEnum.OUTBOUND_APPROVED.getCode().equals(status))
         &&!(WarehouseDictEnum.OUTBOUND_FAILED.getCode().equals(status))){
      throw new JeecgBootException("非审核通过状态、分配失败状态出库单不允许分配库存");
   }
   //查询出库单明细
   List<WmsOutOrdersItems> skuItems = wmsOutOrdersItemsService.selectByMainId(orderId);
   //找到未分配的出库单明细(状态为创建或状态为分配失败)
   List<WmsOutOrdersItems> unAllocatedItems = skuItems.stream()
         .filter(item -> WarehouseDictEnum.OUTBOUND_DETAIL_CREATED.getCode().equals(item.getStatus()) || WarehouseDictEnum.OUTBOUND_DETAIL_FAILED.getCode().equals(item.getStatus()))
         .collect(Collectors.toList());
   if(CollectionUtils.isEmpty(unAllocatedItems)){
      return WarehouseDictEnum.OUTBOUND_FAILED.getCode();
   }
   //遍历未分配的出库单明细
   for(WmsOutOrdersItems skuItem:unAllocatedItems) {
      //查询可用库存列表
      List<WmsInventory> wmsInventories = wmsInventoryService.selectAvailableBySku(warehouseId, skuItem);

      //todo 进行库存分配
      
   }

   //todo 更新出库单分配状态
  
}

public interface IWmsOutOrdersService extends IService<WmsOutOrders> {

   ....

   /**
    * 为商品分配库存
    * @param item 需分配的出库明细
    * @param availableStocks 可用库存明细
    * @return  分配状态
    */
   public String allocateStockToItems(WmsOutOrdersItems item,
                              List<WmsInventory> availableStocks);
}

/**
    * 为商品分配库存
    * @param item 需分配的出库明细
    * @param availableStocks 可用库存明细
    * @return  分配状态
    */
   @Transactional(rollbackFor = Exception.class)
public String allocateStockToItems(WmsOutOrdersItems item, List<WmsInventory> availableStocks) {

   //遍历可用库存
   for(WmsInventory inventory:availableStocks){
      //商品计划分配数量
      Integer expectedQuantity = item.getExpectedQuantity();
      //已分配数量
      Integer allocatedQuantity = item.getAllocatedQuantity();
      //剩余分配数量
      Integer remainingQuantity = expectedQuantity - allocatedQuantity;
      //如果分配完成，退出循环
      if(remainingQuantity<=0){
         break;
      }
      //可用库存数量
      Integer availableQuantity = inventory.getAvailableQuantity();
      if(availableQuantity<=0){
         continue;
      }
      //本次要分配数量
      Integer allocateQuantity = Math.min(availableQuantity, remainingQuantity);

      //向库存分配表插入记录
      WmsOutOrdersAllocation wmsOutOrdersAllocation = new WmsOutOrdersAllocation();
      wmsOutOrdersAllocation.setOrderId(item.getOrderId());
      wmsOutOrdersAllocation.setOrderItemId(item.getId());
      wmsOutOrdersAllocation.setSkuId(item.getSkuId());
      wmsOutOrdersAllocation.setLocationCode(inventory.getLocationCode());
      wmsOutOrdersAllocation.setBatchNumber(inventory.getBatchNumber());
      wmsOutOrdersAllocation.setContainerCode(inventory.getContainerCode());
      wmsOutOrdersAllocation.setAllocatedQuantity(allocateQuantity);
      wmsOutOrdersAllocation.setInventoryId(inventory.getId());
      outOrdersAllocationService.save(wmsOutOrdersAllocation);

      //锁定库存
      WmsInventoryTransParam wmsInventoryTransParam = new WmsInventoryTransParam();
      wmsInventoryTransParam.setProductId(item.getSkuId());
      wmsInventoryTransParam.setExecQuantity(allocateQuantity);
      wmsInventoryTransParam.setSourceLocationCode(inventory.getLocationCode());
      wmsInventoryTransParam.setWarehouseId(inventory.getWarehouseId());
      wmsInventoryTransParam.setBatchNumber(inventory.getBatchNumber());
      wmsInventoryTransParam.setTransactionType(WarehouseDictEnum.INVENTORY_ALLOCATION.getCode());
      wmsInventoryTransParam.setOperationTime(new Date());
      wmsInventoryTransByAllocation.transfer(wmsInventoryTransParam);

      //更新出库单明细中分配数量
      wmsOutOrdersItemsService.allocateStock(item.getId(), allocateQuantity);
      //查询最新的item
      item = wmsOutOrdersItemsService.getById(item.getId());
   }
   //更新出库单明细的状态(已分配或分配失败)
   String allocateStatus = wmsOutOrdersItemsService.updateAllocateStatus(item.getId());

   return allocateStatus;
}

/**
 * 分配库存
 * @param orderId 出库单ID
 * @return 分配状态 ："ALLOCATED"-分配成功 分配失败 "ALLOCATED_FAILED"-分配失败
 */
@Override
@Transactional(rollbackFor = Exception.class)
public String allocateStock(String orderId) {

   //查询出库单
   WmsOutOrders wmsOutOrders = wmsOutOrdersMapper.selectById(orderId);
   //仓库id
   String warehouseId = wmsOutOrders.getWarehouseId();
   //出库单状态
   String status = wmsOutOrders.getStatus();
   //状态为审核通过状态或分配失败时才能继续
   if(!(WarehouseDictEnum.OUTBOUND_APPROVED.getCode().equals(status))
         &&!(WarehouseDictEnum.OUTBOUND_FAILED.getCode().equals(status))){
      throw new JeecgBootException("非审核通过状态、分配失败状态出库单不允许分配库存");
   }
   //查询出库单明细
   List<WmsOutOrdersItems> skuItems = wmsOutOrdersItemsService.selectByMainId(orderId);
   //找到未分配的出库单明细(状态为创建或状态为分配失败)
   List<WmsOutOrdersItems> unAllocatedItems = skuItems.stream()
         .filter(item -> WarehouseDictEnum.OUTBOUND_DETAIL_CREATED.getCode().equals(item.getStatus()) || WarehouseDictEnum.OUTBOUND_DETAIL_FAILED.getCode().equals(item.getStatus()))
         .collect(Collectors.toList());
   if(CollectionUtils.isEmpty(unAllocatedItems)){
      return WarehouseDictEnum.OUTBOUND_FAILED.getCode();
   }
   //遍历未分配的出库单明细
   for(WmsOutOrdersItems skuItem:unAllocatedItems) {
      //查询可用库存列表
      List<WmsInventory> wmsInventories = wmsInventoryService.selectAvailableBySku(warehouseId, skuItem);

      //进行库存分配
        String s = allocateStockToItems(skuItem, wmsInventories);
        //如果分配失败则抛出异常
        if(!s.equals(WarehouseDictEnum.OUTBOUND_DETAIL_ALLOCATED.getCode())){
           throw new JeecgBootException("分配库存失败");
        }
   }

   //更新出库单分配状态
    String allocateStatus = updateAllocateStatus(orderId);
    return allocateStatus;
  
}

package org.jeecg.modules.wms.designmode;

// 抽象处理者
public abstract class Approver {
    protected Approver nextApprover;  // 下一个处理者

    // 设置下一个处理者
    public void setNextApprover(Approver nextApprover) {
        this.nextApprover = nextApprover;
    }

    // 处理请求的方法
    public abstract void processRequest(PurchaseRequest request);
}

package org.jeecg.modules.wms.designmode;

import lombok.Data;

// 请求类
@Data
public class PurchaseRequest {
    private int id;
    private double amount;
    private String purpose;

    public PurchaseRequest(int id, double amount, String purpose) {
        this.id = id;
        this.amount = amount;
        this.purpose = purpose;
    }
}

package org.jeecg.modules.wms.designmode;

// 项目经理
public class ProjectManager extends Approver {
    @Override
    public void processRequest(PurchaseRequest request) {
        System.out.println("项目经理审批采购单：" + request.getId() +
                "，金额：" + request.getAmount() +
                "，用途：" + request.getPurpose());
        if (nextApprover != null) {
            nextApprover.processRequest(request);
        }
    }
}

// 部门经理
public class DepartmentManager extends Approver {
    @Override
    public void processRequest(PurchaseRequest request) {
        if (request.getAmount() > 1000 ) {
            System.out.println("部门经理审批采购单：" + request.getId() +
                    "，金额：" + request.getAmount() +
                    "，用途：" + request.getPurpose());
        }
        if (nextApprover != null) {
            nextApprover.processRequest(request);
        }
    }
}

// 总经理
public class GeneralManager extends Approver {
    @Override
    public void processRequest(PurchaseRequest request) {
        if(request.getAmount() > 5000){
            System.out.println("总经理审批采购单：" + request.getId() +
                    "，金额：" + request.getAmount() +
                    "，用途：" + request.getPurpose());
        }
    }
}

public class Client {
    public static void main(String[] args) {
        // 创建处理者
        Approver projectManager = new ProjectManager();
        Approver departmentManager = new DepartmentManager();
        Approver generalManager = new GeneralManager();
        
        // 设置责任链
        projectManager.setNextApprover(departmentManager);
        departmentManager.setNextApprover(generalManager);
        
        // 创建请求
        PurchaseRequest request1 = new PurchaseRequest(1, 800, "购买办公用品");
        PurchaseRequest request2 = new PurchaseRequest(2, 3500, "购买服务器");
        PurchaseRequest request3 = new PurchaseRequest(3, 10000, "购买新设备");
        
        // 处理请求
        // projectManager.processRequest(request1);
        // projectManager.processRequest(request2);
        projectManager.processRequest(request3);
    }
}

package org.jeecg.modules.wms.designmode2;

import lombok.Data;

// 订单类
@Data
class Order {
    private double amount;
    private boolean isMember;
    private boolean isHoliday;
    private boolean isFirstOrder;

    public Order(double amount, boolean isMember, boolean isHoliday, boolean isFirstOrder) {
        this.amount = amount;
        this.isMember = isMember;
        this.isHoliday = isHoliday;
        this.isFirstOrder = isFirstOrder;
    }
}

package org.jeecg.modules.wms.designmode2;

// 会员折扣策略
class MemberDiscount implements DiscountStrategy {
    @Override
    public boolean apply(Order order) {
        if (order.isMember()) {
            double newAmount = order.getAmount() * 0.9; // 会员9折
            order.setAmount(newAmount);
            System.out.println("应用会员折扣，新金额: " + newAmount);
            return true;
        }
        return false;
    }
}

// 节日折扣策略
class HolidayDiscount implements DiscountStrategy {
    @Override
    public boolean apply(Order order) {
        if (order.isHoliday()) {
            double newAmount = order.getAmount() * 0.85; // 节日85折
            order.setAmount(newAmount);
            System.out.println("应用节日折扣，新金额: " + newAmount);
            return true;
        }
        return false;
    }
}

// 首单折扣策略
class FirstOrderDiscount implements DiscountStrategy {
    @Override
    public boolean apply(Order order) {
        if (order.isFirstOrder()) {
            double newAmount = order.getAmount() * 0.8; // 首单8折
            order.setAmount(newAmount);
            System.out.println("应用首单折扣，新金额: " + newAmount);
            return true;
        }
        return false;
    }
}

// 大额订单折扣策略
class BigOrderDiscount implements DiscountStrategy {
    @Override
    public boolean apply(Order order) {
        if (order.getAmount() > 1000) {
            double newAmount = order.getAmount() * 0.7; // 大额7折
            order.setAmount(newAmount);
            System.out.println("应用大额折扣，新金额: " + newAmount);
            return true;
        }
        return false;
    }
}

package org.jeecg.modules.wms.designmode2;

import java.util.ArrayList;
import java.util.List;

// 折扣策略链
class DiscountStrategyChain {
    private List<DiscountStrategy> strategies = new ArrayList<>();

    public DiscountStrategyChain addStrategy(DiscountStrategy strategy) {
        strategies.add(strategy);
        return this;
    }

    public void applyDiscounts(Order order) {
        for (DiscountStrategy strategy : strategies) {
            strategy.apply(order);
        }
    }
}

package org.jeecg.modules.wms.designmode2;

// 客户端代码
public class OrderProcessingDemo {
    public static void main(String[] args) {
        // 创建策略链
        DiscountStrategyChain chain = new DiscountStrategyChain();
        chain.addStrategy(new MemberDiscount())
             .addStrategy(new HolidayDiscount())
             .addStrategy(new FirstOrderDiscount())
             .addStrategy(new BigOrderDiscount());

        // 处理订单1: 会员 + 节日
        System.out.println("\n处理订单1:");
        Order order1 = new Order(500, true, true, false);
        chain.applyDiscounts(order1);
        System.out.println("最终金额: " + order1.getAmount());

        // 处理订单2: 首单 + 大额
        System.out.println("\n处理订单2:");
        Order order2 = new Order(1500, false, false, true);
        chain.applyDiscounts(order2);
        System.out.println("最终金额: " + order2.getAmount());

        // 处理订单3: 无折扣
        System.out.println("\n处理订单3:");
        Order order3 = new Order(200, false, false, false);
        chain.applyDiscounts(order3);
        System.out.println("最终金额: " + order3.getAmount());
    }
}

package org.jeecg.modules.wms.wave.strategy;

import org.jeecg.modules.wms.outorder.entity.WmsOutOrders;
import org.jeecg.modules.wms.outorder.entity.WmsOutOrdersAllocation;

import java.util.List;
import java.util.Map;

/**
 * 波次策略接口
 */
public abstract class IWaveStrategy {
    
    /**
     * 下一个策略
     */
    private IWaveStrategy nextStrategy;

    public void setNextStrategy(IWaveStrategy nextStrategy) {
        this.nextStrategy = nextStrategy;
    }

    /**
     * 创建波次
     * @param orders 待处理的订单列表
     * @param allocationsMap 订单分配明细映射
     */
    abstract void process(List<WmsOutOrders> orders,
                             Map<String, List<WmsOutOrdersAllocation>> allocationsMap);

    /**
     * 获取策略类型
     */
    abstract String getStrategyType();

    /**
     * 获取策略优先级(数值越小优先级越高)
     */
    abstract int getPriority();

    /**
     * 下一个策略
     */
    public IWaveStrategy  next(){
        return nextStrategy;
    }
    /**
     * 执行下一个策略
     */
    public void processNext(List<WmsOutOrders> orders, Map<String, List<WmsOutOrdersAllocation>> allocationsMap) {
        if (orders.size() > 0 && next() != null) {
            next().process(orders, allocationsMap);
        }
    }    
}

package org.jeecg.modules.wms.wave.strategy;

import lombok.RequiredArgsConstructor;
import org.jeecg.modules.wms.outorder.entity.WmsOutOrders;
import org.jeecg.modules.wms.outorder.entity.WmsOutOrdersAllocation;
import org.jeecg.modules.wms.outorder.entity.WmsOutOrdersItems;
import org.jeecg.modules.wms.outorder.service.IWmsOutOrdersItemsService;
import org.jeecg.modules.wms.wave.entity.WmsWaveStrategy;
import org.jeecg.modules.wms.wave.service.IWaveStrategyService;
import org.jeecg.modules.wms.wave.service.IWmsWaveMasterService;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;

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

/**
 * 单品单件波次策略 - SISQ
 * 条件：订单中只有一个SKU，且总数量为1
 */
@Component
@RequiredArgsConstructor
public class SISQWaveStrategy extends IWaveStrategy {

    private final IWmsWaveMasterService wmsWaveMasterService;

    private final IWaveStrategyService waveStrategyService;

    private final IWmsOutOrdersItemsService wmsOutOrdersItemsService;

    @Override
    public void process(List<WmsOutOrders> orders,
                        Map<String, List<WmsOutOrdersAllocation>> allocationsMap) {
        //包裹策略为STANDARD_STRATEGY
        String shipmentStrategy = "STANDARD_STRATEGY";
        //找到符合单品单件的订单
        List<WmsOutOrders> matchedOrders = orders.stream()
                .filter(order -> order.getTotalSku() == 1 && order.getTotalQuantity() == 1)
                .collect(Collectors.toList());
        if (CollectionUtils.isEmpty(matchedOrders)) {
            processNext(orders, allocationsMap);
            return;
        }
        //从数据库取出当前策略的详细信息
        WmsWaveStrategy strategyByCode = waveStrategyService.getStrategyByCode(this.getStrategyType());
        //最小订单数
        int minOrderCount = strategyByCode.getMinOrderCount();
        //出库单id
        List<String> orderIds = matchedOrders.stream().map(WmsOutOrders::getId).collect(Collectors.toList());

        //根据出库单id查询出库单明细
        List<WmsOutOrdersItems> allocations = wmsOutOrdersItemsService.selectByOrderIds(orderIds);

        //遍历matchedOrders,从allocations中找到对应的出库单明细并找到skuId，赋值到matchedOrders的对象中
        for (WmsOutOrders order : matchedOrders) {
            WmsOutOrdersItems allocation = allocations.stream()
                    .filter(item -> item.getOrderId().equals(order.getId()))
                    .findFirst()
                    .orElse(new WmsOutOrdersItems());
            order.setSkuId(allocation.getSkuId());
        }

        //对matchedOrders按skuId分组
        Map<String, List<WmsOutOrders>> groupedOrders = matchedOrders.stream().collect(Collectors.groupingBy(WmsOutOrders::getSkuId));
        //添加到波次的订单
        List<WmsOutOrders> wmsOutOrders = new ArrayList<>();
        //遍历groupedOrders
        for (Map.Entry<String, List<WmsOutOrders>> entry : groupedOrders.entrySet()) {
            List<WmsOutOrders> skuOrders = entry.getValue();
            if (skuOrders.size() >= minOrderCount) {
                wmsWaveMasterService.addWave(skuOrders, getStrategyType(), shipmentStrategy);
                wmsOutOrders.addAll(skuOrders);
            }
        }

        //剩余的订单
        List<WmsOutOrders> collect = orders.stream()
                .filter(order -> !wmsOutOrders.contains(order))
                .collect(Collectors.toList());
        //执行下一个
        processNext(collect, allocationsMap);

    }



    @Override
    public String getStrategyType() {
        return "SISQ";
    }

    @Override
    public int getPriority() {
        return 1;
    }
}

package org.jeecg.modules.wms.wave.strategy;

import org.jeecg.modules.wms.outorder.entity.WmsOutOrders;
import org.jeecg.modules.wms.outorder.entity.WmsOutOrdersAllocation;

import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

/**
 * 创建波次客户端类
 */
public class WaveCreateClient {

    private IWaveStrategy firstStrategy;
    /**
     * 构造方法
     *
     * @param strategies         全部波次策略
     * @param selectedStrategies 选中的波次策略编码
     */
    public WaveCreateClient(List<IWaveStrategy> strategies, List<String> selectedStrategies) {
        // 从全部策略中，获取选中的策略，按优先级排序策略
        List<IWaveStrategy> filteredStrategies = strategies.stream()
                .filter(strategy -> selectedStrategies.contains(strategy.getStrategyType()))
                .sorted((s1, s2) -> Integer.compare(s1.getPriority(), s2.getPriority()))
                .collect(Collectors.toList());
        if(CollectionUtils.isEmpty( filteredStrategies )){
            return;
        }
        //将filteredStrategies中的策略对象组成责任链
        //获取第一个策略
        firstStrategy = filteredStrategies.get(0);
        //将剩余的策略设置成第一个策略的nextStrategy
        for (int i = 1; i < filteredStrategies.size(); i++) {
            filteredStrategies.get(i - 1).setNextStrategy(filteredStrategies.get(i));
        }

    }

    /**
     * 处理订单波次分配
     */
    public void process(List<WmsOutOrders> orders,
                       Map<String, List<WmsOutOrdersAllocation>> allocationsMap) {
        if(firstStrategy == null){
            throw new JeecgBootException("没有配置波次策略");
        }
        firstStrategy.process(orders, allocationsMap);
    }
}