using Admin.NET.Core.Service;
using Admin.NET.Application.Entity;
using Microsoft.AspNetCore.Http;
using System.Data;
using System.Web;
using System.Text;
using static SKIT.FlurlHttpClient.Wechat.Api.Models.ChannelsECLeagueHeadSupplierOrderGetResponse.Types.CommssionOrder.Types;
using System.Linq.Expressions;
using Furion.LinqBuilder;
using System.Linq;
using AngleSharp.Dom;
namespace Admin.NET.Application;
/// <summary>
/// 波次单分配服务
/// </summary>
[ApiDescriptionSettings(ApplicationConst.WmsTaskGroupName, Order = 100)]
public class WmsSortDispenseService : IDynamicApiController, ITransient
{
    /// <summary>
    /// 是否正在执行分配方法
    /// </summary>
    private static bool isRuning_Fun_Dispense = false;
    private static SemaphoreSlim semaphoreSlim = new SemaphoreSlim(1, 1);

    private readonly SqlSugarRepository<WmsContainerSort> _wmsContainerSortRep;
    private readonly SqlSugarRepository<v_wms_stock_quan> _v_wms_stock_quanRep;
    private readonly SqlSugarRepository<v_wms_stock_quan_for_use> _v_wms_stock_quan_for_useRep;

    private readonly SqlSugarRepository<WmsOrderSortDetails> _wmsOrderSortDetailsRep;
    //private readonly SqlSugarRepository<WmsStockQuanLock> _wmsStockQuanLockRep;
    private readonly SqlSugarRepository<WmsOrderSort> _wmsOrderSortRep;
    private readonly SqlSugarRepository<WmsOrderMovementDetails> _wmsOrderMovementDetailsRep;
    private readonly SqlSugarRepository<WmsOrderMovement> _wmsOrderMovementRep;
    private readonly SqlSugarRepository<WmsTask> _wmsTaskRep;
    private readonly SqlSugarRepository<WmsRecordPredetermineDispense> _wmsRecordPredetermineDispenseRep;
    private readonly SqlSugarRepository<V_WmsOrderMovementDetails> _v_wmsOrderMovementDetailsRep;


    public WmsSortDispenseService(
        SqlSugarRepository<V_WmsOrderMovementDetails> v_wmsOrderMovementDetailsRep,
        SqlSugarRepository<WmsContainerSort> wmsContainerSortRep,
        SqlSugarRepository<v_wms_stock_quan> v_wms_stock_quanRep,
        SqlSugarRepository<v_wms_stock_quan_for_use> v_wms_stock_quan_for_useRep,
    //SqlSugarRepository<WmsStockQuanLock> wmsStockQuanLockRep,
    SqlSugarRepository<WmsOrderSortDetails> wmsOrderSortDetailsRep,
        SqlSugarRepository<WmsOrderSort> wmsOrderSortRep,
        SqlSugarRepository<WmsOrderMovementDetails> wmsOrderMovementDetailsRep,
        SqlSugarRepository<WmsOrderMovement> wmsOrderMovementRep,
            SqlSugarRepository<WmsTask> wmsTaskRep,
        SqlSugarRepository<WmsRecordPredetermineDispense> wmsRecordPredetermineDispenseRep)
    {
        _v_wmsOrderMovementDetailsRep = v_wmsOrderMovementDetailsRep;
        _wmsContainerSortRep = wmsContainerSortRep;
        _v_wms_stock_quanRep = v_wms_stock_quanRep;
        _v_wms_stock_quan_for_useRep = v_wms_stock_quan_for_useRep;
        //_wmsStockQuanLockRep = wmsStockQuanLockRep;
        _wmsOrderSortDetailsRep = wmsOrderSortDetailsRep;
        _wmsOrderSortRep = wmsOrderSortRep;
        _wmsOrderMovementDetailsRep = wmsOrderMovementDetailsRep;
        _wmsOrderMovementRep = wmsOrderMovementRep;
        _wmsTaskRep = wmsTaskRep;
        _wmsRecordPredetermineDispenseRep = wmsRecordPredetermineDispenseRep;
    }



    /// <summary>
    /// 波次分配
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    [HttpPost]
    [ApiDescriptionSettings(Name = "SortDispense")]
    [Description("WmsSortDispense/SortDispense")]
    public async Task<int> SortDispense(List<DispenseInput> input)
    {
        try
        {
            if (isRuning_Fun_Dispense)
            {
                throw Oops.Oh("程序正忙，请稍后再试");
            }
            await semaphoreSlim.WaitAsync();

            isRuning_Fun_Dispense = true;

            return await SortDispenseFaction(input);

        }
        catch (Exception ex)
        {
            throw Oops.Oh(ex.Message);
        }
        finally
        {
            semaphoreSlim.Release();
            isRuning_Fun_Dispense = false;
        }
    }



    #region 私有方法


    /// <summary>
    /// 分配
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    private async Task<int> SortDispenseFaction(List<DispenseInput> input)
    {

        /**
         * 获取分配物料库存信息
         * 获取当前分配锁定库存信息
         * 校验可用库存-历史分配锁定库存 是否满足分配
         * 新增分配锁定库存
         * 修改下架单明细分配数
         * 新增事务
         * 新增操作日期
         */



        var updateWmsOrderMoveDetailsList = new List<WmsOrderMovementDetails>();//修改的移动单明细
        var addWmsRecordPredetermineDispenseList = new List<WmsRecordPredetermineDispense>();
        List<string> sortNoList = input.Select(x => x.SortNo).ToList();
        //获取波次单所有明细
        var allOrderSortDetails = await _wmsOrderSortDetailsRep.GetListAsync(u => sortNoList.Contains(u.SortNo));
        if (allOrderSortDetails?.Count <= 0)
        {
            throw Oops.Oh("波次单明细不存在");
        }

        //本次下发波次单明细
        var currentOrderSortDetails = allOrderSortDetails.Where(u => input.Select(x => x.SortDetailsId).Contains(u.Id)).ToList();
        if (currentOrderSortDetails?.Count <= 0)
        {
            throw Oops.Oh("本次下发的波次单明细不存在");
        }


        List<string> moveNoList = input.Select(s => s.MovementNo).ToList();
        var allWmsOrderSortList = await _wmsOrderMovementRep.GetListAsync(u => moveNoList.Contains(u.OrderNo));
        if (allWmsOrderSortList?.Count <= 0)
        {
            throw Oops.Oh("下架单不存在");
        }

        //获取下架单所有明细
        var allOrderrMovementDetails = await _wmsOrderMovementDetailsRep.GetListAsync(u => moveNoList.Contains(u.MovementNo));
        if (allOrderrMovementDetails?.Count <= 0)
        {
            throw Oops.Oh("下架单明细不存在");
        }

        // 查找物料库存
        List<string> materialCodeList = input.Select(x => x.MaterialCode).Distinct().ToList();

        //根据物料编码获取物料跟踪码的可用库存信息）
        var allStockQuanUseList = await _v_wms_stock_quan_for_useRep.GetListAsync(x => materialCodeList.Contains(x.MaterialCode));
        if (allStockQuanUseList?.Count <= 0)
        {
            throw Oops.Oh("所有物料都没有库存");
        }


        //TODO 分配分配锁定库存

        //获取本次操作的下架单和下架单明细

        var currentMovementDetailsKeyList = input.Select(x => x.MovementNo + x.LineNumber).ToList();
        var currentMovementDetailsList = await _wmsOrderMovementDetailsRep.GetListAsync(x => currentMovementDetailsKeyList.Contains(x.MovementNo + x.LineNumber));
        var v_currentMovementDetailsList = await _v_wmsOrderMovementDetailsRep.GetListAsync(x => currentMovementDetailsKeyList.Contains(x.MovementNo + x.LineNumber));
        var queryOrderIds = currentMovementDetailsList.Select(x => x.MovementId).Distinct().ToList();
        var currentOrderMovementList = await _wmsOrderMovementRep.GetListAsync(x => queryOrderIds.Contains(x.Id));

        foreach (var inputItem in input)
        {


            WmsOrderMovement movementOrder = currentOrderMovementList.FirstOrDefault(p => p.OrderNo == inputItem.MovementNo);
            if (movementOrder == null)
            {
                throw Oops.Oh("本次分配的下架单不存在");
            }
            //TODO 校验下架单状态
            var movementDetails = currentMovementDetailsList.FirstOrDefault(x => x.MovementNo == inputItem.MovementNo && x.LineNumber == inputItem.LineNumber);
            if (movementDetails == null)
            {
                throw Oops.Oh("本次分配的下架单明细不存在");
            }
            var v_movementDetails = v_currentMovementDetailsList.FirstOrDefault(x => x.MovementNo == inputItem.MovementNo && x.LineNumber == inputItem.LineNumber);
            if (v_movementDetails == null)
            {
                throw Oops.Oh("本次分配的下架单明细不存在");
            }
            #region 处理分配
            decimal historyDispenseQuantity = v_movementDetails.DispenseQuantity;//下架单的历史分配数量

            decimal allQuantity = movementDetails.Quantity - historyDispenseQuantity;//下架单明细剩余可分配数量
            decimal occQuantity = inputItem.SendQuantity;//当前实际分配数量
            if (allQuantity <= 0)
            {
                throw Oops.Oh("下架单" + movementDetails.MovementNo + "行号" + movementDetails.LineNumber + "物料编号" + movementDetails.MaterialCode + $"已全部分配");
            }
            if (occQuantity > allQuantity)
            {
                throw Oops.Oh("下架单" + movementDetails.MovementNo + "行号" + movementDetails.LineNumber + "物料编号" + movementDetails.MaterialCode + $"本次分配数量{occQuantity}大于剩余可分配数{allQuantity}");
            }

            // 根据物料找出库存列表中数量大于0的库存
            var findStockQuanList = allStockQuanUseList.Where(x => x.AvailableQty > 0 && x.MaterialCode == movementDetails.MaterialCode)
           .OrderBy(x => x.ContainerCode).ThenBy(x => x.PlaceCode).ThenBy(x => x.RecordInsertTime).ToList();
            //寻找库存原则：按照先入先出原则 RecordInsertTime 排升序
            //同一个物料尽量从同一个库位取 
            if (findStockQuanList.Count() <= 0)
            {
                //缺料
                throw Oops.Oh("物料编号" + movementDetails.MaterialCode + $"库存数量不足,分配数量:{occQuantity},库存可用数量:0");
            }
            var sumQty = findStockQuanList.Sum(x => x.AvailableQty);

            if (sumQty < occQuantity)
            {
                throw Oops.Oh("物料编号" + movementDetails.MaterialCode + $"库存数量不足,分配数量:{occQuantity},库存可用数量:{sumQty}");
            }

            //处理后未分配的数量，多个同一个物料多个库存数据的情况，循环处理下发
            decimal currentIssueQuantity = occQuantity;

            List<string> snCodeList = new List<string>();//下发的库存SNCode，存在使用多个情况
            foreach (var stockQuanItem in findStockQuanList)
            {
                if (currentIssueQuantity > 0)
                {
                    //当前物料波次锁定库存
                    var currentStockQuanLockQty = findStockQuanList.Where(x => x.SNCode == stockQuanItem.SNCode).Sum(x => x.Quantity);
                    //当前物料可用库存
                    var currentUsedQuantity = stockQuanItem.AvailableQty;

                    //循环库存信息 处理下发数
                    if (currentUsedQuantity >= currentIssueQuantity)//分配数量小于等于库存
                    {
                        currentIssueQuantity = 0;//全部分配，不在处理
                    }
                    else
                    {
                        //当前分配数未能完全分配，累计分配数
                        currentIssueQuantity = currentIssueQuantity - currentUsedQuantity;

                    }
                    //累计使用的库存跟踪码
                    snCodeList.Add(stockQuanItem.SNCode);


                    //创建分配记录

                    //TODO 之前单据明细已经预配，如何处理？？？？
                    var addWmsRecordPredetermineDispense = CommonCreateWmsRecordPredetermineDispense(movementDetails, occQuantity, stockQuanItem);


                    addWmsRecordPredetermineDispenseList.Add(addWmsRecordPredetermineDispense);


                    if (currentIssueQuantity == 0)
                    {
                        break;
                    }


                }
                else
                {
                    break;
                }

            }

            //movementDetails.DispenseQuantity += occQuantity;//累计分配数
            //预配数等于分配数
            movementDetails.PredetermineQuantity += occQuantity;
            updateWmsOrderMoveDetailsList.Add(movementDetails);//更新下架单明细
            #endregion
        }





        var _tenant = _wmsOrderMovementDetailsRep.AsTenant();

        try
        {
            #region 事务内执行操作

            await _wmsOrderMovementDetailsRep.UpdateRangeAsync(updateWmsOrderMoveDetailsList);
            await _wmsRecordPredetermineDispenseRep.InsertRangeAsync(addWmsRecordPredetermineDispenseList);
            #endregion

            await _tenant.CommitTranAsync();
        }
        catch (Exception ex)
        {

            await _tenant.RollbackTranAsync();
            throw;
        }








        return 1;
    }





    ///// <summary>
    ///// 移动单分配
    ///// </summary>
    ///// <param name="input"></param>
    ///// <returns></returns>
    //private async Task<int> LockMovePredetermine(List<WmsOrderMovePredetermineInput> input)
    //{



    //    var addWmsStockQuanLockList = new List<WmsStockQuanLock>();//新增的锁定库存信息
    //    var updateWmsOrderMoveDetailsList = new List<WmsOrderMovementDetails>();//修改的移动单明细
    //    var updateWmsOrderMoveList = new List<WmsOrderMovement>();//修改的移动单
    //    //TODO 添加事务记录

    //    List<string> sortNoList = input.Select(x => x.movementNo).ToList();
    //    // 获取所有波次单

    //    //Expression<Func<WmsOrderSort, bool>> predicate = u => sortNoList.Contains(u.SortNo);
    //    var allWmsOrderSortList = await _wmsOrderMovementRep.GetListAsync(u => sortNoList.Contains(u.OrderNo));
    //    if (allWmsOrderSortList?.Count <= 0)
    //    {
    //        throw Oops.Oh("下架单不存在");
    //    }

    //    //获取波次单所有明细
    //    var allOrderSortDetails = await _wmsOrderMovementDetailsRep.GetListAsync(u => sortNoList.Contains(u.MovementNo));
    //    if (allOrderSortDetails?.Count <= 0)
    //    {
    //        throw Oops.Oh("下架单明细不存在");
    //    }

    //    //本次下发波次单明细
    //    var currentOrderSortDetails = allOrderSortDetails.Where(u => input.Select(x => x.Id).Contains(u.Id)).ToList();
    //    if (currentOrderSortDetails?.Count <= 0)
    //    {
    //        throw Oops.Oh("本次操作的下架单明细不存在");
    //    }


    //    // 查找物料库存
    //    List<string> materialCodeList = currentOrderSortDetails.Select(x => x.MaterialCode).Distinct().ToList();

    //    //获取可操作下发的库存信息-（未排除锁定库存）库存状态已上架、质检状态合格、非虚拟库位
    //    var queryParam = ExpressionHelper.GetStockQuanForIssueOutTask();
    //    queryParam.And(x => materialCodeList.Contains(x.MaterialCode));
    //    var allStockQuanList = await _v_wms_stock_quanRep.GetListAsync(queryParam);
    //    if (allStockQuanList?.Count <= 0)
    //    {
    //        throw Oops.Oh("所有物料都没有库存");
    //    }

    //    //获取所有物料锁定库存
    //    var allStockQuanLockList = await _wmsStockQuanLockRep.GetListAsync(x => materialCodeList.Contains(x.MaterialCode));
    //    //波次下发物料锁定库存
    //    var allStockQuanLockForSortList = allStockQuanLockList.Where(x => x.LockType == LockTypeEnum.分配 && x.IsDelete == false).ToList();
    //    //TODO 分配分配锁定库存

    //    var movementDetailsKeyList = currentOrderSortDetails.Select(x => x.RelationNo + x.RelationNoLineNumber).ToList();
    //    var movementDetailsList = await _wmsOrderMovementDetailsRep.GetListAsync(x => movementDetailsKeyList.Contains(x.MovementNo + x.LineNumber));
    //    var queryOrderIds = movementDetailsList.Select(x => x.MovementId).Distinct().ToList();
    //    var orderMovementList = await _wmsOrderMovementRep.GetListAsync(x => queryOrderIds.Contains(x.Id));

    //    foreach (var inputItem in input)
    //    {
    //        var item = currentOrderSortDetails.FirstOrDefault(x => x.Id == inputItem.Id);

    //        WmsOrderMovement movementOrder = orderMovementList.FirstOrDefault(p => p.OrderNo == item.MovementNo);
    //        if (movementOrder == null)
    //        {
    //            throw Oops.Oh("本次分配的下架单不存在");
    //        }
    //        //TODO 校验下架单状态
    //        var sortMovementDetails = movementDetailsList.FirstOrDefault(f => f.MovementNo == item.RelationNo && f.LineNumber == item.RelationNoLineNumber);
    //        if (sortMovementDetails == null)
    //        {
    //            throw Oops.Oh("本次分配的下架单明细不存在");
    //        }
    //        #region 处理下发
    //        decimal issueQuantity = item.PredetermineQuantity ;//下架单的历史分配数量

    //        decimal allQuantity = item.Quantity - issueQuantity;//当前未下发数量
    //        decimal occQuantity = inputItem.SendQuantity;//当前实际下发数量
    //        if (allQuantity <= 0)
    //        {
    //            throw Oops.Oh("下架单" + item.MovementNo + "行号" + item.LineNumber + "物料编号" + item.MaterialCode + $"已全部分配");
    //        }
    //        if (occQuantity > allQuantity)
    //        {
    //            throw Oops.Oh("下架单" + item.MovementNo + "行号" + item.LineNumber + "物料编号" + item.MaterialCode + $"本次分配需求数量{occQuantity}大于未分配数{allQuantity}");
    //        }

    //        // 根据物料找出库存列表中数量大于0的库存
    //        var findStockQuanList = allStockQuanList.Where(x => (x.Quantity) > 0 && x.MaterialCode == item.MaterialCode)
    //       .OrderBy(x => x.ContainerCode).ThenBy(x => x.PlaceCode).ThenBy(x => x.RecordInsertTime).ToList();
    //        //寻找库存原则：按照先入先出原则 RecordInsertTime 排升序
    //        //同一个物料尽量从同一个库位取 
    //        if (findStockQuanList.Count() <= 0)
    //        {
    //            //缺料
    //            throw Oops.Oh("物料编号" + item.MaterialCode + $"库存数量不足,分配需求数量:{occQuantity},库存可用数量:0");
    //        }

    //        var sumQty = findStockQuanList.Where(o => o.MaterialCode == item.MaterialCode).Sum(x => x.Quantity);
    //        //波次下发 实际锁定库存
    //        var lockQtyForSort = allStockQuanLockForSortList.Where(o => o.MaterialCode == item.MaterialCode).Sum(x => x.Quantity);
    //        //TODO 去掉分配分配锁定库存
    //        var usedQty = (sumQty - lockQtyForSort) <= 0 ? 0 : (sumQty - lockQtyForSort);
    //        if (usedQty < occQuantity)
    //        {
    //            throw Oops.Oh("物料编号" + item.MaterialCode + $"库存数量不足,分配需求数量:{occQuantity},库存可用数量:{usedQty}");
    //        }

    //        //处理后未下发的数量，多个同一个物料多个库存数据的情况，循环处理下发
    //        decimal currentIssueQuantity = occQuantity;

    //        List<string> snCodeList = new List<string>();//下发的库存SNCode，存在使用多个情况
    //        foreach (var stockQuanItem in findStockQuanList)
    //        {
    //            //库位属性是 封存和禁出的，不能操作下架
    //            if (stockQuanItem.PlaceStatus == PlaceStatusEnum.封存)
    //            {
    //                throw Oops.Oh($"库位编号{stockQuanItem.PlaceCode}库位属性是{PlaceStatusEnum.封存.GetDescription()}");
    //            }
    //            if (stockQuanItem.PlaceStatus == PlaceStatusEnum.禁出)
    //            {
    //                throw Oops.Oh($"库位编号{stockQuanItem.PlaceCode}库位属性是{PlaceStatusEnum.禁出.GetDescription()}");
    //            }

    //            if (currentIssueQuantity > 0)
    //            {
    //                //当前物料波次锁定库存
    //                var currentStockQuanLockQty = allStockQuanLockForSortList.Where(x => x.SNCode == stockQuanItem.SNCode).Sum(x => x.Quantity);
    //                //当前物料可用库存
    //                var currentUsedQuantity = (stockQuanItem.Quantity - currentStockQuanLockQty);
    //                currentUsedQuantity = currentUsedQuantity <= 0 ? 0 : currentUsedQuantity;

    //                //循环库存信息 处理下发数
    //                if (currentUsedQuantity >= currentIssueQuantity)//下发数量小于等于库存
    //                {

    //                    currentIssueQuantity = 0;//全部下发，不在处理

    //                }
    //                else
    //                {
    //                    //当前下发数未能完全下发，累计下发数
    //                    currentIssueQuantity = currentIssueQuantity - currentUsedQuantity;

    //                }
    //                //累计使用的库存跟踪码
    //                snCodeList.Add(stockQuanItem.SNCode);



    //                //创建锁定库存
    //                var addWmsStockQuanLock = CommonCreateWmsStockQuanLock(item, occQuantity, stockQuanItem);

    //                //创建分拣信息
    //                var addWmsContainerSort = CommonCreateWmsContainerSort(item, movementOrder, sortMovementDetails, occQuantity, addWmsStockQuanLock);





    //                addWmsStockQuanLockList.Add(addWmsStockQuanLock);

    //                if (currentIssueQuantity == 0)
    //                {
    //                    break;
    //                }


    //            }
    //            else
    //            {
    //                break;
    //            }
    //        }

    //        if (currentIssueQuantity > 0)
    //        {
    //            throw Oops.Oh("物料编号" + item.MaterialCode + $"库存数量不足");

    //        }

    //        //更新波次单的已下发数量
    //        item.SNCode = string.Join(",", snCodeList.Distinct().ToList());

    //        decimal lastIssueQuantity = issueQuantity + occQuantity;//下架单单的历史分配数
    //        item.PredetermineQuantity = lastIssueQuantity;//累计分配数

    //        //更新波次单明细的状态
    //        OrderHelper.UpdateOrderMovementDetailsStatus(item);
    //        updateWmsOrderSortDetailsList.Add(item);

    //        #endregion
    //    }

    //    foreach (var item in allWmsOrderSortList)
    //    {
    //        var updateOrderSortDetails = allOrderSortDetails.Where(w => w.MovementId == item.Id).ToList();
    //        ////计算 波次单单的状态 
    //        OrderHelper.UpdatOrderSortStatus(updateOrderSortDetails, item);
    //        updateWmsOrderSortList.Add(item);
    //    }



    //    if (addWmsContainerSortList?.Count <= 0)
    //    {


    //        throw Oops.Oh("没有可下发的物料，库存全部不足");

    //    }



    //    var _tenant = _wmsContainerSortRep.AsTenant();

    //    try
    //    {
    //        #region 事务内执行操作
    //        await _wmsStockQuanLockRep.InsertRangeAsync(addWmsStockQuanLockList);
    //        await _wmsOrderSortRep.UpdateRangeAsync(updateWmsOrderSortList);
    //        await _wmsOrderSortDetailsRep.UpdateRangeAsync(updateWmsOrderSortDetailsList);
    //        #endregion

    //        await _tenant.CommitTranAsync();
    //    }
    //    catch (Exception ex)
    //    {

    //        await _tenant.RollbackTranAsync();
    //        throw;
    //    }








    //    return 1;
    //}



    /// <summary>
    /// 创建记录分配信息公共方法
    /// </summary>
    /// <param name="item"></param>
    /// <param name="occQuantity"></param>
    /// <param name="stockQuanItem"></param>
    /// <returns></returns>

    private static WmsRecordPredetermineDispense CommonCreateWmsRecordPredetermineDispense(WmsOrderMovementDetails item, decimal occQuantity, v_wms_stock_quan_for_use stockQuanItem)
    {

        return new WmsRecordPredetermineDispense()
        {
            Id = Yitter.IdGenerator.YitIdHelper.NextId(),
            PDRecordType = PDRecordTypeEnum.分配,
            PDRecordTypeName = PDRecordTypeEnum.分配.GetDescription(),
            PDRecordStatus = PDRecordStatusEnum.已分配,
            PDRecordStatusName = PDRecordStatusEnum.已分配.GetDescription(),
            MaterialCode = item.MaterialCode,
            MaterialName = item.MaterialName,
            Quantity = occQuantity,
            MovementLineNumber = item.LineNumber,//下架单行号
            MovementNo = item.MovementNo,//下架单号
            SNCode = item.SNCode,//用于分配的库存跟踪码
            Batch = stockQuanItem.Batch,//批次号
            AreaCode = stockQuanItem.AreaCode,//库区编码
            AreaName = stockQuanItem.AreaName,//库区名称
            PlaceCode = stockQuanItem.PlaceCode,
            PlaceName = stockQuanItem.PlaceName,
            ContainerCode = stockQuanItem.ContainerCode,
            ContainerName = stockQuanItem.ContainerName,
            Remarks = "",

        };
    }

    #endregion




}