using Admin.NET.Core.Service;
using Admin.NET.Application.Entity;
using Microsoft.AspNetCore.Http;
using System.Data;
using System.Web;
using System.Text;
using Furion.DatabaseAccessor;
using MathNet.Numerics;
using DocumentFormat.OpenXml.VariantTypes;

namespace Admin.NET.Application;
/// <summary>
/// 波次单明细服务
/// </summary>
[ApiDescriptionSettings(ApplicationConst.WmsOrderGroupName, Order = 100)]
public class WmsOrderSortDetailsService : IDynamicApiController, ITransient
{
    private readonly SqlSugarRepository<WmsOrderSortDetails> _rep;
    private readonly SqlSugarRepository<WmsOrderSort> _WmsOrderSortRep;
    private readonly SqlSugarRepository<WmsOrderMovementDetails> _WmsOrderMovementDetailsRep;
    private readonly SqlSugarRepository<WmsOrderMovement> _WmsOrderMovementRep;
    private readonly SqlSugarRepository<WmsConfigNoRule> _WmsNoCreateRuleRep;
    private readonly SqlSugarRepository<WmsConfigSerialSN> _repSNRep;
    private readonly SqlSugarRepository<WmsBaseBusinessType> _WmsBaseBusinessTypeRep;
    private readonly SqlSugarRepository<WmsOrderDeliverDetails> _WmsOrderDeliverDetailsRep;
    private readonly SqlSugarRepository<WmsOrderDeliver> _WmsOrderDeliverRep;
    private readonly WmsIssueService _wmsIssueService;

    public WmsOrderSortDetailsService(SqlSugarRepository<WmsOrderSortDetails> rep, SqlSugarRepository<WmsOrderSort> wmsOrderSortRep, 
        SqlSugarRepository<WmsOrderMovementDetails> WmsOrderMovementDetailsRep,
        SqlSugarRepository<WmsOrderMovement> wmsOrderMovementRep, 
        SqlSugarRepository<WmsConfigNoRule> wmsNoCreateRuleRep, 
        SqlSugarRepository<WmsConfigSerialSN> repSNRep,
        SqlSugarRepository<WmsBaseBusinessType> WmsBaseBusinessTypeRep,
        SqlSugarRepository<WmsOrderDeliverDetails> WmsOrderDeliverDetailsRep,
        SqlSugarRepository<WmsOrderDeliver> WmsOrderDeliverRep,
        WmsIssueService wmsIssueService
        )
    {
        _rep = rep;
        _WmsOrderSortRep = wmsOrderSortRep;
        _WmsOrderMovementDetailsRep = WmsOrderMovementDetailsRep;
        _WmsOrderMovementRep = wmsOrderMovementRep;
        _WmsNoCreateRuleRep = wmsNoCreateRuleRep;
        _repSNRep = repSNRep;
        _WmsBaseBusinessTypeRep = WmsBaseBusinessTypeRep;
        _WmsOrderDeliverDetailsRep = WmsOrderDeliverDetailsRep;
        _WmsOrderDeliverRep = WmsOrderDeliverRep;
        _wmsIssueService = wmsIssueService;
    }

    /// <summary>
    /// 分页查询波次单明细
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    [HttpPost]
    [ApiDescriptionSettings(Name = "Page")]
    [Description("WmsOrderSortDetails/Page")]
    public async Task<SqlSugarPagedList<WmsOrderSortDetailsOutput>> Page(WmsOrderSortDetailsInput input)
    {
        var query = CommonPageFilter(input);
        return await query
             .OrderBy(x => x.LineNumber)
            //.OrderBuilder(input, "", "Id")
            .ToPagedListAsync(input.Page, input.PageSize);
    }

    /// <summary>
    /// 不分页查询波次单明细
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    [HttpGet]
    [ApiDescriptionSettings(Name = "List")]
    [Description("WmsOrderSortDetails/List")]
    public async Task<List<WmsOrderSortDetailsOutput>> List([FromQuery] WmsOrderSortDetailsInput input)
    {
        var query = CommonPageFilter(input);
        return await query.OrderBuilder(input, "", "Id").Select<WmsOrderSortDetailsOutput>().ToListAsync();
    }

    /// <summary>
    /// 创建波次-确认
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    [HttpPost]
    [ApiDescriptionSettings(Name = "Add")]
    [Description("WmsOrderSortDetails/Add")]
    [UnitOfWork]
    public async Task<long> Add(List<DiyAddWmsOrderSortDetailsInput> input)
    {
        /*
         1 插入波次主表1条
         2 插入波次明细表n条
         3 更新下架单明细表的物料 - 状态 波次数
         4 更新下架单主表 - 状态 
         5 如果存在DO单的物料  更新状态 波次数  --ly
         * **/

        if (input is null || input.Count == 0)
        {
            throw Oops.Oh("明细不能为空");
        }
        var hearId = await AddOrderEFsql(input);
        return 200;
        //var entity = input.Adapt<WmsOrderSortDetails>();
        ////重复性验证
        //await CheckExist(entity);
        //await _rep.InsertAsync(entity);
        //return entity.Id;
    }

    /// <summary>
    /// 创建波次单并且下发
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    [HttpPost]
    [ApiDescriptionSettings(Name = "CreateOrderAndIssue")]
    [Description("WmsOrderSortDetails/CreateOrderAndIssue")]
    [UnitOfWork]
    public async Task<long> CreateOrderAndIssue(List<DiyAddWmsOrderSortDetailsInput> input) 
    {
        if (input is null || input.Count == 0)
        {
            throw Oops.Oh("明细不能为空");
        }
        var wmsOrderSortDetails = await AddOrderEFsql(input);

        var issueList = wmsOrderSortDetails.Select(n => new IssueInput 
        {
            SendQuantity = n.Quantity,
            Batch = n.Batch,
            SortNo = n.SortNo,
            SortDetailsId = n.Id,
        }).ToList();

        await _wmsIssueService.Issue(issueList);
        return 200;
    }

    private async Task<List<WmsOrderSortDetails>> AddOrderEFsql(List<DiyAddWmsOrderSortDetailsInput> input)
    {
        //-----------新增表头
        var warehousOrder = new WmsOrderSort();
        var hearId = Yitter.IdGenerator.YitIdHelper.NextId();
        warehousOrder.Id = hearId;

        warehousOrder.BusinessType = BusinessTypeEnum.波次下发;
        warehousOrder.BusinessTypeName = GetEnumDescriptionUtil.GetEnumDescription(BusinessTypeEnum.波次下发);

        var entity = await _WmsBaseBusinessTypeRep.GetFirstAsync(u => u.BusinessTypeValue == (int)warehousOrder.BusinessType);
        if (entity == null)
        {
            throw Oops.Oh("业务类型名称获取失败");
        }

        // 获取当前时间
        DateTime currentTime = DateTime.Now;

        // 格式化为年月日字符串
        string formattedDate = currentTime.ToString("yyyyMMdd");

        //按照单号规则生成单号 - 查找最新的创建的一条单据记录
        var newestOrder = await _WmsOrderSortRep.AsQueryable().Where(p => p.OrderType == OrderTypeEnum.波次单).Where(p => p.SortNo.Contains(formattedDate)).OrderBy(it => it.CreateTime, OrderByType.Desc)
                             .FirstAsync();

        //ly-按照单号规则生成单号
        warehousOrder.SortNo = await SerialUtilOrder.GetSerialOrder(OrderTypeEnum.波次单, _WmsNoCreateRuleRep, _repSNRep,
            (int)warehousOrder.BusinessType, newestOrder == null ? null : newestOrder.SortNo);
        if (warehousOrder.SortNo == null || warehousOrder.SortNo == "")
        {
            warehousOrder.SortNo = Yitter.IdGenerator.YitIdHelper.NextId().ToString();
        }

        warehousOrder.OrderType = OrderTypeEnum.波次单;
        warehousOrder.OrderTypeName = OrderTypeEnum.波次单.GetDescription();
   
        warehousOrder.OrderSocure = SourceByEnum.系统;
        warehousOrder.SortStatus = OrderStatusEnum.新建;
        warehousOrder.SortStatusName = GetEnumDescriptionUtil.GetEnumDescription(OrderStatusEnum.新建);

        //-------新增明细
        var warehousOrderDetails1 = input.Adapt<List<WmsOrderSortDetails>>();
        for (int i = 0; i < warehousOrderDetails1.Count; i++)
        {
            warehousOrderDetails1[i].RelationNo = input[i].MovementNo;
        }
        //定义行号
        int lineNumber = 1;
        foreach (var w in warehousOrderDetails1)
        {
            if (w.Quantity == 0)
            {
                throw Oops.Oh("创建失败：数量需要大于0");
            }
            if (String.IsNullOrEmpty(w.LineNumber))
            {
                throw Oops.Oh("创建失败：行号不能为空");
            }
            w.RelationNoLineNumber = w.LineNumber;
            //系统自己生成行号
           // string myLineNumeber = (input.Where(x => x.SortNo == w.SortNo).Count()).ToString();
            string myLineNumeber = lineNumber.ToString();
            w.LineNumber = OrderHelper.AutoCompleEBELP(myLineNumeber,4);
            w.Id = Yitter.IdGenerator.YitIdHelper.NextId();
            w.SortNo = warehousOrder.SortNo;
            w.SortId = warehousOrder.Id;
            w.SortDetailStatus = OrderStatusEnum.新建;
            w.SortDetailStatusName = GetEnumDescriptionUtil.GetEnumDescription(OrderStatusEnum.新建);
            w.OffShelvesQuantity = 0M;
            w.PickQuantity = 0M;
            w.IssueQuantity = 0M;
            lineNumber++;
        }

        //------------更新下架单的物料-状态 波次数
        var WmsOrderMovementDetailsArr = new List<WmsOrderMovementDetails>();
        List<long> queryCodeList = input.Select(v => v.Id).Distinct().ToList();
        var handleList = await _WmsOrderMovementDetailsRep.GetListAsync(u => queryCodeList.Contains(u.Id) && u.IsDelete == false);
        foreach (var w in handleList)
        {
            //ly 数量可自定义 波次对象
            var paramWarehousOrderDetails1 = warehousOrderDetails1
                .FirstOrDefault(x =>  x.MaterialCode == w.MaterialCode && x.RelationNoLineNumber == w.LineNumber && x.RelationNo == w.MovementNo);
            if (paramWarehousOrderDetails1 == null)
            {
                throw Oops.Oh("创建失败：下架单明细中没有找到相应的物料！");
            }
            decimal usedQty = w.Quantity - w.CreateWaveQuantity;
            if (paramWarehousOrderDetails1.Quantity > usedQty)
            {
                throw Oops.Oh($"创建失败：{paramWarehousOrderDetails1.RelationNo}需求数量必须小于订单数{w.Quantity}与波次数量{w.CreateWaveQuantity}之差");
            }
            w.CreateWaveQuantity += paramWarehousOrderDetails1.Quantity;
            w.OrderStatus = OrderStatusEnum.处理中;
            w.OrderStatusName = GetEnumDescriptionUtil.GetEnumDescription(OrderStatusEnum.处理中);
            WmsOrderMovementDetailsArr.Add(w);
        }

        //------------更新主表下架单-状态
        var WmsOrderMovementArr = new List<WmsOrderMovement>();
        List<string> queryCodeListMovement = input.Select(v => v.MovementNo).Distinct().ToList();
        var handleListZ = await _WmsOrderMovementRep
            .GetListAsync(u => queryCodeListMovement.Contains(u.OrderNo) && u.IsDelete == false);
        if (handleListZ==null || handleListZ.Count<=0)
        {
            throw Oops.Oh($"创建失败：没有找到下架单");
        }

        foreach (var w in handleListZ)
        {
            w.OrderStatus = OrderStatusEnum.处理中;
            w.OrderStatusName = GetEnumDescriptionUtil.GetEnumDescription(OrderStatusEnum.处理中);
            WmsOrderMovementArr.Add(w);
        }

        //------------ly-如果存在DO单的物料  更新DO单的物料 - 更新状态 波次数 
        var WmsOrderDeliverDetailsArr = new List<WmsOrderDeliverDetails>();
        var WmsOrderDeliverArr = new List<WmsOrderDeliver>();
        List<string> queryCodeListForDo = input.Where(v => !string.IsNullOrWhiteSpace(v.RelationNo)).Select(v => v.RelationNo).Distinct().ToList();
        if (queryCodeListForDo.Count > 0)
        {

            //DO单明细
            var handleListForDo = await _WmsOrderDeliverDetailsRep.GetListAsync(u => queryCodeListForDo.Contains(u.DoNo) && u.IsDelete == false);
            foreach (var w in handleListForDo)
            {
                var item = input.FirstOrDefault(x => x.MaterialCode == w.MaterialCode && x.RelationNoLineNumber == w.DoLineNumber && x.RelationNo == w.DoNo);
                if (item != null)
                {
                    var hasUseBoQty = w.CreateMovementQuantity;
                    w.CreateMovementQuantity += item.Quantity;
                    if (w.CreateMovementQuantity > w.Quantity)
                    {
                        throw Oops.Oh($"创建失败：DO单号{w.DoNo},物料编号{w.MaterialCode},DO行号{w.DoLineNumber},订单数{w.Quantity},已创建的波次数{hasUseBoQty},无可用数量!");
                    }
                    w.DoDetailStatus = OrderStatusEnum.处理中;
                    w.DoDetailStatusName = GetEnumDescriptionUtil.GetEnumDescription(OrderStatusEnum.处理中);
                    WmsOrderDeliverDetailsArr.Add(w);
                }
                
            }
            //------------end ly更新DO单的物料 - 更新状态 波次数 

            //------------ly--更新DO主表下架单-状态
            if (queryCodeListForDo.Count > 0 && WmsOrderDeliverDetailsArr.Count > 0)
            {
                var handleListForDoMain = await _WmsOrderDeliverRep.GetListAsync(u => queryCodeListForDo.Contains(u.DeliverNo) && u.IsDelete == false);
                if (handleListForDoMain == null || handleListForDoMain.Count <= 0)
                {
                    throw Oops.Oh("创建失败：没有找到主DO订单单号");
                }

                foreach (var w in handleListForDoMain)
                {
                    if (w.DoStatus == OrderStatusEnum.处理中 || w.DoStatus == OrderStatusEnum.新建)
                    {
                        w.DoStatus = OrderStatusEnum.处理中;
                        w.DoStatusName = GetEnumDescriptionUtil.GetEnumDescription(OrderStatusEnum.处理中);
                        WmsOrderDeliverArr.Add(w);
                    }
                    else
                    {
                        throw Oops.Oh($"创建失败：DO订单{w.DeliverNo}状态{w.DoStatusName} 不可操作！");
                    }
                }
            }
            //------------ly--end更新DO主表下架单-状态
        }

        try
        {
         //   await _rep.AsTenant().BeginTranAsync();
            if (warehousOrder != null)
            {
                await _WmsOrderSortRep.InsertAsync(warehousOrder);//插入波次主表
            }

            if (warehousOrderDetails1.Count > 0)
            { 
                await _rep.InsertRangeAsync(warehousOrderDetails1);  //插入波次明细表
            }

            if (WmsOrderMovementDetailsArr.Count > 0)
            { 
                await _WmsOrderMovementDetailsRep.UpdateRangeAsync(WmsOrderMovementDetailsArr);  //更新下架单明细表
            }
            if (WmsOrderMovementArr.Count > 0)
            {
                await _WmsOrderMovementRep.UpdateRangeAsync(WmsOrderMovementArr);  //更新下架单主表
            }

            ////--ly0701 存在DO单 更新Do单波次数
            if (WmsOrderDeliverDetailsArr.Count > 0)
            {
                await _WmsOrderDeliverDetailsRep.UpdateRangeAsync(WmsOrderDeliverDetailsArr);  //更新DO单明细表
            }
            if (WmsOrderDeliverArr.Count > 0)
            {
                await _WmsOrderDeliverRep.UpdateRangeAsync(WmsOrderDeliverArr);  //更新DO单主表
            }
            //调用公共方法
            //await _WmsOrderMovementDetailsRep.UpdateRangeAsync(WmsOrderMovementDetailsArr);  //更新下架单主表
            // await _rep.AsTenant().CommitTranAsync();
        }
        catch
        {
           // await _rep.AsTenant().RollbackTranAsync();
            throw;
        }
        return warehousOrderDetails1;
    }



    /// <summary>
    /// 删除波次单明细
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    [HttpPost]
    [ApiDescriptionSettings(Name = "Delete")]
    [Description("WmsOrderSortDetails/Delete")]
    public async Task Delete(DeleteWmsOrderSortDetailsInput input)
    {
        var entity = await _rep.GetFirstAsync(u => u.Id == input.Id) ?? throw Oops.Oh(ErrorCodeEnum.D1002);
        //await _rep.FakeDeleteAsync(entity);   //假删除
        await _rep.DeleteAsync(entity);   //真删除
    }

    /// <summary>
    /// 更新波次单明细
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    [HttpPost]
    [ApiDescriptionSettings(Name = "Update")]
    [Description("WmsOrderSortDetails/Update")]
    public async Task Update(UpdateWmsOrderSortDetailsInput input)
    {
        var entity = input.Adapt<WmsOrderSortDetails>();

        //重复性验证
        await CheckExist(entity,true);

        await _rep.AsUpdateable(entity).IgnoreColumns(ignoreAllNullColumns: true).ExecuteCommandAsync();
    }

    /// <summary>
    /// 获取波次单明细
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    [HttpGet]
    [ApiDescriptionSettings(Name = "Detail")]
    [Description("WmsOrderSortDetails/Detail")]
    public async Task<WmsOrderSortDetails> Detail([FromQuery] QueryByIdWmsOrderSortDetailsInput input)
    {
        return await _rep.GetFirstAsync(u => u.Id == input.Id);
    }





    #region 导入
    
    /// <summary>
    /// Excel模板导入波次单明细功能
    /// </summary>
    /// <param name="file">Excel模板文件</param>
    /// <returns>导入的记录数</returns>
    [HttpPost]
    [ApiDescriptionSettings(Name = "ImportExcel")]
    [Description("WmsOrderSortDetails/ImportExcel")]
    public async Task<int> ImportExcelAsync(IFormFile file)
    { 
        int _HeadStartLine = 2;//第1行是说明,第2行是列名
        int _DataStartLine = 3;//第3行开始是数据
        DataTable importDataTable = ExcelUtil.ImportExcelToDataTable(file, _HeadStartLine, _DataStartLine);
        var addList =await CommonImport(importDataTable, _DataStartLine);
        await _rep.InsertRangeAsync(addList);
        return addList.Count;
    }
    
    /// <summary>
    ///  DataTable转换实体对象列表
    /// </summary>
    /// <param name="dataTable"></param>
    /// <param name="dataStartLine">模版列名开始行</param>
    /// <returns></returns>
    private async Task<List<WmsOrderSortDetails>> CommonImport(DataTable dataTable, int dataStartLine)
    {
        var details = new List<WmsOrderSortDetails>();
        int index = dataStartLine;//模版列名开始行
        foreach (System.Data.DataRow row in dataTable.Rows)
        {
            index++;
            //导入模版定制化代码（替换模版使用）
                                      
                           var addItem = new WmsOrderSortDetails();
                          #region 定义变量
                           var _SortId = "";//波次单ID
                           var _SortNo = "";//波次单号
                           var _SortDetailStatus = "";//状态
                           var _SortDetailStatusName = "";//状态名称
                           var _LineNumber = "";//行号
                           var _MaterialCode = "";//物料编号
                           var _MaterialName = "";//物料名称
                           var _RelationNo = "";//关联单号
                           var _RelationNoLineNumber = "";//关联单行号
                           var _SNCode = "";//跟踪码
                           var _Unit = "";//单位
                           var _Quantity = "";//数量
                           var _DispenseQuantity = "";//分配数
                           var _OffShelvesQuantity = "";//下架数
                           var _DeliverQuantity = "";//发货数
                           var _PickQuantity = "";//分拣数
                           var _IssueQuantity = "";//下发数
                           var _BatchRule = "";//批次规则
                           var _Batch = "";//批次
                           var _ErpOrderNo = "";//ERP单号
                           var _ErpCode = "";//ERP库存地
                          #endregion
                          
                          
                          #region 取值
                           _SortId = row["波次单ID"]?.ToString() ;
                           _SortNo = row["波次单号"]?.ToString() ;
                           _SortDetailStatus = row["状态"]?.ToString() ;
                           _SortDetailStatusName = row["状态名称"]?.ToString() ;
                           _LineNumber = row["行号"]?.ToString() ;
                           _MaterialCode = row["物料编号"]?.ToString() ;
                           _MaterialName = row["物料名称"]?.ToString() ;
                           _RelationNo = row["关联单号"]?.ToString() ;
                           _RelationNoLineNumber = row["关联单行号"]?.ToString() ;
                           _SNCode = row["跟踪码"]?.ToString() ;
                           _Unit = row["单位"]?.ToString() ;
                           _Quantity = row["数量"]?.ToString() ;
                           // _DispenseQuantity = row["分配数"]?.ToString() ;
                           //_OffShelvesQuantity = row["下架数"]?.ToString() ;
                           //_DeliverQuantity = row["发货数"]?.ToString() ;
                           // _PickQuantity = row["分拣数"]?.ToString() ;
                           _IssueQuantity = row["下发数"]?.ToString() ;
                           _BatchRule = row["批次规则"]?.ToString() ;
                           _Batch = row["批次"]?.ToString() ;
                           _ErpOrderNo = row["ERP单号"]?.ToString() ;
                           _ErpCode = row["ERP库存地"]?.ToString() ;
                          #endregion
                          
                          
                          #region 验证
                          
                          if (string.IsNullOrEmpty(_SortId))
                          {
                            throw Oops.Oh($"第{index}行[波次单ID]{_SortId}不能为空！");
                          }
                          
                          if(!string.IsNullOrEmpty(_SortId))
                          {
                              if (!long.TryParse(_SortId, out long outSortId)&&!string.IsNullOrEmpty(_SortId))
                              {
                                 throw Oops.Oh($"第{index}行[波次单ID]{_SortId}值不正确！");
                              }
                              if (outSortId <= 0&&!string.IsNullOrEmpty(_SortId))
                              {
                                 throw Oops.Oh($"第{index}行[波次单ID]{_SortId}值不能小于等于0！");
                              }
                              else
                              {
                                 addItem.SortId = outSortId;
                              }
                          
                          }
                          
                          if (string.IsNullOrEmpty(_SortNo))
                          {
                            throw Oops.Oh($"第{index}行[波次单号]{_SortNo}不能为空！");
                          }
                          
                          if(!string.IsNullOrEmpty(_SortNo))
                          {
                                addItem.SortNo = (string)(_SortNo.Trim());
                           }
                          
                          if (string.IsNullOrEmpty(_SortDetailStatus))
                          {
                            throw Oops.Oh($"第{index}行[状态]{_SortDetailStatus}不能为空！");
                          }
                          
                          if(!string.IsNullOrEmpty(_SortDetailStatus))
                          {
                          Admin.NET.Application.OrderStatusEnum  enumSortDetailStatus = default(Admin.NET.Application.OrderStatusEnum);
                          
                             if(!Enum.TryParse<Admin.NET.Application.OrderStatusEnum>(_SortDetailStatus, out enumSortDetailStatus)&&!string.IsNullOrEmpty(_SortDetailStatus))
                              {
                                throw Oops.Oh($"第{index}行[状态]{_SortDetailStatus}值不正确！");
                              }
                              else
                              {
                                 addItem.SortDetailStatus = enumSortDetailStatus;
                              }
                          
                           }
                          
                          if (string.IsNullOrEmpty(_SortDetailStatusName))
                          {
                            throw Oops.Oh($"第{index}行[状态名称]{_SortDetailStatusName}不能为空！");
                          }
                          
                          if(!string.IsNullOrEmpty(_SortDetailStatusName))
                          {
                                addItem.SortDetailStatusName = (string)(_SortDetailStatusName.Trim());
                           }
                          
                          if (string.IsNullOrEmpty(_LineNumber))
                          {
                            throw Oops.Oh($"第{index}行[行号]{_LineNumber}不能为空！");
                          }
                          
                          if(!string.IsNullOrEmpty(_LineNumber))
                          {
                                addItem.LineNumber = (string)(_LineNumber.Trim());
                           }
                          
                          if (string.IsNullOrEmpty(_MaterialCode))
                          {
                            throw Oops.Oh($"第{index}行[物料编号]{_MaterialCode}不能为空！");
                          }
                          
                          if(!string.IsNullOrEmpty(_MaterialCode))
                          {
                                addItem.MaterialCode = (string)(_MaterialCode.Trim());
                           }
                          
                          if (string.IsNullOrEmpty(_MaterialName))
                          {
                            throw Oops.Oh($"第{index}行[物料名称]{_MaterialName}不能为空！");
                          }
                          
                          if(!string.IsNullOrEmpty(_MaterialName))
                          {
                                addItem.MaterialName = (string)(_MaterialName.Trim());
                           }
                          if(!string.IsNullOrEmpty(_RelationNo))
                          {
                                addItem.RelationNo = (string)(_RelationNo.Trim());
                           }
                          if(!string.IsNullOrEmpty(_RelationNoLineNumber))
                          {
                                addItem.RelationNoLineNumber = (string)(_RelationNoLineNumber.Trim());
                           }
                          
                          if (string.IsNullOrEmpty(_SNCode))
                          {
                            throw Oops.Oh($"第{index}行[跟踪码]{_SNCode}不能为空！");
                          }
                          
                          if(!string.IsNullOrEmpty(_SNCode))
                          {
                                addItem.SNCode = (string)(_SNCode.Trim());
                           }
                          if(!string.IsNullOrEmpty(_Unit))
                          {
                                addItem.Unit = (string)(_Unit.Trim());
                           }
                          
                          if (string.IsNullOrEmpty(_Quantity))
                          {
                            throw Oops.Oh($"第{index}行[数量]{_Quantity}不能为空！");
                          }
                          
                          if(!string.IsNullOrEmpty(_Quantity))
                          {
                              if (!decimal.TryParse(_Quantity, out decimal outQuantity)&&!string.IsNullOrEmpty(_Quantity))
                              {
                                 throw Oops.Oh($"第{index}行[数量]{_Quantity}值不正确！");
                              }
                              if (outQuantity <= 0&&!string.IsNullOrEmpty(_Quantity))
                              {
                                 throw Oops.Oh($"第{index}行[数量]{_Quantity}值不能小于等于0！");
                              }
                              else
                              {
                                 addItem.Quantity = outQuantity;
                              }
                          
                          }
                       
                          if(!string.IsNullOrEmpty(_OffShelvesQuantity))
                          {
                              if (!decimal.TryParse(_OffShelvesQuantity, out decimal outOffShelvesQuantity)&&!string.IsNullOrEmpty(_OffShelvesQuantity))
                              {
                                 throw Oops.Oh($"第{index}行[下架数]{_OffShelvesQuantity}值不正确！");
                              }
                              if (outOffShelvesQuantity <= 0&&!string.IsNullOrEmpty(_OffShelvesQuantity))
                              {
                                 throw Oops.Oh($"第{index}行[下架数]{_OffShelvesQuantity}值不能小于等于0！");
                              }
                              else
                              {
                                 addItem.OffShelvesQuantity = outOffShelvesQuantity;
                              }
                          
                          }
                          if(!string.IsNullOrEmpty(_DeliverQuantity))
                          {
                              if (!decimal.TryParse(_DeliverQuantity, out decimal outDeliverQuantity)&&!string.IsNullOrEmpty(_DeliverQuantity))
                              {
                                 throw Oops.Oh($"第{index}行[发货数]{_DeliverQuantity}值不正确！");
                              }
                              if (outDeliverQuantity <= 0&&!string.IsNullOrEmpty(_DeliverQuantity))
                              {
                                 throw Oops.Oh($"第{index}行[发货数]{_DeliverQuantity}值不能小于等于0！");
                              }
                              else
                              {
                                 addItem.DeliverQuantity = outDeliverQuantity;
                              }
                          
                          }
                          if(!string.IsNullOrEmpty(_PickQuantity))
                          {
                              if (!decimal.TryParse(_PickQuantity, out decimal outPickQuantity)&&!string.IsNullOrEmpty(_PickQuantity))
                              {
                                 throw Oops.Oh($"第{index}行[分拣数]{_PickQuantity}值不正确！");
                              }
                              if (outPickQuantity <= 0&&!string.IsNullOrEmpty(_PickQuantity))
                              {
                                 throw Oops.Oh($"第{index}行[分拣数]{_PickQuantity}值不能小于等于0！");
                              }
                              else
                              {
                                 addItem.PickQuantity = outPickQuantity;
                              }
                          
                          }
                          //if(!string.IsNullOrEmpty(_IssueQuantity))
                          //{
                          //      addItem.IssueQuantity = _IssueQuantity;
                          // }
                          if(!string.IsNullOrEmpty(_BatchRule))
                          {
                                addItem.BatchRule = (string)(_BatchRule.Trim());
                           }
                          if(!string.IsNullOrEmpty(_Batch))
                          {
                                addItem.Batch = (string)(_Batch.Trim());
                           }
                          if(!string.IsNullOrEmpty(_ErpOrderNo))
                          {
                                addItem.ErpOrderNo = (string)(_ErpOrderNo.Trim());
                           }
                          if(!string.IsNullOrEmpty(_ErpCode))
                          {
                                addItem.ErpCode = (string)(_ErpCode.Trim());
                           }
                          #endregion
                          

            details.Add(addItem);
        }
        //验重
        await CheckExisitForImport(details);
        return details;
    }
    
    /// <summary>
    /// 根据版本下载波次单明细的Excel导入模板
    /// </summary>
    /// <returns>下载的模板文件</returns>
    [HttpGet]
    [ApiDescriptionSettings(Name = "DownloadExcelTemplate")]
    [Description("WmsOrderSortDetails/DownloadExcelTemplate")]
    public IActionResult DownloadExcelTemplate()
    {
        string _path = TemplateConst.EXCEL_TEMPLATEFILE_导入模版路径 + $"\\波次单明细{TemplateConst.EXCEL_TEMPLATEFILE_导入模版名称后缀}.xlsx";
        var fileName = HttpUtility.UrlEncode($"导入模板(波次单明细).xlsx", Encoding.GetEncoding("UTF-8"));
        return new FileStreamResult(new FileStream(_path, FileMode.Open), "application/octet-stream") { FileDownloadName = fileName };
    }
    
    #endregion

    #region 私有方法

    /// <summary>
    /// 公共查询波次单明细条件
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    private ISugarQueryable<WmsOrderSortDetailsOutput> CommonPageFilter(WmsOrderSortDetailsInput input)
    {

        //ly-0606 波次-下发-需要传递的参数
        if (!string.IsNullOrWhiteSpace(input.OrdersId))
        {
            input.OrdersIdList = new List<long>();

            if (input.OrdersId.IndexOf(',') >= 0 || input.OrdersId.IndexOf('，') >= 0)
            {
                var list = input.OrdersId.Replace('，', ',').Split(',').ToList();
                foreach (var item in list)
                {
                    input.OrdersIdList.Add(Convert.ToInt64(item));
                }
                input.OrdersId = string.Empty;
            }
            else
            {
                input.OrdersIdList.Add(Convert.ToInt64(input.OrdersId));
            }
        }
        var query = _rep.AsQueryable()
            .WhereIF(!string.IsNullOrWhiteSpace(input.SearchKey), u =>
                u.SortNo.Contains(input.SearchKey.Trim())
                || u.SortDetailStatusName.Contains(input.SearchKey.Trim())
                || u.LineNumber.Contains(input.SearchKey.Trim())
                || u.MaterialCode.Contains(input.SearchKey.Trim())
                || u.MaterialName.Contains(input.SearchKey.Trim())
                || u.RelationNo.Contains(input.SearchKey.Trim())
                || u.RelationNoLineNumber.Contains(input.SearchKey.Trim())
                || u.SNCode.Contains(input.SearchKey.Trim())
                || u.Unit.Contains(input.SearchKey.Trim())
            //    || u.IssueQuantity.Contains(input.SearchKey.Trim())
                || u.BatchRule.Contains(input.SearchKey.Trim())
                || u.Batch.Contains(input.SearchKey.Trim())
                || u.ErpOrderNo.Contains(input.SearchKey.Trim())
                || u.ErpCode.Contains(input.SearchKey.Trim())
                || u.CreateUserName.Contains(input.SearchKey.Trim())
                || u.UpdateUserName.Contains(input.SearchKey.Trim())
            )
            .WhereIF(input.SortId>0, u => u.SortId == input.SortId)
            .WhereIF(input.OrdersIdList != null && input.OrdersIdList.Count > 0, u => input.OrdersIdList.Contains(u.SortId)) // 下发波次单-需要传递的参数- 支持多个Id集合查询
            .WhereIF(input.AbleSendForMateriral==true, u => u.Quantity > u.IssueQuantity) //ly-波次单-下发页面用
            .WhereIF(!string.IsNullOrWhiteSpace(input.SortNo), u => u.SortNo.Contains(input.SortNo.Trim()))
            .WhereIF(input.SortDetailStatus.HasValue, u => u.SortDetailStatus == input.SortDetailStatus)
            .WhereIF(!string.IsNullOrWhiteSpace(input.SortDetailStatusName), u => u.SortDetailStatusName.Contains(input.SortDetailStatusName.Trim()))
            .WhereIF(!string.IsNullOrWhiteSpace(input.LineNumber), u => u.LineNumber.Contains(input.LineNumber.Trim()))
            .WhereIF(!string.IsNullOrWhiteSpace(input.MaterialCode), u => u.MaterialCode.Contains(input.MaterialCode.Trim()))
            .WhereIF(!string.IsNullOrWhiteSpace(input.MaterialName), u => u.MaterialName.Contains(input.MaterialName.Trim()))
            .WhereIF(!string.IsNullOrWhiteSpace(input.RelationNo), u => u.RelationNo.Contains(input.RelationNo.Trim()))
            .WhereIF(!string.IsNullOrWhiteSpace(input.RelationNoLineNumber), u => u.RelationNoLineNumber.Contains(input.RelationNoLineNumber.Trim()))
            .WhereIF(!string.IsNullOrWhiteSpace(input.SNCode), u => u.SNCode.Contains(input.SNCode.Trim()))
            .WhereIF(!string.IsNullOrWhiteSpace(input.Unit), u => u.Unit.Contains(input.Unit.Trim()))
          //  .WhereIF(!string.IsNullOrWhiteSpace(input.IssueQuantity), u => u.IssueQuantity.Contains(input.IssueQuantity.Trim()))
            .WhereIF(!string.IsNullOrWhiteSpace(input.BatchRule), u => u.BatchRule.Contains(input.BatchRule.Trim()))
            .WhereIF(!string.IsNullOrWhiteSpace(input.Batch), u => u.Batch.Contains(input.Batch.Trim()))
            .WhereIF(!string.IsNullOrWhiteSpace(input.ErpOrderNo), u => u.ErpOrderNo.Contains(input.ErpOrderNo.Trim()))
            .WhereIF(!string.IsNullOrWhiteSpace(input.ErpCode), u => u.ErpCode.Contains(input.ErpCode.Trim()))
            .Select<WmsOrderSortDetailsOutput>();
        return query;
       }

        /// <summary>
        /// 重复性验证
        /// </summary>
        /// <param name="input">验证对象</param>
        /// <param name="isEdit">是否是编辑</param>
        /// <returns></returns>
        private async Task CheckExist( WmsOrderSortDetails input,bool isEdit=false)
        {
           


            //没有配置组合校验，不需要验重

           
            //没有配置单独校验，不需要验重
       }

       /// <summary>
        /// 根据组合校验和单独校验验证数据是否已存在-导入时验证
        /// </summary>
        /// <param name="inputs"></param>
        /// <returns></returns>
        private async Task CheckExisitForImport(List<WmsOrderSortDetails> inputs)
        { 
            if (inputs?.Count <= 0)
            {
                throw Oops.Oh($"导入数据不能为空");
            }
            //根据组合校验验证表格中中是否已存在相同数据  
                      






          
           //根据单独校验验证表格中中是否已存在相同数据  
           
           
           
        }
     #endregion

}