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.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 Volo.Abp.Uow;
|
|
namespace CMS.Plugin.HIAWms.Application.Implements;
|
|
/// <inheritdoc />
|
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,
|
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 />
|
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(GetWmsMaterialStockInput input)
|
{
|
Check.NotNull(input, nameof(input));
|
|
if (input.Sorting.IsNullOrWhiteSpace())
|
{
|
input.Sorting = nameof(WmsMaterialStock.Sort);
|
}
|
|
//动态构造查询条件
|
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 materialModel = await _wmsMaterialRepository.FindByModelAsync(input.MaterialModel);
|
if(materialModel == null)
|
{
|
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;
|
|
wmsmaterialstock.MaterialModel = material.MaterialModel;
|
wmsmaterialstock.MaterialBatch = input.MaterialBatch;
|
|
wmsmaterialstock.Sort = sort;
|
wmsmaterialstock.InStockTime = DateTime.Now;
|
|
var stockList = new List<WmsMaterialStock>();
|
var recordList = new List<WmsInOutStockRecord>();
|
for (int i = 0; i < input.StockNumber; i++)
|
{
|
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 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("物料信息不存在");
|
}
|
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("库位库区信息不存在");
|
}
|
|
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.MaterialName = material.MaterialName;
|
wmsmaterialstock.ContainerStatus = Domain.Shared.Enums.ContainerStatusEnum.KUWEI;
|
wmsmaterialstock.ContainerType = container.ContainerType;
|
|
wmsmaterialstock.PlaceStatus = Domain.Shared.Enums.PlaceStatusEnum.CUNHUO;
|
wmsmaterialstock.StorageTypeNo = place.StorageTypeNo;
|
wmsmaterialstock.AreaCode = place.AreaCode;
|
wmsmaterialstock.AreaName = area.AreaName;
|
|
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 />
|
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);
|
}
|
}
|
|
/// <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, "", 0, 999);
|
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(GetWmsMaterialStockInput input)
|
{
|
Check.NotNull(input, nameof(input));
|
|
if (input.Sorting.IsNullOrWhiteSpace())
|
{
|
input.Sorting = nameof(WmsMaterialStock.Sort);
|
}
|
|
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>
|
{
|
["配置"] = 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;
|
}
|
|
|
/// <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 isMultipleThrowException = false, CancellationToken cancellationToken = default)
|
{
|
return await _wmsmaterialstockRepository.GetSingleByFilterAsync(whereConditions, isMultipleThrowException);
|
}
|
|
/// <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));
|
}
|
}
|
