//所有类属性对外暴露和修改
@Data
public class OrderInfo {

    private String orderNo;

    private String externalOrderNo;

    private OrderSource orderSource;

    private OrderStatus orderStatus;

    public List<SkuItemInfo> skuInfos;

}

OrderInfo orderInfo = new OrderInfo();
//发生业务 需要挂起订单 ,已发货的无需挂起
if(this.orderStatus != OrderStatus.FULFILLED){
    orderInfo.setOrderStatus(OrderStatus.HANG_UP);//类的属性随时可以通过set方法变更
}

//只暴露订单域和其他域需要协助的类属性
@Getter
public class OrderInfo {

    private String orderNo;

    private String externalOrderNo;

    private OrderSource orderSource;

    private OrderStatus orderStatus;

    public List<SkuItemInfo> skuInfos;

    public static OrderInfo create(OrderCreateCommand createCommand){
        OrderInfo orderInfo = new OrderInfo();
        orderInfo.externalOrderNo = createCommand.getExternalOrderNo();
        orderInfo.orderSource = createCommand.getOrderSource();
        //其他属性赋值
        return orderInfo;
    }
    /**
     * 订单挂起(领域方法)
     */
    public void hangup(){
        if(this.orderStatus == OrderStatus.FULFILLED){
            return;
        }
        this.orderStatus = OrderStatus.HANG_UP;
    }
}
OrderCreateCommand command = getOrderCreateCommand();
OrderInfo orderInfo = OrderInfo.create(command);
//发生业务 需要挂起订单 已发货的无需挂起
orderInfo.hangup();

   //创建订单聚合
   OrderCreateAggregate aggregate = OrderCreateAggregate.create(command);
  //是否重复创建
   orderCreateDomainService.isExist(aggregate);
  //初始化聚合业务的必要信息
   orderCreateDomainService.initBaseInfo(aggregate);
  //订单风控审核
   orderCreateDomainService.audit(aggregate);
  //金额拆分
   aggregate.priceCalculate();
  //sku发货优先级处理
   aggregate.priorityProcessing();
  //新增订单
   orderCreateRepository.save(aggregate);
  //发布订单创建事件，通知履约集合 拆单、分厂
   orderEventPublisher.publish(new OrderCreatedEvent(aggregate.getOrderId().getOrderNo()));

orderCreateDomainService.deductInventory(aggregate);

public void deductInventory(OrderCreateAggregate aggregate){
    DeductInventoryRequest request = DeductInventoryRequest.builder()
                .build();
    //通过南向网关调用 库存域进行库存扣减
    DeductInventoryResponse response = inventoryGateway.deduct(request);
    //domain service 调用聚合的领域方法 完成库存扣减后逻辑
    aggregate.deductInventory(response.getInventoryInfos());
}
    

@Getter
public class OrderFulfillAggregate {

    /**
     * 订单号
     */
    private String orderNo;

    /**
     * 店铺编码
     */
    private String storeCode;

    /**
     * 订单下单skuItemMap
     */
    private List<FulfillSkuItem> fulfillSkuItems;


    /**
     * sku 仓库库存信息
     */
    private List<FulfillWarehouse> fulfillWarehouses;

    /**
     * SKU-仓库映射关系
     */
    private Map<String,String> skuMappingWarehouseMap;

    /**
     *店铺-仓库映射关系
     */
    private Map<String,String> storeMappingWarehouseMap;


    /**
     * 拆单拆单结果
     */
    private Map<String,List<OrderSplitResult>> splitOrders;


    /**
     * 工厂创建或者构造函数都可以
     * @param orderNo
     * @param storeCode
     * @param skuItemInfos
     */
    public OrderFulfillAggregate(String orderNo,String storeCode,List<SkuItemInfo> skuItemInfos){
        //初始化校验 这里省略
        this.fulfillSkuItems = Lists.newArrayList();
        skuItemInfos.forEach(skuItemInfo -> {
            fulfillSkuItems.add(new FulfillSkuItem(skuItemInfo));
        });
        this.orderNo = orderNo;
        this.storeCode = storeCode;
        this.splitOrders = Maps.newHashMap();
        this.fulfillWarehouses = Lists.newArrayList();
        this.skuMappingWarehouseMap = Maps.newHashMap();
        this.storeMappingWarehouseMap = Maps.newHashMap();
    }

    public void initBaseInfo(List<WarehouseInfo> warehouseInfos, Map<String,String> skuMappingWarehouseMap,
                     Map<String,String> storeMappingWarehouseMap){
        //check
        this.skuMappingWarehouseMap = skuMappingWarehouseMap;
        this.storeMappingWarehouseMap = storeMappingWarehouseMap;
        warehouseInfos.forEach(warehouseInfo -> {
            this.fulfillWarehouses.add(new FulfillWarehouse(warehouseInfo.getWarehouseCode(),warehouseInfo.getAreaCode(),
                    warehouseInfo.getInventoryMap()));
        });

    }

    /**
     * 业务检查
     */
    public void check(){

    }

    /**
     * 分仓
     */
    public void dispatch(){
        this.fulfillSkuItems.forEach(this::doDispatch);
    }

    private void doDispatch(FulfillSkuItem skuItem) {
        //1 店铺指定仓库发货
        String warehouseCode = storeMappingWarehouseMap.get(this.storeCode);
        if (!Objects.isNull(warehouseCode)) {
            skuItem.dispatch(warehouseCode,skuItem.getShippingAmount());
            return;
        }
        //2 sku指定了仓库发货
        warehouseCode = skuMappingWarehouseMap.get(skuItem.getSkuCode());
        if (!Objects.isNull(warehouseCode)) {
            skuItem.dispatch(warehouseCode,skuItem.getShippingAmount());
            return;
        }
        //3 地理位置就近原则+库存余量+仓库处理能力 权重计算
        this.dispatchByOptimalWarehouse(skuItem);
    }


    /**
     * 最优仓库选择
     * @param skuItem
     */
    private void dispatchByOptimalWarehouse(FulfillSkuItem skuItem){
        Map<String,Integer> dispatchMap = Maps.newHashMap();
        this.fulfillWarehouses.forEach(warehouse->{
               //dispatchMap
        });
        dispatchMap.forEach((warehouseCode,amount)->{
            skuItem.dispatch(warehouseCode,amount);
        });

    }

    /**
     * 获取父订单号
     * @return
     */
    private String makeParentOrderNo(){
        return "10"+System.currentTimeMillis();
    }

    /**
     * 根据分仓结果拆单
     */
    public void split(){
        this.fulfillSkuItems.forEach(skuItem -> {
            skuItem.getDispatchInfo().forEach((warehouseCode,skuAmount)->{
                List<OrderSplitResult> splitResults = this.splitOrders.get(warehouseCode);
                String parentOrderNo = this.makeParentOrderNo();
                if(CollectionUtils.isEmpty(splitResults)){
                    splitResults = Lists.newArrayList();
                    this.splitOrders.put(warehouseCode,splitResults);
                }else {
                    orderNo = splitResults.get(0).getParentOrderNo();
                }
                splitResults.add(new OrderSplitResult(this.orderNo,parentOrderNo,skuItem.getSkuCode(),
                        skuAmount,warehouseCode));
            });
        });
    }

}
    
 

@Getter
public class StoreInfo {

    private String storeCode;
    private String storeName;

    public void init(String storeCode,String storeName){
        Assert.isNull(storeCode,"storeCode is null!!!");
        Assert.isNull(storeName,"storeName is null!!!");
        this.storeCode = storeCode;
        this.storeName = storeName;
    }

    public StoreInfo(String storeCode){
        Assert.isNull(storeCode,"storeCode is null!!!");
        this.storeCode = storeCode;
    }

@Getter
public class OrderId {
    private String orderNo;
    private  String externalOrderNo;
    private OrderSource orderSource;

    public OrderId(String externalOrderNo,OrderSource orderSource){
        this.externalOrderNo = externalOrderNo;
        this.orderSource = orderSource;
        this.orderNo = System.currentTimeMillis()+"";
    }
    
    public OrderId(String orderNo){
        this.orderNo = orderNo;
    }
}

 public void createOrder(OrderCreateCommand command){
        OrderCreateAggregate aggregate = OrderCreateAggregate.create(command);
        orderCreateDomainService.isExist(aggregate);
        orderCreateDomainService.initBaseInfo(aggregate);
        aggregate.check();
        aggregate.priceCalculate();
        orderCreateDomainService.deductInventory(aggregate);
        orderRepository.save(aggregate);
        orderEventPublisher.publish(new OrderCreatedEvent(aggregate.getOrderId().getOrderNo()));
    }

orderCreateDomainService.initBaseInfo(aggregate);

    /**
     * 领域方法(高内聚低耦合)
     * @param aggregate
     */
    public void initBaseInfo(OrderCreateAggregate aggregate){
        this.initStoreInfo(aggregate);
        this.initSkuInfo(aggregate);
        this.initInvoiceInfo(aggregate);
        this.initShippingAddress(aggregate);
        this.initBuyer(aggregate);
    }

aggregate.priceCalculate();

/**
* sku金额拆分计算(领域行为)
*/
    public void  priceCalculate(){
        //优惠金额，运费 等附加费用 根据 sku下单金额权重比例进行金额拆分
        this.skuItems = Lists.newArrayList();
        this.skuInfos.forEach(skuInfo -> {
            //拆组合商品 计算子sku需要均摊的金额，附加费用
            Map<FeeType,Long> feeAmountInfos = Maps.newHashMap();
            //feeAmountInfos.put(FeeType.TRAN_FEE,)
            //feeAmountInfos.put(FeeType.DISCOUNT_FEE,)
            OrderSkuItem skuItem = new OrderSkuItem(skuInfo.getSkuInfo().getSkuId(),skuInfo.getSkuInfo().getSkuCode(),
                    skuInfo.getSkuBuyAmount(),skuInfo.getSkuPayPrice(),feeAmountInfos);
            this.skuItems.add(skuItem);
        });
    }

 orderCreateDomainService.deductInventory(aggregate);
 /**
     * 扣减库存 (领域方法)
     * 多领域协作
     * @param aggregate
     */
    public void deductInventory(OrderCreateAggregate aggregate){
        DeductInventoryRequest request = DeductInventoryRequest.builder()
                .build();
        DeductInventoryResponse response = inventoryGateway.deduct(request);
        aggregate.deductInventory(response.getInventoryInfos());
    }

    //订单分仓拆单后 发布领域事件
     OrderFulfillAggregate aggregate = orderFulfillRepository.ofByOrderNo(orderNo);
     orderFulfillDomainService.initBaseInfo(aggregate);
     aggregate.check();
     aggregate.dispatch();
     aggregate.split();
     orderFulfillRepository.save(aggregate);
     orderEventPublisher.publish(new OrderFulfillEvent(orderNo));

    //监听领域事件
    @EventListener(value = OrderFulfillEvent.class)
    @Async
    public void onApplicationEvent(OrderFulfillEvent event) {
        log.info("OrderFulfilledEvent :orderNo=[{}]",event.getOrderNo());
        try {
            orderAppService.fulfillOrder(event.getOrderNo());
        }catch (Exception ex){
            log.error(ex.getMessage(),ex);
        }
    }

    /**
     * 推WMS履约(可做业务补偿)
     * 业务逻辑比较薄，可以直接绕过领域层逻辑直接操作南向网关
     * @param orderNo
     */
    public void fulfillOrder(String orderNo){
        List<FulfillOrderInfo> list = orderFulfillRepository.queryFulfillOrderInfos(orderNo);
        list.forEach(order->{
            OrderFulfillRequest request = OrderFulfillRequest.builder()
                    .warehouseCode(order.getWarehouseCode())
                    .omsOrderNo(order.getOmsOrderNo())
                    .build();
            OrderFulfillResponse response =  orderFulfillGateway.fulfill(request);
            if(response.isFulfill()){
                orderFulfillRepository.updateOrderFulfill(order.getOmsOrderNo());
            }
        });
    }