库存后端修改

zs

2025-05-05 3cd9f003ae893abe2483ab3ce0a62bfbd9fa8554

库存后端修改

 HIAWms/server/src/CMS.Plugin.HIAWms.Application.Contracts/Dtos/WmsMaterialStocks/GetWmsMaterialStocksInput.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,110 @@
using CMS.Plugin.HIAWms.Domain.Shared.Enums;
using Volo.Abp.Application.Dtos;

namespace CMS.Plugin.HIAWms.Application.Contracts.Dtos.WmsMaterialStocks;

/// <summary>
/// WmsMaterialStock查询参数对象
/// </summary>
public class GetWmsMaterialStocksInput : ExtensiblePagedAndSortedResultRequestDto
{
    /// <summary>
    /// Gets or sets the filter.
    /// </summary>
    public string Filter { get; set; }

    /// <summary>
    /// Gets or sets the name.
    /// </summary>
    public string Name { get; set; }

    /// <summary>
    /// å¼€å§‹æ—¶é—´
    /// </summary>
    public DateTime? StartTime { get; set; }

    /// <summary>
    /// ç»“束时间
    /// </summary>
    public DateTime? EndTime { get; set; }

    /// <summary>
    /// ç¼–号
    /// </summary>
    public virtual string MaterialId { get; set; }

    /// <summary>
    /// åç§°
    /// </summary>
    public virtual string MaterialName { get; set; }

    /// <summary>
    /// å®¹å™¨ç¼–号
    /// </summary>
    public string ContainerNo { get; set; }

    /// <summary>
    /// å®¹å™¨çŠ¶æ€
    /// </summary>
    public ContainerStatusEnum? ContainerStatus { get; set; }

    /// <summary>
    /// å®¹å™¨ç±»åž‹
    /// </summary>
    public ContainerTypeEnum? ContainerType { get; set; }

    /// <summary>
    /// ç‰©æ–™ç¼–号
    /// </summary>
    public string MaterialNo { get; set; }

    /// <summary>
    /// ç‰©æ–™æ‰¹æ¬¡
    /// </summary>
    public string MaterialBatch { get; set; }

    /// <summary>
    /// ä¾›åº”商编号
    /// </summary>
    public string SupplierCode { get; set; }

    /// <summary>
    /// æœºåž‹
    /// </summary>
    public string MaterialModel { get; set; }

    /// <summary>
    /// åº“位编号
    /// </summary>
    public string PlaceNo { get; set; }

    /// <summary>
    /// åº“位状态
    /// </summary>
    public PlaceStatusEnum? PlaceStatus { get; set; }

    /// <summary>
    /// åº“位类型编号
    /// </summary>
    public PlaceTypeEnum? StorageTypeNo { get; set; }

    /// <summary>
    /// åŒºåŸŸç¼–号
    /// </summary>
    public string AreaCode { get; set; }

    /// <summary>
    /// åº“区名称
    /// </summary>
    public string AreaName { get; set; }

    /// <summary>
    /// æ˜¯å¦é”å®š
    /// </summary>
    public YesNoEnum? IsLock { get; set; }

    /// <summary>
    /// å…¥åº“时间
    /// </summary>
    public DateTime? InStockTime { get; set; }
}

 HIAWms/server/src/CMS.Plugin.HIAWms.Application.Contracts/Dtos/WmsMaterialStocks/WmsMaterialStockCreateDto.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,17 @@
namespace CMS.Plugin.HIAWms.Application.Contracts.Dtos.WmsMaterialStocks;

/// <summary>
/// WmsMaterialStock创建参数对象
/// </summary>
public class WmsMaterialStockCreateDto : WmsMaterialStockCreateOrUpdateDtoBase
{
    /// <summary>
    /// æŽ’序
    /// </summary>
    public virtual int? Sort { get; set; }

    /// <summary>
    /// æ˜¯å¦ç¦ç”¨
    /// </summary>
    public bool? IsDisabled { get; set; } = false;
}

 HIAWms/server/src/CMS.Plugin.HIAWms.Application.Contracts/Dtos/WmsMaterialStocks/WmsMaterialStockCreateOrUpdateDtoBase.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,112 @@
using CMS.Plugin.HIAWms.Domain.Shared.Enums;
using Volo.Abp.Application.Dtos;

namespace CMS.Plugin.HIAWms.Application.Contracts.Dtos.WmsMaterialStocks;

/// <summary>
/// WmsMaterialStock创建或更新基类
/// </summary>
public abstract class WmsMaterialStockCreateOrUpdateDtoBase : ExtensibleEntityDto
{
    /// <summary>
    /// ç¼–号
    /// </summary>
    public virtual string MaterialId { get; set; }

    /// <summary>
    /// åç§°
    /// </summary>
    public virtual string MaterialName { get; set; }

    /// <summary>
    /// å®¹å™¨ç¼–号
    /// </summary>
    public string ContainerNo { get; set; }

    /// <summary>
    /// å®¹å™¨çŠ¶æ€
    /// </summary>
    public ContainerStatusEnum ContainerStatus { get; set; }

    /// <summary>
    /// å®¹å™¨ç±»åž‹
    /// </summary>
    public ContainerTypeEnum ContainerType { get; set; }

    /// <summary>
    /// ç‰©æ–™ç¼–号
    /// </summary>
    public string MaterialNo { get; set; }

    /// <summary>
    /// åº“存数量
    /// </summary>
    public int StockNumber { get; set; }

    /// <summary>
    /// ç‰©æ–™æ‰¹æ¬¡
    /// </summary>
    public string MaterialBatch { get; set; }

    /// <summary>
    /// ä¾›åº”商编号
    /// </summary>
    public string SupplierCode { get; set; }

    /// <summary>
    /// æœºåž‹
    /// </summary>
    public string MaterialModel { get; set; }

    /// <summary>
    /// åº“位编号
    /// </summary>
    public string PlaceNo { get; set; }

    /// <summary>
    /// åº“位状态
    /// </summary>
    public PlaceStatusEnum PlaceStatus { get; set; }

    /// <summary>
    /// åº“位类型编号
    /// </summary>
    public PlaceTypeEnum StorageTypeNo { get; set; }

    /// <summary>
    /// åŒºåŸŸç¼–号
    /// </summary>
    public string AreaCode { get; set; }

    /// <summary>
    /// åº“区名称
    /// </summary>
    public string AreaName { get; set; }

    /// <summary>
    /// æ˜¯å¦é”å®š
    /// </summary>
    public int IsLock { get; set; }

    /// <summary>
    /// æ˜¯å¦ç©ºæ‰˜
    /// </summary>
    public YesNoEnum EmptyContainer { get; protected set; }

    /// <summary>
    /// å…¥åº“时间
    /// </summary>
    public DateTime? InStockTime { get; set; }

    /// <summary>
    /// å¤‡æ³¨
    /// </summary>
    public virtual string Remark { get; set; }

    /// <summary>
    /// Initializes a new instance of the <see cref="WmsMaterialStockCreateOrUpdateDtoBase"/> class.
    /// </summary>
    public WmsMaterialStockCreateOrUpdateDtoBase() : base(false)
    {
    }
}

 HIAWms/server/src/CMS.Plugin.HIAWms.Application.Contracts/Dtos/WmsMaterialStocks/WmsMaterialStockDto.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,205 @@
using CMS.Plugin.HIAWms.Domain.Shared.Enums;
using System.Runtime.CompilerServices;
using Volo.Abp.Application.Dtos;
using Volo.Abp.Domain.Entities;

namespace CMS.Plugin.HIAWms.Application.Contracts.Dtos.WmsMaterialStocks;

/// <summary>
/// WmsMaterialStock数据参数对象
/// </summary>
public class WmsMaterialStockDto : ExtensibleEntityDto<Guid>, IHasConcurrencyStamp
{
    /// <summary>
    /// ç¼–号
    /// </summary>
    public virtual string MaterialId { get; set; }

    /// <summary>
    /// åç§°
    /// </summary>
    public virtual string MaterialName { get; set; }

    /// <summary>
    /// å®¹å™¨ç¼–号
    /// </summary>
    public string ContainerNo { get; set; }

    /// <summary>
    /// å®¹å™¨çŠ¶æ€
    /// </summary>
    public ContainerStatusEnum ContainerStatus { get; set; }

    /// <summary>
    /// æ‰˜ç›˜çŠ¶æ€
    /// </summary>
    public string ContainerStatusDesc
    {
        get
        {
            return GetEnumDescriptionUtil.GetEnumDescription(ContainerStatus);
        }
    }

    /// <summary>
    /// å®¹å™¨ç±»åž‹
    /// </summary>
    public ContainerTypeEnum ContainerType { get; set; }

    /// <summary>
    /// æ‰˜ç›˜ç±»åž‹
    /// </summary>
    public string ContainerTypeDesc
    {
        get
        {
            return GetEnumDescriptionUtil.GetEnumDescription(ContainerType);
        }
    }


    /// <summary>
    /// ç‰©æ–™ç¼–号
    /// </summary>
    public string MaterialNo { get; set; }

    /// <summary>
    /// åº“存数量
    /// </summary>
    public int StockNumber { get; set; }

    /// <summary>
    /// ç‰©æ–™æ‰¹æ¬¡
    /// </summary>
    public string MaterialBatch { get; set; }

    /// <summary>
    /// ä¾›åº”商编号
    /// </summary>
    public string SupplierCode { get; set; }

    /// <summary>
    /// æœºåž‹
    /// </summary>
    public string MaterialModel { get; set; }

    /// <summary>
    /// åº“位编号
    /// </summary>
    public string PlaceNo { get; set; }

    /// <summary>
    /// åº“位状态
    /// </summary>
    public PlaceStatusEnum PlaceStatus { get; set; }

    /// <summary>
    /// è´§ä½çŠ¶æ€
    /// </summary>
    public string PlaceStatusDesc
    {
        get
        {
            return GetEnumDescriptionUtil.GetEnumDescription(PlaceStatus);
        }
    }


    /// <summary>
    /// åº“位类型编号
    /// </summary>
    public PlaceTypeEnum StorageTypeNo { get; set; }

    /// <summary>
    /// è´§ä½ç±»åž‹
    /// </summary>
    public string StorageTypeNoDesc
    {
        get
        {
            return GetEnumDescriptionUtil.GetEnumDescription(StorageTypeNo);
        }
    }

    /// <summary>
    /// åŒºåŸŸç¼–号
    /// </summary>
    public string AreaCode { get; set; }

    /// <summary>
    /// åº“区名称
    /// </summary>
    public string AreaName { get; set; }

    /// <summary>
    /// æ˜¯å¦é”å®š
    /// </summary>
    public YesNoEnum IsLock { get; set; }

    /// <summary>
    /// æ˜¯å¦é”å®š
    /// </summary>
    public string IsLockDesc
    {
        get
        {
            return GetEnumDescriptionUtil.GetEnumDescription(IsLock);
        }
    }

    /// <summary>
    /// æ˜¯å¦ç©ºæ‰˜
    /// </summary>
    public YesNoEnum EmptyContainer { get; protected set; }

    /// <summary>
    /// æ˜¯å¦ç©ºæ‰˜
    /// </summary>
    public string EmptyContainerDesc
    {
        get
        {
            return GetEnumDescriptionUtil.GetEnumDescription(EmptyContainer);
        }
    }

    /// <summary>
    /// å…¥åº“时间
    /// </summary>
    public DateTime? InStockTime { get; set; }

    /// <summary>
    /// æŽ’序
    /// </summary>
    public virtual int Sort { get; set; }

    /// <summary>
    /// å¤‡æ³¨
    /// </summary>
    public virtual string Remark { get; set; }

    /// <summary>
    /// æ˜¯å¦ç¦ç”¨
    /// </summary>
    public virtual bool? IsDisabled { get; set; }

    /// <summary>
    /// å¹¶å‘戳
    /// </summary>
    public string ConcurrencyStamp { get; set; }

    /// <summary>
    /// Gets the export data.
    /// </summary>
    /// <returns></returns>
    public Dictionary<string, object> GetExportData()
    {
        var exportData = new Dictionary<string, object>();
        foreach (var property in this.GetType().GetProperties())
        {
            exportData.Add(property.Name, property.GetValue(this));
        }

        return exportData;
    }
}

 HIAWms/server/src/CMS.Plugin.HIAWms.Application.Contracts/Dtos/WmsMaterialStocks/WmsMaterialStockUpdateDto.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,14 @@
using Volo.Abp.Domain.Entities;

namespace CMS.Plugin.HIAWms.Application.Contracts.Dtos.WmsMaterialStocks;

/// <summary>
/// WmsMaterialStock更新参数对象
/// </summary>
public class WmsMaterialStockUpdateDto : WmsMaterialStockCreateOrUpdateDtoBase, IHasConcurrencyStamp
{
    /// <summary>
    /// å¹¶å‘戳
    /// </summary>
    public string ConcurrencyStamp { get; set; }
}

 HIAWms/server/src/CMS.Plugin.HIAWms.Application.Contracts/Dtos/WmsMaterialStocks/WmsMaterialStocksExportModel.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,136 @@
using CMS.Plugin.HIAWms.Domain.Shared.Enums;
using MiniExcelLibs.Attributes;

namespace CMS.Plugin.HIAWms.Application.Contracts.Dtos.WmsMaterialStocks
{
    /// <summary>
    /// WmsMaterialStocks导出模型
    /// </summary>
    public class WmsMaterialStocksExportModel
    {
        /// <summary>
        /// WmsMaterialStock导出模型
        /// </summary>
        public class WorkSectionExportModel
        {
            /// <summary>
            /// ç‰©æ–™ç¼–号（唯一标识）
            /// </summary>
            [ExcelColumn(Name = "物料编号", Width = 25)]
            public string MaterialNo { get; set; }

            /// <summary>
            /// ç‰©æ–™åç§°/描述
            /// </summary>
            [ExcelColumn(Name = "物料名称", Width = 25)]
            public string MaterialName { get; set; }

            /// <summary>
            /// å®¹å™¨/托盘编号
            /// </summary>
            [ExcelColumn(Name = "容器编号", Width = 25)]
            public string ContainerNo { get; set; }

            /// <summary>
            /// å®¹å™¨çŠ¶æ€æžšä¸¾å€¼
            /// <para>0-空容器 1-已装载 2-故障</para>
            /// </summary>
            [ExcelColumn(Name = "容器状态", Width = 25)]
            public ContainerStatusEnum ContainerStatus { get; set; }

            /// <summary>
            /// å®¹å™¨ç±»åž‹æžšä¸¾å€¼
            /// <para>1-托盘 2-料箱 3-周转箱</para>
            /// </summary>
            [ExcelColumn(Name = "容器类型", Width = 25)]
            public ContainerTypeEnum ContainerType { get; set; }

            /// <summary>
            /// å½“前库存数量（整数）
            /// </summary>
            [ExcelColumn(Name = "库存数量", Width = 25)]
            public int StockNumber { get; set; }

            /// <summary>
            /// ç‰©æ–™æ‰¹æ¬¡å·ï¼ˆLOT）
            /// </summary>
            [ExcelColumn(Name = "物料批次", Width = 25)]
            public string MaterialBatch { get; set; }

            /// <summary>
            /// ä¾›åº”商编码（关联供应商表）
            /// </summary>
            [ExcelColumn(Name = "供应商编号", Width = 25)]
            public string SupplierCode { get; set; }

            /// <summary>
            /// ç‰©æ–™è§„格型号
            /// </summary>
            [ExcelColumn(Name = "型号", Width = 25)]
            public string MaterialModel { get; set; }

            /// <summary>
            /// åº“位编码（库位表外键）
            /// </summary>
            [ExcelColumn(Name = "库位编号", Width = 25)]
            public string PlaceNo { get; set; }

            /// <summary>
            /// åº“位状态枚举值
            /// <para>1-空闲 2-占用 3-禁用</para>
            /// </summary>
            [ExcelColumn(Name = "库位状态", Width = 25)]
            public PlaceStatusEnum PlaceStatus { get; set; }

            /// <summary>
            /// åº“位类型枚举值
            /// <para>1-平面库 2-立体库 3-重型货架</para>
            /// </summary>
            [ExcelColumn(Name = "库位类型", Width = 25)]
            public PlaceTypeEnum StorageTypeNo { get; set; }

            /// <summary>
            /// æ‰€å±žåº“区编码（区域表外键）
            /// </summary>
            [ExcelColumn(Name = "区域编号", Width = 25)]
            public string AreaCode { get; set; }

            /// <summary>
            /// åº“区名称（显示用）
            /// </summary>
            [ExcelColumn(Name = "库区名称", Width = 25)]
            public string AreaName { get; set; }

            /// <summary>
            /// é”å®šçŠ¶æ€
            /// <para>0-未锁定 1-已锁定</para>
            /// </summary>
            [ExcelColumn(Name = "是否锁定", Width = 25)]
            public int IsLock { get; set; }

            /// <summary>
            /// æ˜¯å¦ç©ºæ‰˜
            /// </summary>
            [ExcelColumn(Name = "是否空托", Width = 25)]
            public YesNoEnum EmptyContainer { get; protected set; }

            /// <summary>
            /// æœ€åŽå…¥åº“时间（可为空）
            /// </summary>
            [ExcelColumn(Name = "入库时间", Width = 25, Format = "yyyy-MM-dd HH:mm")]
            public DateTime? InStockTime { get; set; }

            /// <summary>
            /// æ˜¾ç¤ºæŽ’序序号
            /// </summary>
            [ExcelColumn(Name = "排序", Width = 15)]
            public int Sort { get; set; }

            /// <summary>
            /// å¤‡æ³¨ä¿¡æ¯
            /// </summary>
            [ExcelColumn(Name = "备注", Width = 30)]
            public string Remark { get; set; }
        }
    }
}

 HIAWms/server/src/CMS.Plugin.HIAWms.Application.Contracts/Dtos/WmsMaterialStocks/WmsMaterialStocksImportModel.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,34 @@
using static CMS.Plugin.HIAWms.Application.Contracts.Dtos.WmsMaterialStocks.WmsMaterialStocksExportModel;

namespace CMS.Plugin.HIAWms.Application.Contracts.Dtos.WmsMaterialStocks
{
    /// <summary>
    /// WmsMaterialStocks导入模型
    /// </summary>
    public class WmsMaterialStocksImportModel
    {
        private List<WmsMaterialStockImportModel> _wmsmaterialstocks = new();

        public List<WmsMaterialStockImportModel> WmsMaterialStocks
        {
            get => _wmsmaterialstocks;
            set
            {
                _wmsmaterialstocks = value;
                var rowIndex = 2;
                _wmsmaterialstocks?.ForEach(x => x.RowIndex = rowIndex++);
            }
        }

        /// <summary>
        /// WmsMaterialStock导入模型
        /// </summary>
        public class WmsMaterialStockImportModel : WorkSectionExportModel
        {
            /// <summary>
            /// è¡Œå·
            /// </summary>
            public int RowIndex { get; set; }
        }
    }
}

 HIAWms/server/src/CMS.Plugin.HIAWms.Application.Contracts/Services/IWmsMaterialStockAppService.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,46 @@
using CMS.Plugin.HIAWms.Application.Contracts.Dtos.WmsMaterialStocks;
using Volo.Abp.Application.Services;

namespace CMS.Plugin.HIAWms.Application.Contracts.Services;

/// <summary>
/// WmsMaterialStock应用服务
/// </summary>
public interface IWmsMaterialStockAppService : ICrudAppService<WmsMaterialStockDto, Guid, GetWmsMaterialStocksInput, WmsMaterialStockCreateDto, WmsMaterialStockUpdateDto>
{
    /// <summary>
    /// Clones the asynchronous.
    /// </summary>
    /// <param name="ids">The ids.</param>
    /// <returns></returns>
    Task<List<WmsMaterialStockDto>> CloneAsync(IEnumerable<Guid> ids);

    /// <summary>
    /// Deletes the many asynchronous.
    /// </summary>
    /// <param name="ids">The ids.</param>
    /// <returns></returns>
    Task DeleteManyAsync(IEnumerable<Guid> ids);

    /// <summary>
    /// Adjusts the sort asynchronous.
    /// </summary>
    /// <param name="id">The identifier.</param>
    /// <param name="sort">The sort.</param>
    /// <returns></returns>
    Task AdjustSortAsync(Guid id, int sort);

    /// <summary>
    /// Imports the asynchronous.
    /// </summary>
    /// <param name="input">The input.</param>
    /// <returns></returns>
    Task ImportAsync(WmsMaterialStocksImportModel input);

    /// <summary>
    /// Exports the asynchronous.
    /// </summary>
    /// <param name="input">The input.</param>
    /// <returns></returns>
    Task<(Dictionary<string, object> Sheets, string FileName)> ExportAsync(GetWmsMaterialStocksInput input);
}

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

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,385 @@
using CMS.Plugin.HIAWms.Application.Contracts.Dtos.WmsMaterialStocks;
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.WmsMaterialStocks;
using Volo.Abp;
using Volo.Abp.Application.Dtos;
using Volo.Abp.Data;
using Volo.Abp.ObjectExtending;
using CMS.Plugin.HIAWms.Domain.Shared.Util;

namespace CMS.Plugin.HIAWms.Application.Implements;

/// <inheritdoc />
public class WmsMaterialStockAppService : CMSPluginAppService, IWmsMaterialStockAppService
{
    private readonly IWmsMaterialStockRepository _wmsmaterialstockRepository;

    /// <summary>
    /// Initializes a new instance of the <see cref="WmsMaterialStockAppService"/> class.
    /// </summary>
    /// <param name="wmsmaterialstockRepository">The task job repository.</param>
    public WmsMaterialStockAppService(IWmsMaterialStockRepository wmsmaterialstockRepository)
    {
        _wmsmaterialstockRepository = wmsmaterialstockRepository;
    }

    /// <inheritdoc />
    public virtual async Task<WmsMaterialStockDto> GetAsync(Guid id)
    {
        return ObjectMapper.Map<WmsMaterialStock, WmsMaterialStockDto>(await _wmsmaterialstockRepository.GetAsync(id));
    }

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

        if (input.Sorting.IsNullOrWhiteSpace())
        {
            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);

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

    /// <inheritdoc />
    public virtual async Task<WmsMaterialStockDto> CreateAsync(WmsMaterialStockCreateDto input)
    {
        await CheckCreateOrUpdateDtoAsync(input);

        var exist = await _wmsmaterialstockRepository.NameExistAsync(input.MaterialNo);
        if (exist)
        {
            throw new UserFriendlyException(L[CMSPluginDomainErrorCodes.NameAlreadyExists, input.MaterialNo]);
        }

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

        if (input.Sort.HasValue && wmsmaterialstock.Sort != maxSort)
        {
            await AdjustSortAsync(wmsmaterialstock.Id, wmsmaterialstock.Sort);
        }

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

    /// <inheritdoc />
    public virtual async Task<WmsMaterialStockDto> UpdateAsync(Guid id, WmsMaterialStockUpdateDto input)
    {
        await CheckCreateOrUpdateDtoAsync(input);

        var wmsmaterialstock = await _wmsmaterialstockRepository.GetAsync(id);
        var exist = await _wmsmaterialstockRepository.NameExistAsync(input.MaterialNo, wmsmaterialstock.Id);
        if (exist)
        {
            throw new UserFriendlyException(L[CMSPluginDomainErrorCodes.NameAlreadyExists, input.MaterialNo]);
        }

        wmsmaterialstock.SetConcurrencyStampIfNotNull(input.ConcurrencyStamp);
        input.MapExtraPropertiesTo(wmsmaterialstock, MappingPropertyDefinitionChecks.None);

        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;

        await _wmsmaterialstockRepository.UpdateAsync(wmsmaterialstock);

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

    /// <inheritdoc />
    public async Task<List<WmsMaterialStockDto>> CloneAsync(IEnumerable<Guid> ids)
    {
        var wmsmaterialstocks = new List<WmsMaterialStock>();
        if (ids != null)
        {
            var sort = await _wmsmaterialstockRepository.GetMaxSortAsync();
            foreach (var id in ids)
            {
                var wmsmaterialstock = await _wmsmaterialstockRepository.FindAsync(id);
                if (wmsmaterialstock != null)
                {
                    var name = wmsmaterialstock.MaterialNo + WmsMaterialStockConsts.CloneTag;
                    var notExist = false;
                    while (!notExist)
                    {
                        var exist = await _wmsmaterialstockRepository.NameExistAsync(name);
                        if (exist || wmsmaterialstocks.Any(x => x.MaterialNo == name))
                        {
                            name += WmsMaterialStockConsts.CloneTag;
                            continue;
                        }

                        notExist = true;
                    }

                    //wmsmaterialstock = await _wmsmaterialstockRepository.InsertAsync(wmsmaterialstock.Clone(GuidGenerator.Create(), name, sort++));
                    wmsmaterialstocks.Add(wmsmaterialstock);
                }
            }
        }

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

    /// <inheritdoc />
    public virtual Task DeleteAsync(Guid id)
    {
        return _wmsmaterialstockRepository.DeleteAsync(id);
    }

    /// <inheritdoc />
    public async Task DeleteManyAsync(IEnumerable<Guid> ids)
    {
        foreach (var id in ids)
        {
            await DeleteAsync(id);
        }
    }

    /// <inheritdoc />
    public virtual async Task AdjustSortAsync(Guid id, int sort)
    {
        var list = await _wmsmaterialstockRepository.GetListAsync(null, null, null, nameof(WmsMaterialStock.Sort));
        if (list != null && list.Any())
        {
            var initSort = 1;
            list.ForEach(x => x.AdjustSort(initSort++));
            var entity = list.FirstOrDefault(x => x.Id == id);
            if (entity != null)
            {
                if (sort == 1)
                {
                    list.Where(x => x.Id != id).ToList()?.ForEach(x => x.AdjustSort(x.Sort + 1));
                }
                else if (entity.Sort > sort)
                {
                    list.Where(x => x.Id != id && x.Sort >= sort).ToList()?.ForEach(x => x.AdjustSort(x.Sort + 1));
                    list.Where(x => x.Id != id && x.Sort < sort).ToList()?.ForEach(x => x.AdjustSort(x.Sort - 1));
                }
                else if (entity.Sort < sort)
                {
                    list.Where(x => x.Id != id && x.Sort > sort).ToList()?.ForEach(x => x.AdjustSort(x.Sort + 1));
                    list.Where(x => x.Id != id && x.Sort <= sort).ToList()?.ForEach(x => x.AdjustSort(x.Sort - 1));
                }

                entity.AdjustSort(sort);
            }
        }

        await _wmsmaterialstockRepository.UpdateManyAsync(list);
    }

    /// <inheritdoc />
    public async Task ImportAsync(WmsMaterialStocksImportModel input)
    {
        Check.NotNull(input, nameof(input));

        var wmsmaterialstockCreateDtos = new List<(int RowIndex, WmsMaterialStockCreateDto Item)>();
        var wmsmaterialstockUpdateDtos = new List<(int RowIndex, Guid Id, WmsMaterialStockUpdateDto Item)>();
        var wmsmaterialstocks = input.WmsMaterialStocks;

        if (wmsmaterialstocks != null && wmsmaterialstocks.Any())
        {
            #region å¯¼å…¥æ ¡éªŒ

            // åˆ¤æ–­åç§°æ˜¯å¦é‡å¤ï¼Œå¹¶è¾“出第几行重复
            var duplicateWmsMaterialStocks = wmsmaterialstocks.GroupBy(x => x.MaterialNo).Where(x => x.Count() > 1).ToList();
            if (duplicateWmsMaterialStocks?.Any() == true)
            {
                var duplicateWmsMaterialStockMsgs = duplicateWmsMaterialStocks.Select(x => $"第 {string.Join(",", x.Select(x => x.RowIndex))} è¡Œï¼š{x.Key}  åç§°é‡å¤");
                var errorMsg = $"导入失败！配置， {string.Join(",", duplicateWmsMaterialStockMsgs)}，终止导入";
                throw new UserFriendlyException(errorMsg);
            }

            #endregion

            foreach (var wmsmaterialstock in wmsmaterialstocks)
            {
                if (wmsmaterialstock.MaterialNo.IsNullOrWhiteSpace() && wmsmaterialstock.MaterialNo.IsNullOrWhiteSpace())
                {
                    continue;
                }

                if (wmsmaterialstock.MaterialNo.IsNullOrWhiteSpace())
                {
                    var errorMsg = $"导入失败！配置，第{wmsmaterialstock.RowIndex}行：WmsMaterialStock名称不能为空";
                    throw new UserFriendlyException(errorMsg);
                }

                var oldWmsMaterialStock = await _wmsmaterialstockRepository.FindByNameAsync(wmsmaterialstock.MaterialNo);
                if (oldWmsMaterialStock != null)
                {
                    var wmsMaterialStockUpdateDto = new WmsMaterialStockUpdateDto
                    {
                        // åŸºç¡€ä¿¡æ¯
                        MaterialNo = wmsmaterialstock.MaterialNo,
                        MaterialName = wmsmaterialstock.MaterialName,
                        Remark = wmsmaterialstock.Remark,

                        // å®¹å™¨ä¿¡æ¯
                        ContainerNo = wmsmaterialstock.ContainerNo,
                        ContainerStatus = wmsmaterialstock.ContainerStatus,
                        ContainerType = wmsmaterialstock.ContainerType,

                        // åº“存信息
                        StockNumber = wmsmaterialstock.StockNumber,
                        MaterialBatch = wmsmaterialstock.MaterialBatch,

                        // ä¾›åº”商信息
                        SupplierCode = wmsmaterialstock.SupplierCode,
                        MaterialModel = wmsmaterialstock.MaterialModel,

                        // åº“位信息
                        PlaceNo = wmsmaterialstock.PlaceNo,
                        PlaceStatus = wmsmaterialstock.PlaceStatus,
                        StorageTypeNo = wmsmaterialstock.StorageTypeNo,

                        // åº“区信息
                        AreaCode = wmsmaterialstock.AreaCode,
                        AreaName = wmsmaterialstock.AreaName,

                        // çŠ¶æ€ä¿¡æ¯
                        IsLock = wmsmaterialstock.IsLock,
                        InStockTime = wmsmaterialstock.InStockTime,

                        // å¹¶å‘控制
                        ConcurrencyStamp = oldWmsMaterialStock.ConcurrencyStamp
                    };

                    wmsmaterialstockUpdateDtos.Add((wmsmaterialstock.RowIndex, oldWmsMaterialStock.Id, wmsMaterialStockUpdateDto));
                }
                else
                {
                    var wmsmaterialstockCreateDto = new WmsMaterialStockCreateDto
                    {
                        // åŸºç¡€ä¿¡æ¯
                        MaterialNo = wmsmaterialstock.MaterialNo,
                        MaterialName = wmsmaterialstock.MaterialName,
                        Remark = wmsmaterialstock.Remark,

                        // å®¹å™¨ä¿¡æ¯
                        ContainerNo = wmsmaterialstock.ContainerNo,
                        ContainerStatus = wmsmaterialstock.ContainerStatus,
                        ContainerType = wmsmaterialstock.ContainerType,

                        // åº“存信息
                        StockNumber = wmsmaterialstock.StockNumber,
                        MaterialBatch = wmsmaterialstock.MaterialBatch,

                        // ä¾›åº”商信息
                        SupplierCode = wmsmaterialstock.SupplierCode,
                        MaterialModel = wmsmaterialstock.MaterialModel,

                        // åº“位信息
                        PlaceNo = wmsmaterialstock.PlaceNo,
                        PlaceStatus = wmsmaterialstock.PlaceStatus,
                        StorageTypeNo = wmsmaterialstock.StorageTypeNo,

                        // åº“区信息
                        AreaCode = wmsmaterialstock.AreaCode,
                        AreaName = wmsmaterialstock.AreaName,

                        // çŠ¶æ€ä¿¡æ¯
                        IsLock = wmsmaterialstock.IsLock,
                        InStockTime = wmsmaterialstock.InStockTime,
                    };

                    wmsmaterialstockCreateDtos.Add((wmsmaterialstock.RowIndex, wmsmaterialstockCreateDto));
                }
            }
        }

        // æ–°å¢ž
        foreach (var wmsmaterialstockDto in wmsmaterialstockCreateDtos)
        {
            try
            {
                await CreateAsync(wmsmaterialstockDto.Item);
            }
            catch (Exception e)
            {
                var errorMsg = $"导入失败！配置，第{wmsmaterialstockDto.RowIndex}行：{e.Message}，终止导入";
                throw new UserFriendlyException(errorMsg);
            }
        }

        // æ›´æ–°
        foreach (var wmsmaterialstockDto in wmsmaterialstockUpdateDtos)
        {
            try
            {
                await UpdateAsync(wmsmaterialstockDto.Id, wmsmaterialstockDto.Item);
            }
            catch (Exception e)
            {
                var errorMsg = $"导入失败！配置，第{wmsmaterialstockDto.RowIndex}行：{e.Message}，终止导入";
                throw new UserFriendlyException(errorMsg);
            }
        }
    }

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

        if (input.Sorting.IsNullOrWhiteSpace())
        {
            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 result = ObjectMapper.Map<List<WmsMaterialStock>, List<WmsMaterialStockDto>>(list);

        var sheets = new Dictionary<string, object>
        {
            ["配置"] = ExportHelper.ConvertListToExportData(result),
        };

        var fileName = result.Count > 1 ? "WmsMaterialStock列表" : result.Count == 1 ? result.First()?.MaterialNo : "WmsMaterialStock模版";
        return (sheets, fileName);
    }

    /// <summary>
    /// Checks the create or update dto asynchronous.
    /// </summary>
    /// <param name="input">The input.</param>
    protected Task CheckCreateOrUpdateDtoAsync(WmsMaterialStockCreateOrUpdateDtoBase input)
    {
        Check.NotNull(input, nameof(input));
        Check.NotNullOrWhiteSpace(input.MaterialNo, "编号", WmsMaterialStockConsts.MaxCodeLength);
        Check.NotNullOrWhiteSpace(input.MaterialName, "名称", WmsMaterialStockConsts.MaxNameLength);
        Check.Length(input.Remark, "备注", WmsMaterialStockConsts.MaxRemarkLength);
        return Task.CompletedTask;
    }
}

 HIAWms/server/src/CMS.Plugin.HIAWms.Application/MapperProfiles/WmsMaterialStockAutoMapperProfile.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,28 @@
using AutoMapper;
using CMS.Plugin.HIAWms.Application.Contracts.Dtos.WmsMaterials;
using CMS.Plugin.HIAWms.Application.Contracts.Dtos.WmsMaterialStocks;
using CMS.Plugin.HIAWms.Domain.WmsMaterials;
using CMS.Plugin.HIAWms.Domain.WmsMaterialStocks;
using Volo.Abp.ObjectExtending;

namespace CMS.Plugin.HIAWms.Application.MapperProfiles;

/// <summary>
/// AutoMapper配置
/// </summary>
/// <seealso cref="AutoMapper.Profile" />
public class WmsMaterialStockAutoMapperProfile : Profile
{
    /// <summary>
    /// Initializes a new instance of the <see cref="WmsMaterialStockAutoMapperProfile"/> class.
    /// </summary>
    public WmsMaterialStockAutoMapperProfile()
    {
        /* You can configure your AutoMapper mapping configuration here.
         * Alternatively, you can split your mapping configurations
         * into multiple profile classes for a better organization. */
        CreateMap<WmsMaterialStock, WmsMaterialStockDto>(MemberList.None).MapExtraProperties(MappingPropertyDefinitionChecks.None);
        CreateMap<WmsMaterialStockCreateDto, WmsMaterialStock>(MemberList.None).MapExtraProperties(MappingPropertyDefinitionChecks.None);
        CreateMap<GetWmsMaterialStocksInput, WmsMaterialStock>(MemberList.None).MapExtraProperties(MappingPropertyDefinitionChecks.None);
    }
}

 HIAWms/server/src/CMS.Plugin.HIAWms.Domain.Shared/WmsMaterialStocks/WmsMaterialStockConsts.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,12 @@
namespace CMS.Plugin.HIAWms.Domain.Shared.WmsMaterialStocks;

/// <summary>
/// WmsMaterialStock常量定义
/// </summary>
public static class WmsMaterialStockConsts
{
    public const string CloneTag = "_副本";
    public static int MaxCodeLength { get; set; } = 64;
    public static int MaxNameLength { get; set; } = 64;
    public static int MaxRemarkLength { get; set; } = 256;
}

 HIAWms/server/src/CMS.Plugin.HIAWms.Domain.Shared/WmsMaterialStocks/WmsMaterialStockEto.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,22 @@
namespace CMS.Plugin.HIAWms.Domain.Shared.WmsMaterialStocks;

/// <summary>
/// WmsMaterialStock事件参数对象
/// </summary>
[Serializable]
public class WmsMaterialStockEto
{
    /// <summary>
    /// Initializes a new instance of the <see cref="WmsMaterialStockEto"/> class.
    /// </summary>
    /// <param name="name">The name.</param>
    public WmsMaterialStockEto(string name)
    {
        Name = name;
    }

    /// <summary>
    /// åç§°
    /// </summary>
    public string Name { get; }
}

 HIAWms/server/src/CMS.Plugin.HIAWms.Domain/EventHandlers/WmsMaterialStockEventHandler.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,17 @@
using CMS.Plugin.HIAWms.Domain.Shared.WmsMaterialStocks;
using Volo.Abp.DependencyInjection;
using Volo.Abp.EventBus.Distributed;

namespace CMS.Plugin.HIAWms.Domain.EventHandlers;

/// <summary>
/// WmsMaterialStock事件处理程序
/// </summary>
public class WmsMaterialStockEventHandler : IDistributedEventHandler<WmsMaterialStockEto>, ITransientDependency
{
    /// <inheritdoc />
    public Task HandleEventAsync(WmsMaterialStockEto eventData)
    {
        return Task.CompletedTask;
    }
}

 HIAWms/server/src/CMS.Plugin.HIAWms.Domain/WmsMaterialStocks/IWmsMaterialStockRepository.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,54 @@
using Volo.Abp.Domain.Repositories;
using Volo.Abp.Specifications;

namespace CMS.Plugin.HIAWms.Domain.WmsMaterialStocks;

/// <summary>
/// WmsMaterialStock仓储
/// </summary>
public interface IWmsMaterialStockRepository : IBasicRepository<WmsMaterialStock, Guid>
{
    /// <summary>
    /// Finds the by name asynchronous.
    /// </summary>
    /// <param name="name">The name.</param>
    /// <param name="cancellationToken">The cancellation token.</param>
    /// <returns></returns>
    Task<WmsMaterialStock> FindByNameAsync(string name, CancellationToken cancellationToken = default);

    /// <summary>
    /// Names the exist asynchronous.
    /// </summary>
    /// <param name="name">The name.</param>
    /// <param name="id">The identifier.</param>
    /// <returns></returns>
    Task<bool> NameExistAsync(string name, Guid? id = null);

    /// <summary>
    /// Gets the maximum sort asynchronous.
    /// </summary>
    /// <returns></returns>
    Task<int> GetMaxSortAsync();

    /// <summary>
    /// Gets the list asynchronous.
    /// </summary>
    /// <param name="sorting">The sorting.</param>
    /// <param name="maxResultCount">The maximum result count.</param>
    /// <param name="skipCount">The skip count.</param>
    /// <param name="filter">The filter.</param>
    /// <param name="specification">The specification.</param>
    /// <param name="includeDetails">if set to <c>true</c> [include details].</param>
    /// <param name="cancellationToken">The cancellation token.</param>
    /// <returns></returns>
    Task<List<WmsMaterialStock>> GetListAsync(WmsMaterialStock? stock, DateTime? startTime = null, DateTime? endTime = null, string sorting = null, int maxResultCount = int.MaxValue,  int skipCount = 0, string filter = null, Specification<WmsMaterialStock> specification = null, bool includeDetails = false, CancellationToken cancellationToken = default);

    /// <summary>
    /// Gets the count asynchronous.
    /// </summary>
    /// <param name="filter">The filter.</param>
    /// <param name="specification">The specification.</param>
    /// <param name="cancellationToken">The cancellation token.</param>
    /// <returns></returns>
    Task<long> GetCountAsync(WmsMaterialStock? stock, DateTime? startTime = null, DateTime? endTime = null, string filter = null, Specification<WmsMaterialStock> specification = null, CancellationToken cancellationToken = default);
}

 HIAWms/server/src/CMS.Plugin.HIAWms.Domain/WmsMaterialStocks/WmsMaterialStock.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,128 @@
using CMS.Plugin.HIAWms.Domain.Shared.Enums;
using CMS.Plugin.HIAWms.Domain.Shared.WmsMaterialStocks;
using Microsoft.EntityFrameworkCore.Metadata.Internal;
using Volo.Abp;
using Volo.Abp.Domain.Entities.Auditing;

namespace CMS.Plugin.HIAWms.Domain.WmsMaterialStocks
{
    /// <summary>
    /// WmsMaterialStock
    /// </summary>
    public class WmsMaterialStock : FullAuditedAggregateRoot<Guid>
    {
        /// <summary>
        /// ç‰©æ–™ç¼–号
        /// </summary>
        public virtual string MaterialId { get; set; }

        /// <summary>
        /// ç‰©æ–™åç§°
        /// </summary>
        public virtual string MaterialName { get; set; }

        /// <summary>
        /// å®¹å™¨ç¼–号
        /// </summary>
        public string ContainerNo { get; set; }

        /// <summary>
        /// å®¹å™¨çŠ¶æ€
        /// </summary>
        public ContainerStatusEnum ContainerStatus { get; set; }

        /// <summary>
        /// å®¹å™¨ç±»åž‹
        /// </summary>
        public ContainerTypeEnum ContainerType { get; set; }

        /// <summary>
        /// ç‰©æ–™ç¼–号
        /// </summary>
        public string MaterialNo { get; set; }

        /// <summary>
        /// åº“存数量
        /// </summary>
        public int StockNumber { get; set; }

        /// <summary>
        /// ç‰©æ–™æ‰¹æ¬¡
        /// </summary>
        public string MaterialBatch { get; set; }

        /// <summary>
        /// ä¾›åº”商编号
        /// </summary>
        public string SupplierCode { get; set; }

        /// <summary>
        /// åž‹å·
        /// </summary>
        public string MaterialModel { get; set; }

        /// <summary>
        /// åº“位编号
        /// </summary>
        public string PlaceNo { get; set; }

        /// <summary>
        /// åº“位状态
        /// </summary>
        public PlaceStatusEnum PlaceStatus { get; set; }

        /// <summary>
        /// åº“位类型编号
        /// </summary>
        public PlaceTypeEnum StorageTypeNo { get; set; }

        /// <summary>
        /// åŒºåŸŸç¼–号
        /// </summary>
        public string AreaCode { get; set; }

        /// <summary>
        /// åº“区名称
        /// </summary>
        public string AreaName { get; set; }

        /// <summary>
        /// æ˜¯å¦é”å®š
        /// </summary>
        public int IsLock { get; set; }

        /// <summary>
        /// æ˜¯å¦ç©ºæ‰˜
        /// </summary>
        public YesNoEnum EmptyContainer { get; protected set; }

        /// <summary>
        /// å…¥åº“时间
        /// </summary>
        public DateTime? InStockTime { get; set; }

        /// <summary>
        /// æŽ’序
        /// </summary>
        public virtual int Sort { get; set; }

        /// <summary>
        /// å¤‡æ³¨
        /// </summary>
        public virtual string Remark { get; set; }

        /// <summary>
        /// æ˜¯å¦ç¦ç”¨
        /// </summary>
        public virtual bool? IsDisabled { get; protected set; }

        /// <summary>
        /// Adjusts the sort.
        /// </summary>
        /// <param name="sort">The sort.</param>
        public void AdjustSort(int sort)
        {
            Sort = sort;
        }
    }
}

 HIAWms/server/src/CMS.Plugin.HIAWms.Domain/WmsMaterialStocks/WmsMaterialStockDataSeedContributor.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,79 @@
using Volo.Abp.Data;
using Volo.Abp.DependencyInjection;
using Volo.Abp.Guids;
using Volo.Abp.Uow;

namespace CMS.Plugin.HIAWms.Domain.WmsMaterialStocks
{
    /// <summary>
    /// WmsMaterialStock种子数据提供程序
    /// </summary>
    public class WmsMaterialStockDataSeedContributor : IDataSeedContributor, ITransientDependency
    {
        private readonly IUnitOfWorkManager _unitOfWorkManager;
        private readonly IWmsMaterialStockRepository _wmsmaterialstockRepository;
        private readonly IGuidGenerator _guidGenerator;

        /// <summary>
        /// Initializes a new instance of the <see cref="WmsMaterialStockDataSeedContributor"/> class.
        /// </summary>
        /// <param name="unitOfWorkManager">The unit of work manager.</param>
        /// <param name="guidGenerator">The unique identifier generator.</param>
        /// <param name="wmsmaterialstockRepository">The work section repository.</param>
        public WmsMaterialStockDataSeedContributor(IUnitOfWorkManager unitOfWorkManager,  IGuidGenerator guidGenerator, IWmsMaterialStockRepository wmsmaterialstockRepository)
        {
            _unitOfWorkManager = unitOfWorkManager;
            _wmsmaterialstockRepository = wmsmaterialstockRepository;
            _guidGenerator = guidGenerator;
        }

        /// <inheritdoc />
        public async Task SeedAsync(DataSeedContext context)
        {
            if (context.Properties.ContainsKey(CMSPluginDbProperties.ConnectionStringName) && context.Properties[CMSPluginDbProperties.ConnectionStringName]?.ToString() == CMSPluginDbProperties.ConnectionStringName)
            {
                try
                {
                    //using var unitofWork = _unitOfWorkManager.Begin(requiresNew: true);
                    //await unitofWork.SaveChangesAsync();
                }
                catch (Exception ex)
                {
                    Console.WriteLine(ex.Message);
                }
            }

            if (context.Properties.ContainsKey("SeedTestData") && context.Properties["SeedTestData"]?.ToString() == "SeedTestData")
            {
                try
                {
                    await SeedWmsMaterialStockDataAsync();
                }
                catch (Exception e)
                {
                    Console.WriteLine(e.Message);
                }
            }
        }

        /// <summary>
        /// Seeds the work section data asynchronous.
        /// </summary>
        private async Task SeedWmsMaterialStockDataAsync()
        {
            using var unitofWork = _unitOfWorkManager.Begin(requiresNew: true);
            if (await _wmsmaterialstockRepository.GetCountAsync() == 0)
            {
                var WmsMaterialStocks = new List<WmsMaterialStock>();
                for (int i = 1; i <= 80; i++)
                {
                    var wmsmaterialstock = new WmsMaterialStock(_guidGenerator.Create(), $"WmsMaterialStock_Code{i}", $"WmsMaterialStock_Name{i}", i, $"WmsMaterialStock_Remark{i}");
                    WmsMaterialStocks.Add(wmsmaterialstock);
                }

                await _wmsmaterialstockRepository.InsertManyAsync(WmsMaterialStocks);
                await unitofWork.SaveChangesAsync();
            }
        }
    }
}

 HIAWms/server/src/CMS.Plugin.HIAWms.Domain/WmsMaterialStocks/WmsMaterialStockSpecification.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,41 @@
using System.Linq.Expressions;

namespace CMS.Plugin.HIAWms.Domain.WmsMaterialStocks
{
    /// <summary>
    /// WmsMaterialStock规约
    /// </summary>
    public class WmsMaterialStockSpecification : Volo.Abp.Specifications.Specification<WmsMaterialStock>
    {
        private readonly string _materialName;

        /// <summary>
        /// Initializes a new instance of the <see cref="WmsMaterialStockSpecification"/> class.
        /// </summary>
        public WmsMaterialStockSpecification()
        {
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="WmsMaterialStockSpecification"/> class.
        /// </summary>
        /// <param name="materialName">The name.</param>
        public WmsMaterialStockSpecification(string materialName = null)
        {
            _materialName = materialName;
        }

        /// <inheritdoc />
        public override Expression<Func<WmsMaterialStock, bool>> ToExpression()
        {
            Expression<Func<WmsMaterialStock, bool>> expression = c => 1 == 1;

            if (_materialName != null)
            {
                expression = expression.And(c => c.MaterialNo == _materialName);
            }

            return expression;
        }
    }
}

 HIAWms/server/src/CMS.Plugin.HIAWms.EntityFrameworkCore/Extensions/CMSPluginEfCoreExtensions.WmsMaterialStock.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,141 @@
using CMS.Plugin.HIAWms.Domain;
using CMS.Plugin.HIAWms.Domain.WmsMaterialStocks;
using CMS.Plugin.HIAWms.Domain.Shared.WmsMaterialStocks;
using Microsoft.EntityFrameworkCore;
using Volo.Abp;
using Volo.Abp.EntityFrameworkCore.Modeling;

namespace CMS.Plugin.HIAWms.EntityFrameworkCore.Extensions;

/// <summary>
/// EfCore扩展
/// </summary>
public  static partial class CMSPluginEfCoreExtensions
{
    /// <summary>
    /// Includes the details.
    /// </summary>
    /// <param name="queryable">The queryable.</param>
    /// <param name="include">if set to <c>true</c> [include].</param>
    /// <returns></returns>
    public static IQueryable<WmsMaterialStock> IncludeDetails(this IQueryable<WmsMaterialStock> queryable, bool include = true)
    {
        if (!include)
        {
            return queryable;
        }

        return queryable;
    }

    /// <summary>
    /// Configures the wmsmaterialstock.
    /// </summary>
    /// <param name="builder">The builder.</param>
    public static void ConfigureWmsMaterialStock(this ModelBuilder builder)
    {
        Check.NotNull(builder, nameof(builder));

        builder.Entity<WmsMaterialStock>(b =>
        {
            // é…ç½®è¡¨å’Œæž¶æž„名称
            b.ToTable((CMSPluginDbProperties.DbTablePrefix + "_WmsMaterialStocks").ToLower(),
                      CMSPluginDbProperties.DbSchema)
             .HasComment("WMS物料库存表");

            b.ConfigureByConvention();

            // ä¸»é”®é…ç½®
            b.HasKey(x => x.Id);

            // å±žæ€§é…ç½®
            b.Property(x => x.MaterialId)
                .HasMaxLength(64)
                .IsRequired()
                .HasComment("物料ID");

            b.Property(x => x.MaterialName)
                .HasMaxLength(128)
                .IsRequired()
                .HasComment("物料名称");

            b.Property(x => x.ContainerNo)
                .HasMaxLength(64)
                .HasComment("容器编号");

            b.Property(x => x.ContainerStatus)
                .HasComment("容器状态");

            b.Property(x => x.ContainerType)
                .HasComment("容器类型");

            b.Property(x => x.MaterialNo)
                .HasMaxLength(64)
                .IsRequired()
                .HasComment("物料编号");

            b.Property(x => x.StockNumber)
                .HasComment("库存数量");

            b.Property(x => x.MaterialBatch)
                .HasMaxLength(64)
                .HasComment("物料批次");

            b.Property(x => x.SupplierCode)
                .HasMaxLength(64)
                .HasComment("供应商编号");

            b.Property(x => x.MaterialModel)
                .HasMaxLength(128)
                .HasComment("机型/规格");

            b.Property(x => x.PlaceNo)
                .HasMaxLength(64)
                .HasComment("库位编号");

            b.Property(x => x.PlaceStatus)
                .HasComment("库位状态;");

            b.Property(x => x.StorageTypeNo)
                .HasComment("库位类型");

            b.Property(x => x.AreaCode)
                .HasMaxLength(64)
                .HasComment("区域编号");

            b.Property(x => x.AreaName)
                .HasMaxLength(128)
                .HasComment("库区名称");

            b.Property(x => x.IsLock)
                .HasComment("是否锁定(2:未锁定,1:已锁定)");
            b.Property(x => x.EmptyContainer)
                .HasComment("是否空托(2:否,1:是)");

            b.Property(x => x.InStockTime)
                .HasComment("入库时间");

            b.Property(x => x.Sort)
                .HasDefaultValue(0)
                .HasComment("排序");

            b.Property(x => x.Remark)
                .HasMaxLength(500)
                .HasComment("备注");

            b.Property(x => x.IsDisabled)
                .HasComment("是否禁用");

            // ç´¢å¼•é…ç½®
            b.HasIndex(x => x.MaterialNo).IsUnique();
            b.HasIndex(x => x.MaterialName);
            b.HasIndex(x => x.ContainerNo);
            b.HasIndex(x => x.PlaceNo);
            b.HasIndex(x => x.AreaCode);
            b.HasIndex(x => new { x.MaterialBatch, x.SupplierCode });

            // æ‰©å±•å±žæ€§é…ç½®
            b.ApplyObjectExtensionMappings();
        });
    }
}

 HIAWms/server/src/CMS.Plugin.HIAWms.EntityFrameworkCore/Repositories/EfCoreWmsMaterialStockRepository.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,119 @@
using System.Linq.Dynamic.Core;
using CMS.Plugin.HIAWms.Domain.WmsMaterialStocks;
using CMS.Plugin.HIAWms.EntityFrameworkCore.Extensions;
using Microsoft.EntityFrameworkCore;
using Volo.Abp.Domain.Repositories.EntityFrameworkCore;
using Volo.Abp.EntityFrameworkCore;
using Volo.Abp.Specifications;

namespace CMS.Plugin.HIAWms.EntityFrameworkCore.Repositories;

/// <inheritdoc />
public class EfCoreWmsMaterialStockRepository : EfCoreRepository<ICMSPluginDbContext, WmsMaterialStock, Guid>, IWmsMaterialStockRepository
{
    /// <summary>
    /// Initializes a new instance of the <see cref="EfCoreWmsMaterialStockRepository"/> class.
    /// </summary>
    /// <param name="dbContextProvider">The database context provider.</param>
    public EfCoreWmsMaterialStockRepository(IDbContextProvider<ICMSPluginDbContext> dbContextProvider)
        : base(dbContextProvider)
    {
    }

    /// <inheritdoc />
    public virtual async Task<WmsMaterialStock> FindByNameAsync(string materialNo, CancellationToken cancellationToken = default)
    {
        return await (await GetDbSetAsync())
            .IncludeDetails()
            .OrderBy(t => t.Sort)
            .FirstOrDefaultAsync(t => t.MaterialNo == materialNo, GetCancellationToken(cancellationToken));
    }

    /// <inheritdoc />
    public async Task<bool> NameExistAsync(string materialNo, Guid? id = null)
    {
        return await (await GetDbSetAsync()).WhereIf(id.HasValue, p => p.Id != id).AnyAsync(x => x.MaterialNo == materialNo);
    }

    /// <inheritdoc />
    public async Task<int> GetMaxSortAsync()
    {
        var hasAny = await (await GetQueryableAsync()).AnyAsync();
        if (!hasAny)
        {
            return 1;
        }

        var sort = await (await GetQueryableAsync()).MaxAsync(x => x.Sort);
        return sort + 1;
    }

    /// <inheritdoc />
    public async Task<List<WmsMaterialStock>> GetListAsync(WmsMaterialStock? stock, DateTime? startTime = null, DateTime? endTime = null, string sorting = null, int maxResultCount = int.MaxValue, int skipCount = 0, string filter = null, Specification<WmsMaterialStock> specification = null, bool includeDetails = false, CancellationToken cancellationToken = default)
    {
        specification ??= new WmsMaterialStockSpecification();
        return await (await GetDbSetAsync())
        .IncludeDetails(includeDetails)
        .WhereIf(!filter.IsNullOrWhiteSpace(),
            u => u.MaterialNo.Contains(filter) ||
                 u.MaterialName.Contains(filter) ||
                 u.MaterialBatch.Contains(filter) ||
                 u.PlaceNo.Contains(filter) ||
                 u.AreaName.Contains(filter))
        .WhereIf(!string.IsNullOrEmpty(stock?.MaterialNo), u => u.MaterialNo.Contains(stock.MaterialNo))
        .WhereIf(!string.IsNullOrEmpty(stock?.MaterialName), u => u.MaterialName.Contains(stock.MaterialName))
        .WhereIf(!string.IsNullOrEmpty(stock?.ContainerNo), u => u.ContainerNo == stock.ContainerNo)
        .WhereIf(stock?.ContainerStatus > 0, u => u.ContainerStatus == stock.ContainerStatus)
        .WhereIf(stock?.ContainerType > 0, u => u.ContainerType == stock.ContainerType)
        .WhereIf(!string.IsNullOrEmpty(stock?.MaterialBatch), u => u.MaterialBatch == stock.MaterialBatch)
        .WhereIf(!string.IsNullOrEmpty(stock?.SupplierCode), u => u.SupplierCode == stock.SupplierCode)
        .WhereIf(!string.IsNullOrEmpty(stock?.MaterialModel), u => u.MaterialModel.Contains(stock.MaterialModel))
        .WhereIf(!string.IsNullOrEmpty(stock?.PlaceNo), u => u.PlaceNo == stock.PlaceNo)
        .WhereIf(stock.PlaceStatus > 0, u => u.PlaceStatus == stock.PlaceStatus)
        .WhereIf(stock?.StorageTypeNo > 0, u => u.StorageTypeNo == stock.StorageTypeNo)
        .WhereIf(!string.IsNullOrEmpty(stock?.AreaCode), u => u.AreaCode == stock.AreaCode)
        .WhereIf(!string.IsNullOrEmpty(stock?.AreaName), u => u.AreaName.Contains(stock.AreaName))
        .WhereIf(stock.IsLock > 0, u => u.IsLock == stock.IsLock)
        .WhereIf(startTime.HasValue, u => u.InStockTime >= startTime.Value)
        .WhereIf(endTime.HasValue, u => u.InStockTime <= endTime.Value)
        .OrderBy(sorting.IsNullOrEmpty() ? nameof(WmsMaterialStock.Sort) : sorting)
        .PageBy(skipCount, maxResultCount)
        .ToListAsync(GetCancellationToken(cancellationToken));
    }

    /// <inheritdoc />
    public async Task<long> GetCountAsync(WmsMaterialStock? stock, DateTime? startTime = null, DateTime? endTime = null, string filter = null, Specification<WmsMaterialStock> specification = null, CancellationToken cancellationToken = default)
    {
        specification ??= new WmsMaterialStockSpecification();
        return await (await GetQueryableAsync())
            .WhereIf(!filter.IsNullOrWhiteSpace(),
            u => u.MaterialNo.Contains(filter) ||
                 u.MaterialName.Contains(filter) ||
                 u.MaterialBatch.Contains(filter) ||
                 u.PlaceNo.Contains(filter) ||
                 u.AreaName.Contains(filter))
            .WhereIf(!string.IsNullOrEmpty(stock?.MaterialNo), u => u.MaterialNo.Contains(stock.MaterialNo))
            .WhereIf(!string.IsNullOrEmpty(stock?.MaterialName), u => u.MaterialName.Contains(stock.MaterialName))
            .WhereIf(!string.IsNullOrEmpty(stock?.ContainerNo), u => u.ContainerNo == stock.ContainerNo)
            .WhereIf(stock?.ContainerStatus > 0, u => u.ContainerStatus == stock.ContainerStatus)
            .WhereIf(stock?.ContainerType > 0, u => u.ContainerType == stock.ContainerType)
            .WhereIf(!string.IsNullOrEmpty(stock?.MaterialBatch), u => u.MaterialBatch == stock.MaterialBatch)
            .WhereIf(!string.IsNullOrEmpty(stock?.SupplierCode), u => u.SupplierCode == stock.SupplierCode)
            .WhereIf(!string.IsNullOrEmpty(stock?.MaterialModel), u => u.MaterialModel.Contains(stock.MaterialModel))
            .WhereIf(!string.IsNullOrEmpty(stock?.PlaceNo), u => u.PlaceNo == stock.PlaceNo)
            .WhereIf(stock.PlaceStatus > 0, u => u.PlaceStatus == stock.PlaceStatus)
            .WhereIf(stock?.StorageTypeNo > 0, u => u.StorageTypeNo == stock.StorageTypeNo)
            .WhereIf(!string.IsNullOrEmpty(stock?.AreaCode), u => u.AreaCode == stock.AreaCode)
            .WhereIf(!string.IsNullOrEmpty(stock?.AreaName), u => u.AreaName.Contains(stock.AreaName))
            .WhereIf(stock.IsLock > 0, u => u.IsLock == stock.IsLock)
            .WhereIf(startTime.HasValue, u => u.InStockTime >= startTime.Value)
            .WhereIf(endTime.HasValue, u => u.InStockTime <= endTime.Value)
            .CountAsync(cancellationToken: GetCancellationToken(cancellationToken));
    }

    /// <inheritdoc />
    public override async Task<IQueryable<WmsMaterialStock>> WithDetailsAsync()
    {
        return (await GetQueryableAsync()).IncludeDetails();
    }
}

 HIAWms/server/src/CMS.Plugin.HIAWms.MySQL/CMSPluginDbContext.cs

@@ -37,6 +37,7 @@
        builder.ConfigureWmsArea();
        builder.ConfigureWmsPlace();
        builder.ConfigureWmsMaterial();
        builder.ConfigureWmsMaterialStock();

        /* Configure your own tables/entities inside here */


 HIAWms/server/src/CMS.Plugin.HIAWms.PostgreSql/CMSPluginDbContext.cs

@@ -37,6 +37,7 @@
        builder.ConfigureWmsArea();
        builder.ConfigureWmsPlace();
        builder.ConfigureWmsMaterial();
        builder.ConfigureWmsMaterialStock();
        /* Configure your own tables/entities inside here */

        //builder.Entity<YourEntity>(b =>

 HIAWms/server/src/CMS.Plugin.HIAWms.SqlServer/CMSPluginDbContext.cs

@@ -37,6 +37,7 @@
        builder.ConfigureWmsArea();
        builder.ConfigureWmsPlace();
        builder.ConfigureWmsMaterial();
        builder.ConfigureWmsMaterialStock();

        /* Configure your own tables/entities inside here */


 HIAWms/server/src/CMS.Plugin.HIAWms/Controller/WmsMaterialStockController.cs

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,187 @@
using Ao.Lang;
using CMS.Extensions.Abp.AspNetCore.Mvc.Filters;
using CMS.Plugin.HIAWms.Application.Contracts.Dtos.WmsMaterialStocks;
using CMS.Plugin.HIAWms.Application.Contracts.Services;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using MiniExcelLibs;
using System.Reflection;
using Volo.Abp;
using Volo.Abp.Application.Dtos;

namespace CMS.Plugin.HIAWms.Controller
{
    /// <summary>
    /// WmsMaterialStock服务
    /// </summary>
    [ApiController]
    [TypeFilter(typeof(CMSLanguageFilter))]
    [TypeFilter(typeof(CMSUowActionFilter))]
    [TypeFilter(typeof(CMSAuditActionFilter))]
    [TypeFilter(typeof(CMSExceptionFilter))]
    [Route("api/v{version:apiVersion}/HIAWms/[controller]")]
    public class WmsMaterialStockController : ControllerBase
    {
        private readonly IWmsMaterialStockAppService _wmsmaterialstockAppService;

        /// <summary>
        /// Initializes a new instance of the <see cref="WmsMaterialStockController"/> class.
        /// </summary>
        /// <param name="wmsmaterialstockAppService">The wmsmaterialstock application service.</param>
        public WmsMaterialStockController(IWmsMaterialStockAppService wmsmaterialstockAppService)
        {
            _wmsmaterialstockAppService = wmsmaterialstockAppService;
        }

        /// <summary>
        /// èŽ·å–wmsmaterialstock.
        /// </summary>
        /// <param name="id">标识符.</param>
        /// <returns></returns>
        [HttpGet]
        [Route("{id}")]
        public virtual Task<WmsMaterialStockDto> GetAsync(Guid id)
        {
            return _wmsmaterialstockAppService.GetAsync(id);
        }

        /// <summary>
        /// èŽ·å–wmsmaterialstock的列表.
        /// </summary>
        /// <param name="input">输入.</param>
        /// <returns></returns>
        [HttpGet]
        public virtual Task<PagedResultDto<WmsMaterialStockDto>> GetListAsync([FromQuery] GetWmsMaterialStocksInput input)
        {
            return _wmsmaterialstockAppService.GetListAsync(input);
        }

        /// <summary>
        /// åˆ›å»ºwmsmaterialstock.
        /// </summary>
        /// <param name="input">输入.</param>
        /// <returns></returns>
        //[Authorize]
        [HttpPost]
        public virtual Task<WmsMaterialStockDto> CreateAsync(WmsMaterialStockCreateDto input)
        {
            return _wmsmaterialstockAppService.CreateAsync(input);
        }

        /// <summary>
        /// æ›´æ–°wmsmaterialstock.
        /// </summary>
        /// <param name="id">标识符.</param>
        /// <param name="input">输入.</param>
        /// <returns></returns>
        //[Authorize]
        [HttpPut]
        [Route("{id}")]
        public virtual Task<WmsMaterialStockDto> UpdateAsync(Guid id, WmsMaterialStockUpdateDto input)
        {
            return _wmsmaterialstockAppService.UpdateAsync(id, input);
        }

        /// <summary>
        /// å…‹éš†WmsMaterialStock.
        /// </summary>
        /// <param name="ids">Id集合.</param>
        /// <returns></returns>
        //[Authorize]
        [HttpPost]
        [Route("Clone")]
        public virtual Task<List<WmsMaterialStockDto>> CloneAsync([FromBody] IEnumerable<Guid> ids)
        {
            return _wmsmaterialstockAppService.CloneAsync(ids);
        }

        /// <summary>
        /// åˆ é™¤wmsmaterialstock.
        /// </summary>
        /// <param name="id">标识符.</param>
        /// <returns></returns>
        //[Authorize]
        [HttpDelete]
        [Route("{id}")]
        public virtual Task DeleteAsync(Guid id)
        {
            return _wmsmaterialstockAppService.DeleteAsync(id);
        }

        /// <summary>
        /// æ‰¹é‡åˆ é™¤wmsmaterialstock.
        /// </summary>
        /// <param name="ids">The ids.</param>
        /// <returns></returns>
        //[Authorize]
        [HttpDelete]
        public virtual Task DeleteAsync([FromBody] IEnumerable<Guid> ids)
        {
            return _wmsmaterialstockAppService.DeleteManyAsync(ids);
        }

        /// <summary>
        /// è°ƒæ•´æŽ’序.
        /// </summary>
        /// <param name="id">标识符.</param>
        /// <returns></returns>
        [HttpPut]
        [Route("{id}/AdjustSort/{sort}")]
        public virtual Task AdjustSortAsync(Guid id, int sort)
        {
            return _wmsmaterialstockAppService.AdjustSortAsync(id, sort);
        }

        /// <summary>
        /// å¯¼å…¥wmsmaterialstock.
        /// </summary>
        /// <returns></returns>
        [Authorize]
        [HttpPost]
        [Route("Import")]
        public virtual async Task<IActionResult> ImportAsync(IFormFile file)
        {
            using var stream = new MemoryStream();
            await file.CopyToAsync(stream);
            stream.Seek(0L, SeekOrigin.Begin);

            var sheetNames = stream.GetSheetNames();
            var wmsmaterialstockRows = sheetNames.Contains("配置") ? MiniExcel.Query<WmsMaterialStocksImportModel.WmsMaterialStockImportModel>(stream, sheetName: "配置").ToList() : new();

            if (!wmsmaterialstockRows.Any())
            {
                throw new UserFriendlyException("请检查导入的表格");
            }

            await _wmsmaterialstockAppService.ImportAsync(new WmsMaterialStocksImportModel
            {
                WmsMaterialStocks = wmsmaterialstockRows,
            });

            return Ok();
        }

        /// <summary>
        /// å¯¼å‡ºwmsmaterialstock.
        /// </summary>
        /// <returns></returns>
        [HttpGet]
        [Route("Export")]
        public virtual async Task<IActionResult> ExportAsync([FromQuery] GetWmsMaterialStocksInput input)
        {
            input.MaxResultCount = int.MaxValue;
            var exportData = await _wmsmaterialstockAppService.ExportAsync(input);
            var templatePath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, $"Resources/Templates/WmsMaterialStock导出模板.xlsx");
            if (!System.IO.File.Exists(templatePath))
            {
                templatePath = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location) ?? string.Empty, $"Resources/Templates/WmsMaterialStock导出模板.xlsx");
            }

            var memoryStream = new MemoryStream();
            await memoryStream.SaveAsByTemplateAsync(templatePath, exportData.Sheets);
            memoryStream.Seek(0L, SeekOrigin.Begin);
            return new FileStreamResult(memoryStream, "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet") { FileDownloadName = $"{exportData.FileName}_{DateTime.Now:yyyyMMddhhmmss}.xlsx" };
        }
    }
}

 HIAWms/server/src/CMS.Plugin.HIAWms/Resources/Templates/WmsMaterialStockµ¼³öÄ£°å.xlsx

Binary files differ