出入库功能

zs

2025-05-11 3322dfd299755416176cd946265577e176cae795

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

@@ -1,13 +1,19 @@
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 CMS.Plugin.HIAWms.Domain.WmsAreas;
using CMS.Plugin.HIAWms.Domain.WmsContainers;
using CMS.Plugin.HIAWms.Domain.WmsMaterials;
using CMS.Plugin.HIAWms.Domain.WmsMaterialStocks;
using CMS.Plugin.HIAWms.Domain.WmsPlaces;
using CmsQueryExtensions;
using Microsoft.Extensions.DependencyInjection;
using System.Text.Json;
using Volo.Abp;
using Volo.Abp.Application.Dtos;
using Volo.Abp.Data;
using Volo.Abp.ObjectExtending;
using CMS.Plugin.HIAWms.Domain.Shared.Util;
using Volo.Abp.Uow;

namespace CMS.Plugin.HIAWms.Application.Implements;

@@ -15,14 +21,30 @@
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 IServiceProvider _serviceProvider;

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

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

        var exist = await _wmsmaterialstockRepository.NameExistAsync(input.MaterialNo);
        if (exist)
        //var exist = await _wmsmaterialstockRepository.NameExistAsync(input.MaterialNo);
        //if (exist)
        //{
        //    throw new UserFriendlyException(L[CMSPluginDomainErrorCodes.NameAlreadyExists, input.MaterialNo]);
        //}
        var material = await _wmsMaterialRepository.FindByNameAsync(input.MaterialNo);
        if (material == null)
        {
            throw new UserFriendlyException(L[CMSPluginDomainErrorCodes.NameAlreadyExists, input.MaterialNo]);
            throw new UserFriendlyException("物料信息不存在");
        }
        var container = await _wmscontainerRepository.FindByNameAsync(input.ContainerNo);
        //if (container == null)
        //{
        //    throw new UserFriendlyException("托盘信息不存在");
        //}

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

        wmsmaterialstock.ContainerStatus = Domain.Shared.Enums.ContainerStatusEnum.KUWEI;
        wmsmaterialstock.ContainerType = container == null ? Domain.Shared.Enums.ContainerTypeEnum.XUNI : container.ContainerType;
        wmsmaterialstock.StorageTypeNo = Domain.Shared.Enums.PlaceTypeEnum.XUNIKUWEI;
        wmsmaterialstock.PlaceStatus = Domain.Shared.Enums.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 = Domain.Shared.Enums.PlaceStatusEnum.CUNHUO;
            wmsmaterialstock.StorageTypeNo = place.StorageTypeNo;
            wmsmaterialstock.AreaCode = place.AreaCode;
            wmsmaterialstock.AreaName = area.AreaName;

            place.PlaceStatus = Domain.Shared.Enums.PlaceStatusEnum.CUNHUO;
            place.Islock = input.IsLock;

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

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

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

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

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

        await _wmsmaterialstockRepository.InsertManyAsync(stockList);

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

            await _wmscontainerRepository.UpdateAsync(container);
        }

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

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

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

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

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

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

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

        await _wmsmaterialstockRepository.UpdateManyAsync(wmsmaterialstockList);

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

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

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

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

    /// <inheritdoc />
@@ -164,6 +350,19 @@
        }
    }

    /// <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)
    {