WZC2/be/DataExchange/Fawtyg/Win_in.Sfs.Wms.DataExchange.Fawtyg.TyrpAgent/Incoming/DictReader.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text.Json;
using System.Threading.Tasks;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.Logging;
using Win_in.Sfs.Shared.Domain.Shared;
using Win_in.Sfs.Wms.DataExchange.Domain;
using Win_in.Sfs.Wms.DataExchange.Domain.Fawtyg.Tyrp;
using Win_in.Sfs.Wms.DataExchange.Domain.Shared;
using Win_in.Sfs.Wms.DataExchange.Enums;
using Win_in.Sfs.Wms.DataExchange.WMS.Dict;

namespace Win_in.Sfs.Wms.DataExchange.Fawtyg.TyrpAgent.Incoming;

public class DictReader : IReader
{

    private readonly IDictManager _dictManager;
    private readonly IIncomingFromExternalManager _incomingFromExternalManager;
    private readonly ILogger<DictReader> _logger;
    private readonly IConfiguration _configuration;
    public DictReader(
        IDictManager dictManager
        , IIncomingFromExternalManager incomingFromExternalManager
        , ILogger<DictReader> logger
        , IConfiguration configuration
        )
    {
        _configuration = configuration;
        _dictManager = dictManager;
        _incomingFromExternalManager = incomingFromExternalManager;
        _logger = logger;
    }

    public virtual async Task<List<IncomingFromExternal>> ReadAsync()
    {
        //从ERP读取待处理part
        var toBeProcessedDict = await _dictManager.GetToBeProcessedListAsync().ConfigureAwait(false);
        if (!toBeProcessedDict.Any())
        {
            _logger.LogInformation("No Dicts");
            return new List<IncomingFromExternal>();
        }
        //part逐一转换为Dict
        var incomingDataList = BuildIncomingFromExternalFromScrapAsync(toBeProcessedDict);
        await _incomingFromExternalManager.CreateManyAsync(incomingDataList).ConfigureAwait(false);
        return incomingDataList;
    }
    private List<IncomingFromExternal> BuildIncomingFromExternalFromScrapAsync(List<bcmout> toBeProcessedDict)
    {
        var incomingDataList = new List<IncomingFromExternal>();
        foreach (var dict in toBeProcessedDict)
        {
            var incomingData = BuildIncomingFromExternal(dict);
            incomingData.SetEffectiveDate(DateTime.Now);
            incomingData.SetSuccess();
            try
            {
                var DictRequest = BuildDictRequestCreateInput(dict, incomingData.SourceDataGroupCode);
                incomingData.DestinationDataContent = JsonSerializer.Serialize(DictRequest);
            }
            catch (Exception ex)
            {
                incomingData.SetError(EnumExchangeDataErrorCode.Exception, ex.Message, ex.ToString());
            }
            incomingDataList.Add(incomingData);
        }
        return incomingDataList;
    }

    private IncomingFromExternal BuildIncomingFromExternal(bcmout dict)
    {
        var groupCode = "";
        if (dict.bcmout_code.StartsWith("220"))
        {
            groupCode = EnumDictType.ProjCapacityCode.ToString();
        }
        else if (dict.bcmout_code.StartsWith("201"))
        {
            groupCode = EnumDictType.AdjustmentReason.ToString();
        }
        else if (dict.bcmout_code.StartsWith("202"))
        {
            groupCode = EnumDictType.Reason.ToString();
        }
        var incomingData = new IncomingFromExternal()
        {

            DataType = EnumIncomingDataType.Dict.ToString(),
            DataAction = EnumExchangeDataAction.Add,
            SourceSystem = EnumSystemType.ERP.ToString(),
            SourceDataId = dict.bcmout_code,
            SourceDataGroupCode = groupCode,
            SourceDataDetailCode = dict.bcmout_code,
            SourceDataContent = JsonSerializer.Serialize(dict),
            WriteTime = DateTime.Now,
            Writer = nameof(TyrpIncomingBackgroundWorker),
            DestinationSystem = EnumSystemType.WMS.ToString(),
        };
        return incomingData;
    }

    private static DictExchangeDto BuildDictRequestCreateInput(bcmout dict, string groupCode)
    {
        var dictRequest = new DictExchangeDto();
        if (Enum.TryParse<EnumDictType>(groupCode, out EnumDictType outCode))
        {
            dictRequest.Code = outCode.ToString();
            dictRequest.Name = outCode.GetDisplayName();
            dictRequest.Description = outCode.GetDisplayName();
        }
        var dictItem = new DictItemExchangeDto()
        {
            Code = dict.bcmout_code,
            Name = dict.bcmout_desc,
            Description = dict.bcmout_desc,
        };
        dictRequest.Detail = dictItem;
        return dictRequest;
    }
}