WZC2/be/DataExchange/Fawtyg/Win_in.Sfs.Wms.DataExchange.Fawtyg.MesAgent/Outgoing/IssuesConverter.cs

using System.Collections.Generic;
using System.Text.Json;
using System.Threading.Tasks;
using Volo.Abp.ObjectMapping;
using Win_in.Sfs.Wms.DataExchange.Domain;
using Win_in.Sfs.Wms.DataExchange.Domain.Fawtyg.Mes;
using Win_in.Sfs.Wms.DataExchange.Domain.Shared;
using Win_in.Sfs.Wms.DataExchange.WMS.PCK;
using Win_in.Sfs.Wms.Store.Application.Contracts;

namespace Win_in.Sfs.Wms.DataExchange.Fawtyg.MesAgent.Outgoing;

public class IssuesConverter : IOutgoingConverter
{
    private readonly IOutgoingFromWmsManager _outgoingFromWmsManager;
    private readonly IOutgoingToExternalManager _outgoingToExternalManager;
    private readonly IObjectMapper _objectMapper;
    public IssuesConverter(
  IOutgoingFromWmsManager outgoingFromWmsManager
  , IOutgoingToExternalManager outgoingToExternalManager
  , ISupplierAsnAppService supplierAsnAppService
  , IObjectMapper objectMapper
)
    {
        _outgoingFromWmsManager = outgoingFromWmsManager;
        _outgoingToExternalManager = outgoingToExternalManager;
        _objectMapper = objectMapper;
    }
    public virtual async Task<List<OutgoingToExternal>> ConvertAsync()
    {
        var outgoingToExternalList = new List<OutgoingToExternal>();
        var outgoingFromWmsList = await _outgoingFromWmsManager.GetToBeProcessedListAsync(EnumOutgoingDataType.Issue, EnumSystemType.MES).ConfigureAwait(false);
        foreach (var outgoingFromWms in outgoingFromWmsList)
        {
            var wmsIssue = JsonSerializer.Deserialize<IssueNoteDTO>(outgoingFromWms.DataContent);
            foreach (var detail in wmsIssue.Details)
            {
                var outgoingToExternal = new OutgoingToExternal()
                {
                    DataType = outgoingFromWms.DataType,
                    DataAction = outgoingFromWms.DataAction,
                    SourceSystem = EnumSystemType.WMS.ToString(),
                    SourceDataId = detail.Id.ToString(),
                    SourceDataGroupCode = wmsIssue.Number,
                    SourceDataDetailCode = detail.ToPackingCode,
                    Writer = nameof(MesOutgoingBackgroundWorker),
                    DestinationSystem = EnumSystemType.MES.ToString(),
                    DestinationDataId = "",
                };
                outgoingToExternal.SetEffectiveDate(outgoingFromWms.EffectiveDate);

                var exchangeIssue = await BuildPurchaseReceiptExchangeDtoAsync(wmsIssue, detail).ConfigureAwait(false);
                outgoingToExternal.SourceDataContent = JsonSerializer.Serialize(exchangeIssue);
                var arrive = BuildIssue(exchangeIssue);
                outgoingToExternal.DestinationDataContent = JsonSerializer.Serialize(arrive);

                outgoingToExternalList.Add(outgoingToExternal);
            }
        }
        await _outgoingToExternalManager.CreateManyAsync(outgoingToExternalList).ConfigureAwait(false);
        return outgoingToExternalList;
    }

    private static IssueNote BuildIssue(IssueNoteExchangeDto exchangeIssue)
    {
        var detail = exchangeIssue.Detail;
        var issue = new IssueNote()
        {
            DeliverNumber = exchangeIssue.Number,
            ItemCode = detail.ItemCode,
            Plant = detail.ToLocationErpCode,
            Qty_Qty = detail.Qty,
            PackingCode = detail.FromPackingCode,
            IsReceive = 0.ToString(),
            WmsState = 0
        };
        return issue;
    }

    private async Task<IssueNoteExchangeDto> BuildPurchaseReceiptExchangeDtoAsync(IssueNoteDTO wmsIssue, IssueNoteDetailDTO wmsIssueDetail)
    {
        await Task.CompletedTask.ConfigureAwait(false);
        var exchangeIssue = _objectMapper.Map<IssueNoteDTO, IssueNoteExchangeDto>(wmsIssue);
        var exchangeIssueDetail = _objectMapper.Map<IssueNoteDetailDTO, IssueNoteDetailExchangeDto>(wmsIssueDetail);
        exchangeIssue.Detail = exchangeIssueDetail;
        return exchangeIssue;
    }
}