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 SKIT.FlurlHttpClient.Wechat.Api.Models;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using AngleSharp.Dom;
using Admin.NET.Application.CommonHelper;
using Admin.NET.Core;
using Yitter.IdGenerator;
using NewLife.Reflection;
using DocumentFormat.OpenXml.Wordprocessing;
using OfficeOpenXml.FormulaParsing.Excel.Functions.Information;

namespace Admin.NET.Application;
/// <summary>
/// 物料拆分/物料合并 服务
/// </summary>
[ApiDescriptionSettings(ApplicationConst.WmsAssistGroupName, Order = 100)]
public class WmsMaterialSplitService : IDynamicApiController, ITransient
{
    private readonly SqlSugarRepository<WmsStockQuan> _rep;
    private readonly SqlSugarRepository<v_wms_stock_quan> _v_wms_stock_quanRep;
    private readonly SqlSugarRepository<WmsBasePlace> _repWmsPlace;
    private readonly SqlSugarRepository<WmsBaseContainer> _repWmsContainer;
    private readonly SqlSugarRepository<v_wms_stock_quan_for_use> _v_wms_stock_quan_for_useRep;
    private readonly SqlSugarRepository<WmsRecordTrans> _wmsRecordTransRep;
    private readonly SqlSugarRepository<WmsBaseBusinessType> _wmsBusinessRep;
    private readonly SqlSugarRepository<WmsStockQuanZero> _wmsStockQuanZeroRep;
    private readonly SqlSugarRepository<WmsRecordSncodePrint> _wmsRecordSncodePrintrep;
    private readonly SqlSugarRepository<WmsBaseBusinessType> _wmsBaseBusinessTypeRep;
    private readonly SqlSugarRepository<WmsBasePlace> _wmsPlaceRep;

    public WmsMaterialSplitService(
          SqlSugarRepository<WmsRecordSncodePrint> wmsRecordSncodePrintrep,
        SqlSugarRepository<WmsStockQuan> rep
        , SqlSugarRepository<v_wms_stock_quan_for_use> v_wms_stock_quan_for_useRep
        , SqlSugarRepository<v_wms_stock_quan> v_wms_stock_quanRep, SqlSugarRepository<WmsBasePlace> repWmsPlace
, SqlSugarRepository<WmsBaseContainer> repWmsContainer,
        SqlSugarRepository<WmsRecordTrans> wmsRecordTransRep,
        SqlSugarRepository<WmsBaseBusinessType> wmsBusinessRep,
        SqlSugarRepository<WmsStockQuanZero> wmsStockQuanZeroRep
        , SqlSugarRepository<WmsBaseBusinessType> wmsBaseBusinessTypeRep,
        SqlSugarRepository<WmsBasePlace> wmsPlaceRep)

    {
        _wmsRecordSncodePrintrep = wmsRecordSncodePrintrep;
        _rep = rep;
        _v_wms_stock_quanRep = v_wms_stock_quanRep;
        _v_wms_stock_quan_for_useRep = v_wms_stock_quan_for_useRep;
        _repWmsPlace = repWmsPlace;
        _repWmsContainer = repWmsContainer;
        _wmsRecordTransRep = wmsRecordTransRep;
        _wmsBusinessRep = wmsBusinessRep;
        _wmsStockQuanZeroRep = wmsStockQuanZeroRep;
        _wmsBaseBusinessTypeRep = wmsBaseBusinessTypeRep;
        _wmsPlaceRep = wmsPlaceRep;
    }


    /// <summary>
    /// 物料拆分
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    [HttpPost]
    [ApiDescriptionSettings(Name = "MaterialSplit")]
    [Description("WmsMaterialSplit/MaterialSplit")]
    [UnitOfWork]
    public async Task MaterialSplit(WmsMaterialSplitInput input)
    {
        List<WmsRecordSncodePrint> addWmsRecordSncodePrintList = new List<WmsRecordSncodePrint>();//新增分拣打印信息

        if (input == null)
            throw Oops.Oh("输入参数不能为空!");
        if (string.IsNullOrEmpty(input.SNCode))
            throw Oops.Oh("物料跟踪码不能为空!");
        if (input.WmsMaterialSplits is null || input.WmsMaterialSplits.Count == 0)
            throw Oops.Oh("明细不能为空!");

        if (input.WmsMaterialSplits.Count != 2)
            throw Oops.Oh("拆分后的明细只能是2条!");


        // 获取物料信息
        var materialInfoView = await _v_wms_stock_quanRep.GetFirstAsync(n => n.SNCode == input.SNCode) ?? throw Oops.Oh($"跟踪码{input.SNCode}的物料信息不存在!");

        // 判断拆分的数量是否超过原始库存数量
        var isExist = input.WmsMaterialSplits.Any(n => n.Quantity >= materialInfoView.Quantity);
        if (isExist) throw Oops.Oh("拆分的数量超过库存原始数量");

        // 判断拆分数量和是否超过原始库存数量
        var sum = input.WmsMaterialSplits.Sum(n => n.Quantity);
        if (sum > materialInfoView.Quantity) throw Oops.Oh("拆分的数量总和超过库存原始数量");

        if (materialInfoView.LockStatus == LockStatusEnum.已锁定 || materialInfoView.StockStatus == StockStatusEnum.已冻结) throw Oops.Oh($"{input.SNCode}的库存已冻结不允许拆分!");


        // 枚举类型
        MoveTypeEnum moveType = MoveTypeEnum.其他;
        BusinessTypeEnum businessType = BusinessTypeEnum.物料拆分;
        //    获取业务类型 update by  liuwq 2024 07 30
        var wmsBaseBusinessType = BusinessTypeHelper.GetBusinessTypeInfoFromDB((int)businessType, _wmsBaseBusinessTypeRep);


        //update by liuwq 20240729
        //获取目标库位
        //物料拆分，备拆的库存 库位不变,创建事务要用，这里再查一遍
        // 新产生的库存的目标库位不用这个 用  在途库位placeAndContainer.ZtPlace
        var toPlace = await BaseInfoHelper.GetPlace(materialInfoView.PlaceCode, _wmsPlaceRep);

        // 校验在途库区和在途容器是否存在
        // 新产生的库存的目标库位 使用 在途库位placeAndContainer.ZtPlace
        var placeAndContainer = await StockQuanHelper.VerifyZTPlaceAndContainerIsExist(_repWmsPlace, _repWmsContainer, materialInfoView.AreaCode);

        var recordTransList = new List<WmsRecordTrans>();
        // 用来更新
        var updateMaterialInfo = await _rep.GetFirstAsync(n => n.SNCode == input.SNCode) ?? throw Oops.Oh($"跟踪码{input.SNCode}的物料信息不存在!");
        foreach (var item in input.WmsMaterialSplits)
        {
            // 判断id是否有值,有值更新无值修改
            if (item.Id.HasValue && item.Id > 0)
            {
                updateMaterialInfo.Quantity = item.Quantity;
                updateMaterialInfo.MaxIndex = item.MaxIndex;
                await _rep.AsUpdateable(updateMaterialInfo).IgnoreColumns(ignoreAllNullColumns: true).ExecuteCommandAsync();

                #region 创建事务日志入参

                // 其他参数对象
                TransferOtherDetail transferOtherDetail = new TransferOtherDetail()
                {
                    RelationNo = "",
                    RelationNoLineNumber = "",
                    Remarks = "",

                };
                #endregion

                //新增事务记录
                //目标库存 仅变更库存数
                recordTransList.Add(LogRecordHelper.CreateWmsRecordTrans(wmsBaseBusinessType, materialInfoView, updateMaterialInfo, toPlace, transferOtherDetail));

                addWmsRecordSncodePrintList.Add(RecordSncodePrintHelper.AddWmsRecordSncodePrintEntity(updateMaterialInfo, PrintTypeEnum.物料跟踪码, PrintSourceEnum.物料拆分打印));

            }
            else
            {
                var materialInfo = materialInfoView.Adapt<WmsStockQuan>();
                materialInfo.Id = YitIdHelper.NextId();
                materialInfo.SNCode = item.SNCode;//新增的库存的跟踪码，前端生成已经追加了_N
                materialInfo.SourceSNCode = input.SNCode;//源跟踪码就是被拆分的库存的跟踪码
                materialInfo.Quantity = item.Quantity;
                materialInfo.ContainerId = placeAndContainer.ZtContainer.Id;
                materialInfo.ContainerCode = placeAndContainer.ZtContainer.ContainerCode;
                materialInfo.MaxIndex = 0;
                await _rep.InsertAsync(materialInfo);

                #region 创建事务日志入参
                // 其他参数对象
                TransferOtherDetail transferOtherDetail = new TransferOtherDetail()
                {
                    RelationNo = "",
                    RelationNoLineNumber = "",
                    Remarks = "",

                };
                #endregion

                //源库存信息 
                //新增的库存 创建事务记录 记录源跟踪码
                v_wms_stock_quan sourceStockView = materialInfoView.Adapt<v_wms_stock_quan>();
                sourceStockView.SNCode = materialInfoView.SNCode; //源跟踪码是被拆分的库存的跟踪码
                sourceStockView.Quantity = 0;//拆分新增的库存源库存数是0

                //目标库存 是 在途库位placeAndContainer.ZtPlace
                recordTransList.Add(LogRecordHelper.CreateWmsRecordTrans(wmsBaseBusinessType, sourceStockView, materialInfo, placeAndContainer.ZtPlace, transferOtherDetail));

                addWmsRecordSncodePrintList.Add(RecordSncodePrintHelper.AddWmsRecordSncodePrintEntity(materialInfo, PrintTypeEnum.物料跟踪码, PrintSourceEnum.物料拆分打印));
            }
        }
        // 批量插入事务
        await _wmsRecordTransRep.InsertRangeAsync(recordTransList);

        //新增打印记录
        await _wmsRecordSncodePrintrep.InsertRangeAsync(addWmsRecordSncodePrintList);

    }

    /// <summary>
    /// 物料合并
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    [HttpPost]
    [ApiDescriptionSettings(Name = "MaterialMerge")]
    [Description("WmsMaterialSplit/MaterialMerge")]
    [UnitOfWork]
    public async Task MaterialMerge(WmsMaterialMergeInput input)
    {
        List<WmsRecordSncodePrint> addWmsRecordSncodePrintList = new List<WmsRecordSncodePrint>();//新增分拣打印信息

        if (input == null) throw Oops.Oh("输入参数不能为空!");

        if (string.IsNullOrEmpty(input.SNCode)) throw Oops.Oh("物料跟踪码不能为空!");

        if (input.Quantity == 0) throw Oops.Oh("合并数量不能为空!");

        if (input.SNCodeList is null || input.SNCodeList.Count == 0) throw Oops.Oh("物料跟踪码集合不能为空!");




        // 获取跟踪码集合
        var materialInfoViewList =
            await _v_wms_stock_quanRep.AsQueryable().Where(n => input.SNCodeList.Contains(n.SNCode)).ToListAsync();

        if (materialInfoViewList.Count == 0) throw Oops.Oh("物料集合为空!");

        // 已冻结的货物不允许合并
        var snCodes = materialInfoViewList.Where(n => n.LockStatus == LockStatusEnum.已锁定 || n.StockStatus == StockStatusEnum.已冻结)
            .Select(n => n.SNCode).ToList();
        if (snCodes != null && snCodes.Count > 0) throw Oops.Oh($"{string.Join(',', snCodes)}的物料为冻结状态不允许合并!");

        // 判断合并前数量与合并后数量是否匹配
        var quantitySum = materialInfoViewList.Sum(n => n.Quantity);

        if (quantitySum != input.Quantity) throw Oops.Oh("合并后的数量与合并前数量不匹配!");

        // 判断物料是否同物料，同批次，同供应商、同库存状态，同质检状态
        var materialInfo = materialInfoViewList[0];

        var materialDifferent = materialInfoViewList.Where(n => n.MaterialCode != materialInfo.MaterialCode || n.Batch != materialInfo.Batch
        || n.SupplierCode != materialInfo.SupplierCode || n.StockStatus != materialInfo.StockStatus || n.QCStatus != materialInfo.QCStatus).ToList();

        if (materialDifferent.Count > 0)
        {
            var snCodeList = materialDifferent.Select(n => n.SNCode).ToList();
            throw Oops.Oh($"跟踪码为{string.Join(',', snCodeList)}的库存信息与其他库存信息不同!");
        }



        MoveTypeEnum moveType = MoveTypeEnum.其他;
        BusinessTypeEnum businessType = BusinessTypeEnum.物料合并;
        //    获取业务类型 update by  liuwq 2024 07 30
        var wmsBaseBusinessType = BusinessTypeHelper.GetBusinessTypeInfoFromDB((int)businessType, _wmsBaseBusinessTypeRep);
        // 其他库存为0的数据转移到新表 wms_stock_quan_zero中
        var wmsStockQuanZeroList = new List<WmsStockQuanZero>();
        var recordTransList = new List<WmsRecordTrans>();
        var materialListInfo = new List<WmsStockQuan>();

        #region 新增合并后的库存信息  


        // 校验在途库区和在途容器是否存在
        var placeAndContainer = await StockQuanHelper.VerifyZTPlaceAndContainerIsExist(_repWmsPlace, _repWmsContainer, materialInfo.AreaCode);

        // 新增合并后的库存信息
        var wmsStockQuanModal = materialInfo.Adapt<WmsStockQuan>();
        wmsStockQuanModal.Id = YitIdHelper.NextId();
        wmsStockQuanModal.Quantity = input.Quantity;
        wmsStockQuanModal.ContainerId = placeAndContainer.ZtContainer.Id;
        wmsStockQuanModal.ContainerCode = placeAndContainer.ZtContainer.ContainerCode;
        wmsStockQuanModal.SNCode = input.SNCode;
        await _rep.InsertAsync(wmsStockQuanModal);

        addWmsRecordSncodePrintList.Add(RecordSncodePrintHelper.AddWmsRecordSncodePrintEntity(wmsStockQuanModal, PrintTypeEnum.物料跟踪码, PrintSourceEnum.物料合并打印));


        #region 创建事务日志入参

        // 其他参数对象
        TransferOtherDetail hbtransferOtherDetail = new TransferOtherDetail()
        {
            RelationNo = "",
            RelationNoLineNumber = "",
            Remarks = "",

        };
        #endregion
        //新增事务记录
        //合并新增库存 目标库位是在途
        recordTransList.Add(LogRecordHelper.CreateWmsRecordTrans(wmsBaseBusinessType, null, wmsStockQuanModal, placeAndContainer.ZtPlace, hbtransferOtherDetail));
        #endregion

        foreach (var item in materialInfoViewList)
        {
            var wmsStockQuanZero = item.Adapt<WmsStockQuanZero>();
            var wmsStockQuan = item.Adapt<WmsStockQuan>();
            wmsStockQuanZero.Quantity = 0;
            wmsStockQuanZeroList.Add(wmsStockQuanZero);
            materialListInfo.Add(wmsStockQuan);
            #region 创建事务日志入参

            // 其他参数对象
            TransferOtherDetail transferOtherDetail = new TransferOtherDetail()
            {
                RelationNo = "",
                RelationNoLineNumber = "",
                Remarks = "",

            };
            #endregion

            //所有被合并的库存 的目标跟踪码都是 合并新增的库存的跟踪码,库存清零存入zero表
            //toStockQuan用于添加事务记录
            var toStockQuan = item.Adapt<WmsStockQuan>();
            toStockQuan.SNCode = wmsStockQuanModal.SNCode;
            toStockQuan.Quantity = 0;
            //新增事务记录
            //目标库存 目标库位都传空 库存都转移到zero表了
            recordTransList.Add(LogRecordHelper.CreateWmsRecordTrans(wmsBaseBusinessType, item, toStockQuan, null, transferOtherDetail));

            //新增打印记录
            addWmsRecordSncodePrintList.Add(RecordSncodePrintHelper.AddWmsRecordSncodePrintEntity(wmsStockQuanZero, PrintTypeEnum.物料跟踪码, PrintSourceEnum.物料合并打印));
        }


        // 批量删除库存表
        await _rep.DeleteAsync(materialListInfo);

        // 批量新增库存历史表
        await _wmsStockQuanZeroRep.InsertRangeAsync(wmsStockQuanZeroList);

        // 批量添加事务
        await _wmsRecordTransRep.InsertRangeAsync(recordTransList);

        //新增打印记录
        await _wmsRecordSncodePrintrep.InsertRangeAsync(addWmsRecordSncodePrintList);
    }


    #region 私有方法

    /// <summary>
    /// 公共查询实时库存条件
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    private ISugarQueryable<WmsStockQuanOutput> CommonPageFilter(WmsStockQuanInput input)
    {
        var query = _rep.AsQueryable()
            .WhereIF(!string.IsNullOrWhiteSpace(input.SearchKey), u =>
                u.ContainerCode.Contains(input.SearchKey.Trim())
                || u.MaterialCode.Contains(input.SearchKey.Trim())
                || u.SupplierBatch.Contains(input.SearchKey.Trim())
                || u.Batch.Contains(input.SearchKey.Trim())
                || u.CreateUserName.Contains(input.SearchKey.Trim())
                || u.UpdateUserName.Contains(input.SearchKey.Trim())
                || u.SupplierCode.Contains(input.SearchKey.Trim())
                || u.SupplierName.Contains(input.SearchKey.Trim())
                || u.MaterialName.Contains(input.SearchKey.Trim())
                || u.SN_1d.Contains(input.SearchKey.Trim())
                || u.SN_2d.Contains(input.SearchKey.Trim())
                || u.SNCode.Contains(input.SearchKey.Trim())
                || u.ErpOrderNo.Contains(input.SearchKey.Trim())
                || u.ErpCode.Contains(input.SearchKey.Trim())
                || u.ErpVoucher.Contains(input.SearchKey.Trim())
            )
            .WhereIF(input.ContainerId > 0, u => u.ContainerId == input.ContainerId)
            .WhereIF(!string.IsNullOrWhiteSpace(input.ContainerCode), u => u.ContainerCode.Contains(input.ContainerCode.Trim()))
            .WhereIF(!string.IsNullOrWhiteSpace(input.MaterialCode), u => u.MaterialCode.Contains(input.MaterialCode.Trim()))
            .WhereIF(!string.IsNullOrWhiteSpace(input.SupplierBatch), u => u.SupplierBatch.Contains(input.SupplierBatch.Trim()))
            .WhereIF(!string.IsNullOrWhiteSpace(input.Batch), u => u.Batch.Contains(input.Batch.Trim()))
            .WhereIF(!string.IsNullOrWhiteSpace(input.SupplierCode), u => u.SupplierCode.Contains(input.SupplierCode.Trim()))
            .WhereIF(!string.IsNullOrWhiteSpace(input.SupplierName), u => u.SupplierName.Contains(input.SupplierName.Trim()))
            .WhereIF(!string.IsNullOrWhiteSpace(input.MaterialName), u => u.MaterialName.Contains(input.MaterialName.Trim()))
            .WhereIF(input.StockStatus.HasValue, u => u.StockStatus == input.StockStatus)
            .WhereIF(!string.IsNullOrWhiteSpace(input.SN_1d), u => u.SN_1d.Contains(input.SN_1d.Trim()))
            .WhereIF(!string.IsNullOrWhiteSpace(input.SN_2d), u => u.SN_2d.Contains(input.SN_2d.Trim()))
            .WhereIF(!string.IsNullOrWhiteSpace(input.SNCode), u => u.SNCode.Contains(input.SNCode.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()))
            .WhereIF(input.QCStatus.HasValue, u => u.QCStatus == input.QCStatus)
            .WhereIF(!string.IsNullOrWhiteSpace(input.ErpVoucher), u => u.ErpVoucher.Contains(input.ErpVoucher.Trim()))
            .Select<WmsStockQuanOutput>();
        if (input.RecordInsertTimeRange != null && input.RecordInsertTimeRange.Count > 0)
        {
            DateTime? start = input.RecordInsertTimeRange[0].Value.AddDays(-1);
            query = query.WhereIF(start.HasValue, u => u.RecordInsertTime > start);
            if (input.RecordInsertTimeRange.Count > 1 && input.RecordInsertTimeRange[1].HasValue)
            {
                var end = input.RecordInsertTimeRange[1].Value.AddDays(1);
                query = query.Where(u => u.RecordInsertTime < end);
            }
        }
        if (input.ActionTimeRange != null && input.ActionTimeRange.Count > 0)
        {
            DateTime? start = input.ActionTimeRange[0].Value.AddDays(-1);
            query = query.WhereIF(start.HasValue, u => u.ActionTime > start);
            if (input.ActionTimeRange.Count > 1 && input.ActionTimeRange[1].HasValue)
            {
                var end = input.ActionTimeRange[1].Value.AddDays(1);
                query = query.Where(u => u.ActionTime < end);
            }
        }
        return query;
    }


    private ISugarQueryable<v_wms_stock_quan> CommonPageViewFilter(WmsStockQuanInput input)
    {
        var query = _v_wms_stock_quanRep.AsQueryable()
            .WhereIF(!string.IsNullOrWhiteSpace(input.SearchKey), u =>
                u.ContainerCode.Contains(input.SearchKey.Trim())
                || u.MaterialCode.Contains(input.SearchKey.Trim())
                || u.SupplierBatch.Contains(input.SearchKey.Trim())
                || u.Batch.Contains(input.SearchKey.Trim())
                || u.CreateUserName.Contains(input.SearchKey.Trim())
                || u.UpdateUserName.Contains(input.SearchKey.Trim())
                || u.SupplierCode.Contains(input.SearchKey.Trim())
                || u.SupplierName.Contains(input.SearchKey.Trim())
                || u.MaterialName.Contains(input.SearchKey.Trim())
                || u.SN_1d.Contains(input.SearchKey.Trim())
                || u.SN_2d.Contains(input.SearchKey.Trim())
                || u.SNCode.Contains(input.SearchKey.Trim())
                || u.ErpOrderNo.Contains(input.SearchKey.Trim())
                || u.ErpCode.Contains(input.SearchKey.Trim())
                || u.ErpVoucher.Contains(input.SearchKey.Trim())
                || u.ActionRemark.Contains(input.SearchKey.Trim())
            )
            .WhereIF(!string.IsNullOrWhiteSpace(input.ContainerCode), u => u.ContainerCode.Contains(input.ContainerCode.Trim()))
            .WhereIF(!string.IsNullOrWhiteSpace(input.MaterialCode), u => u.MaterialCode.Contains(input.MaterialCode.Trim()))
            .WhereIF(!string.IsNullOrWhiteSpace(input.SupplierBatch), u => u.SupplierBatch.Contains(input.SupplierBatch.Trim()))
            .WhereIF(!string.IsNullOrWhiteSpace(input.Batch), u => u.Batch.Contains(input.Batch.Trim()))
            .WhereIF(!string.IsNullOrWhiteSpace(input.PlaceName), u => u.PlaceName == input.PlaceName)
            .WhereIF(!string.IsNullOrWhiteSpace(input.AreaName), u => u.AreaName == input.AreaName)


            .WhereIF(!string.IsNullOrWhiteSpace(input.SupplierCode), u => u.SupplierCode.Contains(input.SupplierCode.Trim()))
            .WhereIF(!string.IsNullOrWhiteSpace(input.SupplierName), u => u.SupplierName.Contains(input.SupplierName.Trim()))
            .WhereIF(!string.IsNullOrWhiteSpace(input.MaterialName), u => u.MaterialName.Contains(input.MaterialName.Trim()))
            .WhereIF(input.StockStatus.HasValue, u => u.StockStatus == input.StockStatus)
            .WhereIF(!string.IsNullOrWhiteSpace(input.SN_1d), u => u.SN_1d.Contains(input.SN_1d.Trim()))
            .WhereIF(!string.IsNullOrWhiteSpace(input.SN_2d), u => u.SN_2d.Contains(input.SN_2d.Trim()))
            .WhereIF(!string.IsNullOrWhiteSpace(input.SNCode), u => u.SNCode.Contains(input.SNCode.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()))
            .WhereIF(input.QCStatus.HasValue, u => u.QCStatus == input.QCStatus)
            .WhereIF(!string.IsNullOrWhiteSpace(input.ErpVoucher), u => u.ErpVoucher.Contains(input.ErpVoucher.Trim()))
            .Select<v_wms_stock_quan>();
        if (input.RecordInsertTimeRange != null && input.RecordInsertTimeRange.Count > 0)
        {
            DateTime? start = input.RecordInsertTimeRange[0].Value.AddDays(-1);
            query = query.WhereIF(start.HasValue, u => u.RecordInsertTime > start);
            if (input.RecordInsertTimeRange.Count > 1 && input.RecordInsertTimeRange[1].HasValue)
            {
                var end = input.RecordInsertTimeRange[1].Value.AddDays(1);
                query = query.Where(u => u.RecordInsertTime < end);
            }
        }
        if (input.ActionTimeRange != null && input.ActionTimeRange.Count > 0)
        {
            DateTime? start = input.ActionTimeRange[0].Value.AddDays(-1);
            query = query.WhereIF(start.HasValue, u => u.ActionTime > start);
            if (input.ActionTimeRange.Count > 1 && input.ActionTimeRange[1].HasValue)
            {
                var end = input.ActionTimeRange[1].Value.AddDays(1);
                query = query.Where(u => u.ActionTime < end);
            }
        }
        return query;
    }

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



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


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

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








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



    }
    #endregion

}