增加 扩展查询方法

schangxiang@126.com

2025-05-19 d57a4d61a81e2e27b09c4c9560358efb668f349d

 HIAWms/server/src/CMS.Plugin.HIAWms.Application/Implements/WmsMaterialStockAppService.cs

@@ -1,13 +1,29 @@
using CMS.Plugin.HIAWms.Application.Contracts.Dtos.WmsInOutStockOrderDetail;
using CMS.Plugin.HIAWms.Application.Contracts.Dtos.WmsInOutStockRecord;
using CMS.Plugin.HIAWms.Application.Contracts.Dtos.WmsMaterialStocks;
using CMS.Plugin.HIAWms.Application.Contracts.Dtos.WmsTask;
using CMS.Plugin.HIAWms.Application.Contracts.Services;
using CMS.Plugin.HIAWms.Domain.WmsMaterialStocks;
using CMS.Plugin.HIAWms.Domain.Shared;
using CMS.Plugin.HIAWms.Domain.Shared.Enums;
using CMS.Plugin.HIAWms.Domain.Shared.WmsMaterialStocks;
using CMS.Plugin.HIAWms.Domain.WmsAreas;
using CMS.Plugin.HIAWms.Domain.WmsContainers;
using CMS.Plugin.HIAWms.Domain.WmsInOutStockRecord;
using CMS.Plugin.HIAWms.Domain.WmsMaterials;
using CMS.Plugin.HIAWms.Domain.WmsMaterialStocks;
using CMS.Plugin.HIAWms.Domain.WmsPlaces;
using CMS.Plugin.HIAWms.Domain.WmsTask;
using CmsQueryExtensions;
using CmsQueryExtensions.Extension;
using Microsoft.Extensions.DependencyInjection;
using SqlKata;
using System.Linq.Expressions;
using System.Text.Json;
using System.Threading.Tasks;
using Volo.Abp;
using Volo.Abp.Application.Dtos;
using Volo.Abp.Data;
using Volo.Abp.ObjectExtending;
using CMS.Plugin.HIAWms.Domain.Shared.Util;
using Volo.Abp.Uow;

namespace CMS.Plugin.HIAWms.Application.Implements;

@@ -15,14 +31,37 @@
public class WmsMaterialStockAppService : CMSPluginAppService, IWmsMaterialStockAppService
{
    private readonly IWmsMaterialStockRepository _wmsmaterialstockRepository;
    private readonly IWmsMaterialRepository _wmsMaterialRepository;
    private readonly IWmsContainerRepository _wmscontainerRepository;
    private readonly IWmsPlaceRepository _wmsplaceRepository;
    private readonly IWmsAreaRepository _wmsareaRepository;
    private readonly IWmsInOutStockRecordAppService _wmspInOutStockRecordAppService;
    private readonly IWmsInOutStockRecordRepository _wmsInOutStockRecordRepository;
    private readonly IServiceProvider _serviceProvider;

    /// <summary>
    /// Initializes a new instance of the <see cref="WmsMaterialStockAppService"/> class.
    /// </summary>
    /// <param name="wmsmaterialstockRepository">The task job repository.</param>
    public WmsMaterialStockAppService(IWmsMaterialStockRepository wmsmaterialstockRepository)
    public WmsMaterialStockAppService(IWmsMaterialStockRepository wmsmaterialstockRepository,
        IWmsMaterialRepository wmsMaterialRepository,
        IWmsContainerRepository wmscontainerRepository,
        IWmsPlaceRepository wmsplaceRepository,
        IWmsAreaRepository wmsareaRepository
,
        IServiceProvider serviceProvider,
        IWmsInOutStockRecordAppService wmspInOutStockRecordAppService,
        IWmsInOutStockRecordRepository wmsInOutStockRecordRepository
        )
    {
        _wmsmaterialstockRepository = wmsmaterialstockRepository;
        _wmsMaterialRepository = wmsMaterialRepository;
        _wmscontainerRepository = wmscontainerRepository;
        _wmsplaceRepository = wmsplaceRepository;
        _wmsareaRepository = wmsareaRepository;
        _serviceProvider = serviceProvider;
        _wmspInOutStockRecordAppService = wmspInOutStockRecordAppService;
        _wmsInOutStockRecordRepository = wmsInOutStockRecordRepository;
    }

    /// <inheritdoc />
@@ -32,7 +71,7 @@
    }

    /// <inheritdoc />
    public virtual async Task<PagedResultDto<WmsMaterialStockDto>> GetListAsync(GetWmsMaterialStocksInput input)
    public virtual async Task<PagedResultDto<WmsMaterialStockDto>> GetListAsync(GetWmsMaterialStockInput input)
    {
        Check.NotNull(input, nameof(input));

@@ -41,77 +80,353 @@
            input.Sorting = nameof(WmsMaterialStock.Sort);
        }

        var specification = new WmsMaterialStockSpecification(input.Name);
        var stock = ObjectMapper.Map<GetWmsMaterialStocksInput, WmsMaterialStock>(input);
        var count = await _wmsmaterialstockRepository.GetCountAsync(stock, input.StartTime, input.EndTime, input.Filter, specification);
        var list = await _wmsmaterialstockRepository.GetListAsync(stock, input.StartTime, input.EndTime, input.Sorting, input.MaxResultCount, input.SkipCount, input.Filter, specification);
        //动态构造查询条件  
        var whereConditions = DynamicGetQueryParams(input);

        var stock = ObjectMapper.Map<GetWmsMaterialStockInput, WmsMaterialStock>(input);
        var count = await _wmsmaterialstockRepository.GetCountAsync(whereConditions);
        var list = await _wmsmaterialstockRepository.GetListAsync(whereConditions, input.Sorting, input.MaxResultCount, input.SkipCount);

        return new PagedResultDto<WmsMaterialStockDto>(count, ObjectMapper.Map<List<WmsMaterialStock>, List<WmsMaterialStockDto>>(list));
    }

    public async Task<PagedResultDto<WmsMaterialStockDto>> GetStockDetailAsync(GetWmsMaterialStockInput input)
    {
        Check.NotNull(input, nameof(input));

        if (input.Sorting.IsNullOrWhiteSpace())
        {
            input.Sorting = nameof(WmsMaterialStock.Sort);
        }

        #region 动态构造查询条件  

        //动态构造查询条件  
        var whereConditions = DynamicGetQueryParams(input);

        #endregion

        var count = await _wmsmaterialstockRepository.GetDetailCountAsync(whereConditions);
        var list = await _wmsmaterialstockRepository.GetStockDetailListAsync(whereConditions, input.Sorting, input.MaxResultCount, input.SkipCount);
        var result = list
        .GroupBy(x => x.PlaceNo)  // 按库位号分组
        .SelectMany(g => g
            .OrderBy(x => x.InStockTime)  // 按入库时间排序
            .Select((x, index) => new WmsMaterialStockDto
            {
                MaterialId = x.MaterialId,
                MaterialBatch = x.MaterialBatch,
                MaterialModel = x.MaterialModel,
                MaterialName = x.MaterialName,
                MaterialNo = x.MaterialNo,
                CheckStatus = x.CheckStatus,
                ContainerNo = x.ContainerNo,
                ContainerType = x.ContainerType,
                StockNumber = x.StockNumber,
                SupplierCode = x.SupplierCode,
                PlaceNo = x.PlaceNo,
                PlaceStatus = x.PlaceStatus,
                StorageTypeNo = x.StorageTypeNo,
                AreaCode = x.AreaCode,
                AreaName = x.AreaName,
                IsLock = x.IsLock,
                Id = x.Id,
                EmptyContainer = x.EmptyContainer,
                InStockTime = x.InStockTime,
                RedundantField1 = x.RedundantField1,
                RedundantField2 = x.RedundantField2,
                RedundantField3 = x.RedundantField3,
                Remark = x.Remark,
                OrderInPlace = index+1

            })).ToList();
            
        return new PagedResultDto<WmsMaterialStockDto>(count, result);
    }

    /// <summary>  
    /// 动态构造查询条件  
    /// </summary>  
    /// <param name="input">输入参数</param>  
    /// <returns></returns>  
    private FunReturnResultModel<Expression<Func<WmsMaterialStock, bool>>> DynamicGetQueryParams(GetWmsMaterialStockInput input)
    {
        //动态构造查询条件  
        var whereConditions = WhereConditionsExtensions.GetWhereConditions<WmsMaterialStock, GetWmsMaterialStockInput>(input);
        if (!whereConditions.IsSuccess)
        {
            throw new Exception("动态构造查询条件失败:" + whereConditions.ErrMsg);
        }

        //也可再次自定义构建查询条件  
        Expression<Func<WmsMaterialStock, bool>> extendExpression = a => a.IsDeleted == false;
        // 使用 System.Linq.PredicateBuilder 的 And 
        var pres = (System.Linq.Expressions.Expression<Func<WmsMaterialStock, bool>>)(whereConditions.data);
        whereConditions.data = System.Linq.PredicateBuilder.And(pres, extendExpression);

        return whereConditions;
    }

    /// <inheritdoc />
    public virtual async Task<WmsMaterialStockDto> CreateAsync(WmsMaterialStockCreateDto input)
    {
        using var scope = _serviceProvider.CreateScope();
        var unitOfWorkManager = scope.ServiceProvider.GetRequiredService<IUnitOfWorkManager>();
        using var uow = unitOfWorkManager.Begin(requiresNew: true);
        await CheckCreateOrUpdateDtoAsync(input);

        var exist = await _wmsmaterialstockRepository.NameExistAsync(input.MaterialNo);
        if (exist)
        var materialModel = await _wmsMaterialRepository.FindByModelAsync(input.MaterialModel);
        if(materialModel == null)
        {
            throw new UserFriendlyException(L[CMSPluginDomainErrorCodes.NameAlreadyExists, input.MaterialNo]);
            throw new UserFriendlyException("物料型号不存在");
        }

        var material = await _wmsMaterialRepository.FindByNameAsync(materialModel.MaterialNo);
        if (material == null)
        {
            throw new UserFriendlyException("物料信息不存在");
        }
        var palceInfo = await _wmsplaceRepository.FindByNameAsync(input.PlaceNo);

        //if (container == null)
        //{
        //    throw new UserFriendlyException("托盘信息不存在");
        //}
        input.ContainerNo = string.IsNullOrEmpty(input.ContainerNo) ? "TP_" + DateTime.Now.ToString("yyMMddHHmmssfff") : input.ContainerNo;

        var wmsmaterialstock = ObjectMapper.Map<WmsMaterialStockCreateDto, WmsMaterialStock>(input);
        input.MapExtraPropertiesTo(wmsmaterialstock, MappingPropertyDefinitionChecks.None);
        wmsmaterialstock.MaterialId = Guid.NewGuid().ToString("N");
        wmsmaterialstock.MaterialNo = material.MaterialNo;
        wmsmaterialstock.MaterialName = material.MaterialName;

        var wmsmaterialstockList = await _wmsmaterialstockRepository.GetStockListAsync(new WmsMaterialStock { PlaceNo = input.PlaceNo });
        if (wmsmaterialstockList.Count > 0)
        {
            if (wmsmaterialstock.StorageTypeNo == PlaceTypeEnum.YUANLIAOKUWEI)
            {
                wmsmaterialstock.ContainerNo = wmsmaterialstockList[0].ContainerNo;
                input.ContainerNo = wmsmaterialstockList[0].ContainerNo;
            }
            if (wmsmaterialstockList[0].MaterialNo != material.MaterialNo)
            {
                throw new UserFriendlyException("当前库位已存放别的物料");
            }
        }

        var container = await _wmscontainerRepository.FindByNameAsync(input.ContainerNo);

        wmsmaterialstock.ContainerStatus = ContainerStatusEnum.KUWEI;
        wmsmaterialstock.ContainerType = container == null ? ContainerTypeEnum.XUNI : container.ContainerType;
        wmsmaterialstock.StorageTypeNo = PlaceTypeEnum.XUNIKUWEI;
        wmsmaterialstock.PlaceStatus = PlaceStatusEnum.DAIRU;
        if (!string.IsNullOrEmpty(input.PlaceNo))
        {
            var place = await _wmsplaceRepository.FindByNameAsync(input.PlaceNo);
            if (place == null)
            {
                throw new UserFriendlyException("库位信息不存在");
            }
            var area = await _wmsareaRepository.FindByNameAsync(place.AreaCode);
            if (area == null)
            {
                throw new UserFriendlyException("库位库区信息不存在");
            }

            wmsmaterialstock.PlaceStatus = PlaceStatusEnum.CUNHUO;
            wmsmaterialstock.StorageTypeNo = place.StorageTypeNo;
            wmsmaterialstock.AreaCode = place.AreaCode;
            wmsmaterialstock.AreaName = area.AreaName;

            place.PlaceStatus = PlaceStatusEnum.CUNHUO;
            place.Islock = input.IsLock;

            await _wmsplaceRepository.UpdateAsync(place);
        }
        

        var maxSort = await _wmsmaterialstockRepository.GetMaxSortAsync();
        var sort = input.Sort ?? maxSort;
        var wmsmaterialstock = ObjectMapper.Map<WmsMaterialStockCreateDto, WmsMaterialStock>(input);
        input.MapExtraPropertiesTo(wmsmaterialstock, MappingPropertyDefinitionChecks.None);

        wmsmaterialstock.MaterialModel = material.MaterialModel;
        wmsmaterialstock.MaterialBatch = input.MaterialBatch;

        wmsmaterialstock.Sort = sort;
        wmsmaterialstock.InStockTime = DateTime.Now;
        await _wmsmaterialstockRepository.InsertAsync(wmsmaterialstock);

        if (input.Sort.HasValue && wmsmaterialstock.Sort != maxSort)
        var stockList = new List<WmsMaterialStock>();
        var recordList = new List<WmsInOutStockRecord>();
        for (int i = 0; i < input.StockNumber; i++)
        {
            await AdjustSortAsync(wmsmaterialstock.Id, wmsmaterialstock.Sort);
            var stock = new WmsMaterialStock();
            var json = JsonSerializer.Serialize(wmsmaterialstock);
            stock = JsonSerializer.Deserialize<WmsMaterialStock>(json);
            stock.MaterialId = Guid.NewGuid().ToString("N");
            stock.StockNumber = 1;
            stockList.Add(stock);

            // 添加库存记录
            var record = new WmsInOutStockRecord
            {
                TaskNo = string.IsNullOrEmpty(input.OrderNo) ? "Task_" + DateTime.Now.ToString("yyyyMMddHHmmssfff") : input.OrderNo,
                OrderNo = input.OrderNo,
                StockType = StockTypeEnum.InBound,
                ContainerNo = stock.ContainerNo,
                MaterialId = stock.MaterialId,
                MaterialModel = stock.MaterialModel,
                MaterialName = stock.MaterialName,
                MaterialNo = stock.MaterialNo,
                MaterialBatch = stock.MaterialBatch,
                SourcePlace = "添加库存",
                ToPlace = stock.PlaceNo,
                OperateTime = DateTime.Now,
                Remark = "入库",
            };
            recordList.Add(record);
        }
        await _wmsInOutStockRecordRepository.InsertManyAsync(recordList);
        await _wmsmaterialstockRepository.InsertManyAsync(stockList);

        if (container == null)
        {
            container = new WmsContainer
            {
                ContainerNo = wmsmaterialstock.ContainerNo,
                ContainerType = Domain.Shared.Enums.ContainerTypeEnum.XUNI,
                ContainerStatus = Domain.Shared.Enums.ContainerStatusEnum.KUWEI,
            };
            var result = await _wmscontainerRepository.InsertAsync(container);
        }
        else
        {
            container.ContainerStatus = Domain.Shared.Enums.ContainerStatusEnum.KUWEI;

            await _wmscontainerRepository.UpdateAsync(container);
        }

        //if (input.Sort.HasValue && wmsmaterialstock.Sort != maxSort)
        //{
        //    await AdjustSortAsync(wmsmaterialstock.Id, wmsmaterialstock.Sort);
        //}
        await uow.SaveChangesAsync();
        await uow.CompleteAsync();
        return ObjectMapper.Map<WmsMaterialStock, WmsMaterialStockDto>(wmsmaterialstock);
    }

    /// <inheritdoc />
    public virtual async Task<WmsMaterialStockDto> UpdateAsync(Guid id, WmsMaterialStockUpdateDto input)
    {
        using var scope = _serviceProvider.CreateScope();
        var unitOfWorkManager = scope.ServiceProvider.GetRequiredService<IUnitOfWorkManager>();
        using var uow = unitOfWorkManager.Begin(requiresNew: true);
        await CheckCreateOrUpdateDtoAsync(input);

        var wmsmaterialstock = await _wmsmaterialstockRepository.GetAsync(id);
        var exist = await _wmsmaterialstockRepository.NameExistAsync(input.MaterialNo, wmsmaterialstock.Id);
        if (exist)
        var wmsmaterialstockList = await _wmsmaterialstockRepository.GetStockListAsync(new WmsMaterialStock { MaterialNo = input.MaterialNo });
        //var exist = await _wmsmaterialstockRepository.NameExistAsync(input.MaterialNo, wmsmaterialstock.Id);
        //if (exist)
        //{
        //    throw new UserFriendlyException(L[CMSPluginDomainErrorCodes.NameAlreadyExists, input.MaterialNo]);
        //}
        var material = await _wmsMaterialRepository.FindByNameAsync(input.MaterialNo);
        if (material == null)
        {
            throw new UserFriendlyException(L[CMSPluginDomainErrorCodes.NameAlreadyExists, input.MaterialNo]);
            throw new UserFriendlyException("物料信息不存在");
        }
        var container = await _wmscontainerRepository.FindByNameAsync(input.ContainerNo);
        if (container == null)
        {
            throw new UserFriendlyException("托盘信息不存在");
        }
        var place = await _wmsplaceRepository.FindByNameAsync(input.PlaceNo);
        if (place == null)
        {
            throw new UserFriendlyException("库位信息不存在");
        }
        var area = await _wmsareaRepository.FindByNameAsync(place.AreaCode);
        if (area == null)
        {
            throw new UserFriendlyException("库位库区信息不存在");
        }

        wmsmaterialstock.SetConcurrencyStampIfNotNull(input.ConcurrencyStamp);
        input.MapExtraPropertiesTo(wmsmaterialstock, MappingPropertyDefinitionChecks.None);
        foreach (var wmsmaterialstock in wmsmaterialstockList)
        {
            if (input.StockNumber < wmsmaterialstockList.Count)
            {
                wmsmaterialstock.IsDeleted = true;
                input.StockNumber += 1;
            }
            wmsmaterialstock.SetConcurrencyStampIfNotNull(input.ConcurrencyStamp);
            input.MapExtraPropertiesTo(wmsmaterialstock, MappingPropertyDefinitionChecks.None);
            wmsmaterialstock.MaterialNo = input.MaterialNo;
            wmsmaterialstock.ContainerNo = input.ContainerNo;
            //wmsmaterialstock.StockNumber = input.StockNumber;
            wmsmaterialstock.PlaceNo = input.PlaceNo;
            wmsmaterialstock.IsLock = input.IsLock;
            wmsmaterialstock.EmptyContainer = input.EmptyContainer;
            //wmsmaterialstock.InStockTime = input.InStockTime;
            wmsmaterialstock.Remark = input.Remark;

        wmsmaterialstock.MaterialNo = input.MaterialNo;
        wmsmaterialstock.MaterialName = input.MaterialName;
        wmsmaterialstock.ContainerNo = input.ContainerNo;
        wmsmaterialstock.ContainerStatus = input.ContainerStatus;
        wmsmaterialstock.ContainerType = input.ContainerType;
        wmsmaterialstock.StockNumber = input.StockNumber;
        wmsmaterialstock.MaterialBatch = input.MaterialBatch;
        wmsmaterialstock.SupplierCode = input.SupplierCode;
        wmsmaterialstock.MaterialModel = input.MaterialModel;
        wmsmaterialstock.PlaceNo = input.PlaceNo;
        wmsmaterialstock.PlaceStatus = input.PlaceStatus;
        wmsmaterialstock.StorageTypeNo = input.StorageTypeNo;
        wmsmaterialstock.AreaCode = input.AreaCode;
        wmsmaterialstock.AreaName = input.AreaName;
        wmsmaterialstock.IsLock = input.IsLock;
        wmsmaterialstock.InStockTime = input.InStockTime;
        wmsmaterialstock.Remark = input.Remark;
            wmsmaterialstock.MaterialName = material.MaterialName;
            wmsmaterialstock.ContainerStatus = Domain.Shared.Enums.ContainerStatusEnum.KUWEI;
            wmsmaterialstock.ContainerType = container.ContainerType;

        await _wmsmaterialstockRepository.UpdateAsync(wmsmaterialstock);
            wmsmaterialstock.PlaceStatus = Domain.Shared.Enums.PlaceStatusEnum.CUNHUO;
            wmsmaterialstock.StorageTypeNo = place.StorageTypeNo;
            wmsmaterialstock.AreaCode = place.AreaCode;
            wmsmaterialstock.AreaName = area.AreaName;

        return ObjectMapper.Map<WmsMaterialStock, WmsMaterialStockDto>(wmsmaterialstock);
            wmsmaterialstock.MaterialModel = material.MaterialModel;
            wmsmaterialstock.MaterialBatch = input.MaterialBatch;
        }
        if (input.StockNumber > wmsmaterialstockList.Count)
        {
            var stockList = new List<WmsMaterialStock>();
            for (int i = 0; i < input.StockNumber - wmsmaterialstockList.Count; i++)
            {
                var stock = new WmsMaterialStock();
                var json = JsonSerializer.Serialize(wmsmaterialstockList[0]);
                stock = JsonSerializer.Deserialize<WmsMaterialStock>(json);
                stock.MaterialId = Guid.NewGuid().ToString("N");
                stock.StockNumber = 1;
                stockList.Add(stock);
            }
            await _wmsmaterialstockRepository.InsertManyAsync(stockList);
        }

        await _wmsmaterialstockRepository.UpdateManyAsync(wmsmaterialstockList);

        container.ContainerStatus = Domain.Shared.Enums.ContainerStatusEnum.KUWEI;
        place.PlaceStatus = Domain.Shared.Enums.PlaceStatusEnum.CUNHUO;
        place.Islock = input.IsLock;

        await _wmscontainerRepository.UpdateAsync(container);
        await _wmsplaceRepository.UpdateAsync(place);

        await uow.SaveChangesAsync();
        await uow.CompleteAsync();

        var result = wmsmaterialstockList.GroupBy(x => new { x.MaterialNo, x.PlaceNo, x.ContainerNo })
       .Select(g => new WmsMaterialStock
       {
           MaterialNo = g.Key.MaterialNo,
           MaterialName = g.First().MaterialName,
           PlaceNo = g.Key.PlaceNo,
           ContainerNo = g.Key.ContainerNo,
           ContainerStatus = g.First().ContainerStatus,
           PlaceStatus = g.First().PlaceStatus,
           StorageTypeNo = g.First().StorageTypeNo,
           MaterialBatch = g.First().MaterialBatch,
           MaterialModel = g.First().MaterialModel,
           AreaCode = g.First().AreaCode,
           AreaName = g.First().AreaName,
           CheckStatus = g.First().CheckStatus,
           IsLock = g.First().IsLock,
           EmptyContainer = g.First().EmptyContainer,
           InStockTime = g.First().InStockTime,
           StockNumber = g.Sum(x => x.StockNumber)
       })
       .FirstOrDefault();
        return ObjectMapper.Map<WmsMaterialStock, WmsMaterialStockDto>(result);
    }

    /// <inheritdoc />
@@ -164,10 +479,23 @@
        }
    }

    /// <summary>
    /// 删除库存
    /// </summary>
    /// <param name="materialNo"></param>
    /// <returns></returns>
    public async Task DeleteByMaterialAsync(string materialNo)
    {
        var wmsmaterialstockList = await _wmsmaterialstockRepository.GetStockListAsync(new WmsMaterialStock { MaterialNo = materialNo });
        var ids = wmsmaterialstockList.Select(x => x.Id);
        await DeleteManyAsync(ids);
    }


    /// <inheritdoc />
    public virtual async Task AdjustSortAsync(Guid id, int sort)
    {
        var list = await _wmsmaterialstockRepository.GetListAsync(null, null, null, nameof(WmsMaterialStock.Sort));
        var list = await _wmsmaterialstockRepository.GetListAsync(null, "", 0, 999);
        if (list != null && list.Any())
        {
            var initSort = 1;
@@ -347,7 +675,7 @@
    }

    /// <inheritdoc />
    public async Task<(Dictionary<string, object> Sheets, string FileName)> ExportAsync(GetWmsMaterialStocksInput input)
    public async Task<(Dictionary<string, object> Sheets, string FileName)> ExportAsync(GetWmsMaterialStockInput input)
    {
        Check.NotNull(input, nameof(input));

@@ -356,9 +684,9 @@
            input.Sorting = nameof(WmsMaterialStock.Sort);
        }

        var specification = new WmsMaterialStockSpecification(input.Name);
        var stock = ObjectMapper.Map<GetWmsMaterialStocksInput, WmsMaterialStock>(input);
        var list = await _wmsmaterialstockRepository.GetListAsync(stock, input.StartTime, input.EndTime, input.Sorting, input.MaxResultCount, input.SkipCount, input.Filter, specification, includeDetails: true);
        var whereConditions = DynamicGetQueryParams(input);
        var stock = ObjectMapper.Map<GetWmsMaterialStockInput, WmsMaterialStock>(input);
        var list = await _wmsmaterialstockRepository.GetListAsync(whereConditions, input.Sorting, input.MaxResultCount, input.SkipCount);
        var result = ObjectMapper.Map<List<WmsMaterialStock>, List<WmsMaterialStockDto>>(list);

        var sheets = new Dictionary<string, object>
@@ -377,9 +705,85 @@
    protected Task CheckCreateOrUpdateDtoAsync(WmsMaterialStockCreateOrUpdateDtoBase input)
    {
        Check.NotNull(input, nameof(input));
        Check.NotNullOrWhiteSpace(input.MaterialNo, "编号", WmsMaterialStockConsts.MaxCodeLength);
        Check.NotNullOrWhiteSpace(input.MaterialName, "名称", WmsMaterialStockConsts.MaxNameLength);
        //Check.NotNullOrWhiteSpace(input.MaterialNo, "编号", WmsMaterialStockConsts.MaxCodeLength);
        //Check.NotNullOrWhiteSpace(input.MaterialName, "名称", WmsMaterialStockConsts.MaxNameLength);
        Check.Length(input.Remark, "备注", WmsMaterialStockConsts.MaxRemarkLength);
        return Task.CompletedTask;
    }


    /// <summary> 
    /// 根据条件获取出入库单据详情列表 
    /// </summary> 
    /// <param name="whereConditions"></param> 
    /// <param name="cancellationToken"></param> 
    /// <returns></returns> 
    public async Task<List<WmsMaterialStock>> GetListByFilterAsync(Expression<Func<WmsMaterialStock, bool>> whereConditions, CancellationToken cancellationToken = default)
    {
        return await _wmsmaterialstockRepository.GetListByFilterAsync(whereConditions);
    }

    /// <summary> 
    ///  根据条件获取单个出入库单据详情 
    /// </summary> 
    /// <param name="whereConditions"></param> 
    /// <param name="isMultipleThrowException">是否查询出多条就报错</param> 
    /// <param name="cancellationToken"></param> 
    /// <returns></returns> 
    /// <exception cref="UserFriendlyException"></exception> 
    public async Task<WmsMaterialStock> GetSingleByFilterAsync(Expression<Func<WmsMaterialStock, bool>> whereConditions, bool is​MultipleThrowException = false, CancellationToken cancellationToken = default)
    {
        return await _wmsmaterialstockRepository.GetSingleByFilterAsync(whereConditions, is​MultipleThrowException);
    }

    /// <summary>  
    /// 根据条件获取出入库单据详情列表 
    /// </summary>  
    /// <param name="input"></param>  
    /// <returns></returns>  
    public virtual async Task<List<WmsMaterialStockDto>> FindListByFilterAsync(GetWmsMaterialStockInput input, CancellationToken cancellationToken = default)
    {
        Check.NotNull(input, nameof(input));

        if (input.Sorting.IsNullOrWhiteSpace())
        {
            input.Sorting = nameof(WmsMaterialStock.Sort);
        }

        #region 动态构造查询条件   

        //动态构造查询条件   
        var whereConditions = DynamicGetQueryParams(input);

        #endregion

        var list = await _wmsmaterialstockRepository.GetListByFilterAsync(whereConditions?.data);

        return new List<WmsMaterialStockDto>(ObjectMapper.Map<List<WmsMaterialStock>, List<WmsMaterialStockDto>>(list));
    }
    /// <summary>  
    /// 根据条件获取单个出入库单据详情 
    /// </summary>  
    /// <param name="input"></param>  
    /// <returns></returns>  
    public virtual async Task<WmsMaterialStockDto> FindSingleByFilterAsync(GetWmsMaterialStockInput input, CancellationToken cancellationToken = default)
    {
        Check.NotNull(input, nameof(input));

        if (input.Sorting.IsNullOrWhiteSpace())
        {
            input.Sorting = nameof(WmsMaterialStock.Sort);
        }

        #region 动态构造查询条件   

        //动态构造查询条件   
        var whereConditions = DynamicGetQueryParams(input);

        #endregion

        var dataObj = await _wmsmaterialstockRepository.GetSingleByFilterAsync(whereConditions?.data);

        return (ObjectMapper.Map<WmsMaterialStock, WmsMaterialStockDto>(dataObj));
    }
}