MES 耗用单接口

be/DataExchange/Fawtyg/Win_in.Sfs.Wms.DataExchange.Domain.Fawtyg.Mes/Backflus/Backflu.cs

@@ -0,0 +1,56 @@
+using Volo.Abp.Domain.Entities;
+
+namespace Win_in.Sfs.Wms.DataExchange.Domain.Fawtyg.Mes;
+public class Backflu : Entity
+{
+
+    /// <summary>
+    /// MES写入时间
+    /// </summary>
+    public string scmout_dt_w { get; set; }
+    /// <summary>
+    /// 单据类型
+    /// </summary>
+    public string scmout_type { get; set; }
+    /// <summary>
+    /// TYRP单号
+    /// </summary>
+    public string scmout_nbr { get; set; }
+    /// <summary>
+    /// 料号
+    /// </summary>
+    public string scmout_part { get; set; }
+    /// <summary>
+    /// 追加码/预定交货日/序号/储位
+    /// </summary>
+    public string scmout_no { get; set; }
+    /// <summary>
+    /// TYRP异动储位
+    /// </summary>
+    public string scmout_loc { get; set; }
+    /// <summary>
+    /// 库存交易年月
+    /// </summary>
+    public string scmout_ym { get; set; }
+    /// <summary>
+    /// 库存交易日
+    /// </summary>
+    public string scmout_date { get; set; }
+    /// <summary>
+    /// 数量
+    /// </summary>
+    public decimal scmout_qty { get; set; }
+    /// <summary>
+    /// 调入储位
+    /// </summary>
+    public string scmout_in_loc { get; set; }
+    /// <summary>
+    /// 有效码
+    /// </summary>
+    public string scmout_stat { get; set; }
+
+    public override object[] GetKeys()
+    {
+        return new object[] { scmout_type + scmout_nbr + scmout_part + scmout_no };
+    }
+}

be/DataExchange/Fawtyg/Win_in.Sfs.Wms.DataExchange.Domain.Fawtyg.Mes/Backflus/BackfluManager.cs

@@ -0,0 +1,29 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using Volo.Abp.Domain.Services;
+
+namespace Win_in.Sfs.Wms.DataExchange.Domain.Fawtyg.Mes;
+public class BackfluManager : DomainService, IBackfluManager
+{
+    private readonly IBackfluLinq2DbRepository _repository;
+    public BackfluManager(IBackfluLinq2DbRepository repository)
+    {
+        _repository = repository;
+    }
+
+    public async Task<List<scmout>> GetToBeProcessedListAsync()
+    {
+        var Backflu = await _repository.GetListAsync().ConfigureAwait(false);
+
+        return Backflu.ToList();
+    }
+    public virtual async Task UpdateProcessedListAsync(List<scmout> entities)
+    {
+        foreach (var entitie in entities)
+        {
+            entitie.scmout_stat = "N";
+            await _repository.UpdateAsync(entitie).ConfigureAwait(false);
+        }
+    }
+}

be/DataExchange/Fawtyg/Win_in.Sfs.Wms.DataExchange.Domain.Fawtyg.Mes/Backflus/IBackfluManager.cs

@@ -0,0 +1,10 @@
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using Volo.Abp.Domain.Services;
+
+namespace Win_in.Sfs.Wms.DataExchange.Domain.Fawtyg.Mes;
+public interface IBackfluManager : IDomainService
+{
+    Task<List<Backflu>> GetToBeProcessedListAsync();
+    Task UpdateProcessedListAsync(List<Backflu> entities);
+}

be/DataExchange/Fawtyg/Win_in.Sfs.Wms.DataExchange.Domain.Fawtyg.Mes/Backflus/IBackfluRepository.cs

@@ -0,0 +1,7 @@
+using Volo.Abp.Domain.Repositories;
+
+namespace Win_in.Sfs.Wms.DataExchange.Domain.Fawtyg.Mes;
+public interface IBackfluRepository : IRepository<Backflu>
+{
+
+}

be/DataExchange/Fawtyg/Win_in.Sfs.Wms.DataExchange.Domain.Fawtyg.Tyrp/Backflus/BackfluManager.cs

@@ -19,5 +19,12 @@ public class BackfluManager : DomainService, IBackfluManager
 
         return Backflu.ToList();
     }
-
+    public virtual async Task UpdateProcessedListAsync(List<scmout> entities)
+    {
+        foreach (var entitie in entities)
+        {
+            entitie.scmout_stat = "N";
+            await _repository.UpdateAsync(entitie).ConfigureAwait(false);
+        }
+    }
 }

be/DataExchange/Fawtyg/Win_in.Sfs.Wms.DataExchange.Domain.Fawtyg.Tyrp/Backflus/IBackfluManager.cs

@@ -7,5 +7,5 @@ namespace Win_in.Sfs.Wms.DataExchange.Domain.Fawtyg.Tyrp;
 public interface IBackfluManager : IDomainService
 {
     Task<List<scmout>> GetToBeProcessedListAsync();
-    //Task UpdateProcessedListAsync(List<scmout> entities);
+    Task UpdateProcessedListAsync(List<scmout> entities);
 }

be/DataExchange/Fawtyg/Win_in.Sfs.Wms.DataExchange.EntityFrameworkCore.Fawtyg.Mes/Backflus/BackflusDbContextModelCreatingExtensions.cs

@@ -0,0 +1,31 @@
+
+using Microsoft.EntityFrameworkCore;
+using Volo.Abp.EntityFrameworkCore.Modeling;
+using Win_in.Sfs.Wms.DataExchange.Domain.Fawtyg.Mes;
+
+namespace Win_in.Sfs.Wms.DataExchange.EntityFrameworkCore.Fawtyg.Mes;
+public static class BackfluDbContextModelCreatingExtensions
+{
+    public static void ConfigureBackflu(this ModelBuilder builder, MesModelBuilderConfigurationOptions options)
+    {
+        builder.Entity<Backflu>(b =>
+        {
+            //Configure table & schema Name
+            b.ToTable(options.TablePrefix + "scmout", options.Schema);
+            //Configure ABP properties
+            b.ConfigureByConvention();
+            b.Property(q => q.scmout_dt_w).HasMaxLength(20);
+            b.Property(q => q.scmout_type).HasMaxLength(6);
+            b.Property(q => q.scmout_nbr).HasMaxLength(12);
+            b.Property(q => q.scmout_part).HasMaxLength(20);
+            b.Property(q => q.scmout_no).HasMaxLength(10);
+            b.Property(q => q.scmout_loc).HasMaxLength(10);
+            b.Property(q => q.scmout_ym).HasMaxLength(6);
+            b.Property(q => q.scmout_date).HasMaxLength(8);
+            b.Property(q => q.scmout_qty).HasPrecision(10, 2);
+            b.Property(q => q.scmout_in_loc).HasMaxLength(10);
+            b.Property(q => q.scmout_stat).HasMaxLength(1);
+        });
+
+    }
+}

be/DataExchange/Fawtyg/Win_in.Sfs.Wms.DataExchange.EntityFrameworkCore.Fawtyg.Mes/Backflus/BackflusEfCoreRepository.cs

@@ -0,0 +1,12 @@
+using Volo.Abp.Domain.Repositories.EntityFrameworkCore;
+using Volo.Abp.EntityFrameworkCore;
+using Win_in.Sfs.Wms.DataExchange.Domain.Fawtyg.Mes;
+
+namespace Win_in.Sfs.Wms.DataExchange.EntityFrameworkCore.Fawtyg.Mes;
+public class BackfluEfCoreRepository : EfCoreRepository<MesDbContext, Backflu>, IBackfluRepository
+{
+    public BackfluEfCoreRepository(IDbContextProvider<MesDbContext> dbContextProvider)
+        : base(dbContextProvider)
+    {
+    }
+}

be/DataExchange/Fawtyg/Win_in.Sfs.Wms.DataExchange.EntityFrameworkCore.Fawtyg.Mes/DataExchangeDbContextModelCreatingExtensions.cs

@@ -26,6 +26,6 @@ public static class DataExchangeDbContextModelCreatingExtensions
         builder.ConfigurePullTask(options);
         builder.ConfigureScrap(options);
         builder.ConfigurePck(options);
-
+        builder.ConfigureBackflu(options);
     }
 }

be/DataExchange/Fawtyg/Win_in.Sfs.Wms.DataExchange.EntityFrameworkCore.Fawtyg.Mes/DataExchangeEntityFrameworkCoreFawtygModule.cs

@@ -31,5 +31,6 @@ public class DataExchangeEntityFrameworkCoreFawtygModule : AbpModule
         context.Services.AddTransient<IPullTaskRepository, PullTaskEfCoreRepository>();
         context.Services.AddTransient<IScrapRepository, ScrapEfCoreRepository>();
         context.Services.AddTransient<IIssueRepository, IssueEfCoreRepository>();
+        context.Services.AddTransient<IBackfluRepository, BackfluEfCoreRepository>();
     }
 }

be/DataExchange/Fawtyg/Win_in.Sfs.Wms.DataExchange.EntityFrameworkCore.Fawtyg.Mes/IMesDbContext.cs

@@ -19,4 +19,5 @@ public interface IMesDbContext : IEfCoreDbContext
 
     DbSet<MesOut> MesOuts { get; }
     DbSet<PullTask> PullTasks { get; }
+    DbSet<Backflu> Backflu { get; }
 }

be/DataExchange/Fawtyg/Win_in.Sfs.Wms.DataExchange.EntityFrameworkCore.Fawtyg.Mes/MesDbContext.cs

@@ -20,6 +20,7 @@ public class MesDbContext :
 
     public virtual DbSet<PullTask> PullTasks { get; }
     public virtual DbSet<IssueNote> Issue { get; }
+    public virtual DbSet<Backflu> Backflu { get; }
 
     public MesDbContext(DbContextOptions<MesDbContext> options)
         : base(options)

be/DataExchange/Fawtyg/Win_in.Sfs.Wms.DataExchange.Fawtyg.MesAgent/Incoming/BackFluConverter.cs

@@ -0,0 +1,83 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Text.Json;
+using System.Threading.Tasks;
+using Microsoft.Extensions.Logging;
+using Volo.Abp.ObjectMapping;
+using Win_in.Sfs.Basedata.Application.Contracts;
+using Win_in.Sfs.Wms.DataExchange.Domain;
+using Win_in.Sfs.Wms.DataExchange.WMS.BackFlushNote;
+using Win_in.Sfs.Wms.Store.Application.Contracts;
+
+namespace Win_in.Sfs.Wms.DataExchange.Fawtyg.MesAgent.Incoming;
+
+public class BackFluConverter : IIncomingConverter
+{
+    private readonly IIncomingFromExternalManager _incomingFromExternalManager;
+    private readonly IIncomingToWmsManager _incomingToWmsManager;
+    private readonly IItemBasicAppService _itemBasicAppService;
+    private readonly IObjectMapper _objectMapper;
+    private readonly ILogger<BackFluConverter> _logger;
+    public BackFluConverter(
+    IIncomingToWmsManager incomingToWmsManager,
+    IItemBasicAppService itemBasicAppService,
+    IObjectMapper objectMapper,
+    ILogger<BackFluConverter> logger
+,
+    IIncomingFromExternalManager incomingFromExternalManager
+
+)
+    {
+        _incomingToWmsManager = incomingToWmsManager;
+        _itemBasicAppService = itemBasicAppService;
+        _objectMapper = objectMapper;
+        _logger = logger;
+        _incomingFromExternalManager = incomingFromExternalManager;
+    }
+    public virtual async Task ConvertAsync(List<IncomingFromExternal> incomingFromExternalList)
+    {
+        if (!incomingFromExternalList.Any())
+        {
+            _logger.LogInformation("no backflus");
+            return;
+        }
+        var incomingToWmsDataList = await BuildIncomingToWmsOfPurchaseOrderAsync(incomingFromExternalList).ConfigureAwait(false);
+        await _incomingToWmsManager.CreateManyAsync(incomingToWmsDataList).ConfigureAwait(false);
+        //归档
+        await _incomingFromExternalManager.ArchiveBulkAsync(incomingFromExternalList).ConfigureAwait(false);
+
+    }
+
+    private async Task<List<IncomingToWms>> BuildIncomingToWmsOfPurchaseOrderAsync(List<IncomingFromExternal> incomingDataList)
+    {
+        await Task.CompletedTask.ConfigureAwait(false);
+        var incomingToWmsList = new List<IncomingToWms>();
+        var groups = incomingDataList.GroupBy(p => p.SourceDataGroupCode);
+        foreach (var group in groups)
+        {
+            var first = group.First();
+            var incomingToWms = new IncomingToWms()
+            {
+                DataType = first.DataType,
+                DataAction = first.DataAction,
+                SourceSystem = first.SourceSystem,
+                DataIdentityCode = first.SourceDataGroupCode,
+            };
+            incomingToWms.SetEffectiveDate(first.EffectiveDate);
+            var exchangeBack = JsonSerializer.Deserialize<BackFlushNoteExchangeDto>(first.DestinationDataContent);
+            var wmsBack = _objectMapper.Map<BackFlushNoteExchangeDto, BackFlushNoteEditInput>(exchangeBack);
+            wmsBack.Details = new List<BackFlushNoteDetailInput>();
+            foreach (var incomingFromExternal in group.ToList())
+            {
+                var back = JsonSerializer.Deserialize<BackFlushNoteExchangeDto>(incomingFromExternal.DestinationDataContent);
+                var wmsBackDetail = _objectMapper.Map<BackFlushNoteDetailExchangeDto, BackFlushNoteDetailInput>(back.Detail);
+
+                wmsBack.Details.Add(wmsBackDetail);
+            }
+            incomingToWms.DataContent = JsonSerializer.Serialize(wmsBack);
+            incomingToWmsList.Add(incomingToWms);
+        }
+        return incomingToWmsList;
+    }
+
+}

be/DataExchange/Fawtyg/Win_in.Sfs.Wms.DataExchange.Fawtyg.MesAgent/Incoming/BackFluReader.cs

@@ -0,0 +1,112 @@
+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.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.BackFlushNote;
+
+namespace Win_in.Sfs.Wms.DataExchange.Fawtyg.MesAgent.Incoming;
+
+public class BackFluReader : IReader
+{
+    private readonly IBackfluManager _ibackfluManager;
+    private readonly IIncomingFromExternalManager _incomingFromExternalManager;
+    private readonly ILogger<BackFluReader> _logger;
+    private readonly IConfiguration _configuration;
+    public BackFluReader(
+        IBackfluManager ibackfuManager
+        , IIncomingFromExternalManager incomingFromExternalManager
+        , ILogger<BackFluReader> logger
+          , IConfiguration configuration
+        )
+    {
+        _ibackfluManager = ibackfuManager;
+        _incomingFromExternalManager = incomingFromExternalManager;
+        _logger = logger;
+        _configuration = configuration;
+    }
+    public virtual async Task<List<IncomingFromExternal>> ReadAsync()
+    {
+        //从Tyrp读取待处理bom
+        var BackFull = await _ibackfluManager.GetToBeProcessedListAsync().ConfigureAwait(false);
+        var toBeProcessedBack = BackFull.Where(p => p.scmout_stat == "Y").ToList();
+        if (!toBeProcessedBack.Any())
+        {
+            _logger.LogInformation("no backflus");
+            return new List<IncomingFromExternal>();
+        }
+        //bom逐一转换为bomNote
+        var incomingDataList = BuildIncomingFromExternalFromBomAsync(toBeProcessedBack);
+        await _incomingFromExternalManager.CreateManyAsync(incomingDataList).ConfigureAwait(false);
+        await _ibackfluManager.UpdateProcessedListAsync(toBeProcessedBack).ConfigureAwait(false);
+        return incomingDataList;
+    }
+    private List<IncomingFromExternal> BuildIncomingFromExternalFromBomAsync(List<Backflu> toBeProcessedIssue)
+    {
+        var incomingDataList = new List<IncomingFromExternal>();
+        foreach (var backflu in toBeProcessedIssue)
+        {
+            var incomingData = BuildIncomingFromExternal(backflu);
+
+            incomingData.SetEffectiveDate(DateTime.Now);
+
+            try
+            {
+                var bm = BuildScrapNoteOrderExchangeMes(backflu);
+                incomingData.DestinationDataContent = JsonSerializer.Serialize(backflu);
+            }
+            catch (Exception ex)
+            {
+                incomingData.SetError(EnumExchangeDataErrorCode.Exception, ex.Message, ex.ToString());
+            }
+
+            incomingDataList.Add(incomingData);
+
+        }
+        return incomingDataList;
+    }
+    private IncomingFromExternal BuildIncomingFromExternal(Backflu backflu)
+    {
+        var incomingData = new IncomingFromExternal()
+        {
+            DataType = EnumIncomingDataType.BackFlush.ToString(),
+            DataAction = EnumExchangeDataAction.Add,
+            SourceSystem = EnumSystemType.ERP.ToString(),
+            SourceDataId = backflu.scmout_type,
+            SourceDataGroupCode = backflu.scmout_nbr,
+            SourceDataDetailCode = backflu.scmout_part,
+            SourceDataContent = JsonSerializer.Serialize(backflu),
+            WriteTime = DateTime.Now,
+            Writer = nameof(MesIncomingBackgroundWorker),
+            DestinationSystem = EnumSystemType.ERP.ToString(),
+        };
+        return incomingData;
+    }
+
+    private static BackFlushNoteExchangeDto BuildScrapNoteOrderExchangeMes(Backflu backflu)
+    {
+
+        var back = new BackFlushNoteExchangeDto()
+        {
+
+            ActiveDate = Convert.ToDateTime(backflu.scmout_dt_w.Substring(0, 4) + "-" + backflu.scmout_dt_w.Substring(4, 2) + "-" + backflu.scmout_dt_w.Substring(6, 2)),
+            ItemCode = backflu.scmout_part,
+            Number = backflu.scmout_nbr
+        };
+        var bakcdetail = new BackFlushNoteDetailExchangeDto()
+        {
+            Number = backflu.scmout_nbr,
+            ItemCode = backflu.scmout_part,
+            Qty = backflu.scmout_qty,
+            LocationErpCode = backflu.scmout_loc
+        };
+        back.Detail = bakcdetail;
+        return back;
+    }
+}

be/DataExchange/Fawtyg/Win_in.Sfs.Wms.DataExchange.Fawtyg.MesAgent/Incoming/MesIncomingBackgroundWorker.cs

@@ -34,13 +34,13 @@ public class MesIncomingBackgroundWorker : AsyncPeriodicBackgroundWorkerBase
             Logger.LogInformation($"{Incoming} is not active!");
             return;
         }
-        Logger.LogInformation($"Read MesOut");//缴库
+        //Logger.LogInformation($"Read MesOut");//缴库
-        var mesOutReader = workerContext.ServiceProvider.GetRequiredService<MesOutReader>();
+        //var mesOutReader = workerContext.ServiceProvider.GetRequiredService<MesOutReader>();
-        var mesOutConverter = workerContext.ServiceProvider.GetRequiredService<MesOutConverter>();
+        //var mesOutConverter = workerContext.ServiceProvider.GetRequiredService<MesOutConverter>();
-        //读取并保存MesOut
+        ////读取并保存MesOut
-        var mesOutsFromExternalList = await mesOutReader.ReadAsync().ConfigureAwait(false);
+        //var mesOutsFromExternalList = await mesOutReader.ReadAsync().ConfigureAwait(false);
-        //转换MesOut
+        ////转换MesOut
-        await mesOutConverter.ConvertAsync(mesOutsFromExternalList).ConfigureAwait(false);
+        //await mesOutConverter.ConvertAsync(mesOutsFromExternalList).ConfigureAwait(false);
 
         Logger.LogInformation($"Read PullTask");//拉动任务
         var pullTaskReader = workerContext.ServiceProvider.GetRequiredService<PullTaskReader>();
@@ -66,6 +66,13 @@ public class MesIncomingBackgroundWorker : AsyncPeriodicBackgroundWorkerBase
         //转换Pck
         await pckConverter.ConvertAsync(pcksFromExternalList).ConfigureAwait(false);
 
+        Logger.LogInformation($"Read BackFlush");//耗用单
+        var BackFlushReader = workerContext.ServiceProvider.GetRequiredService<BackFluReader>();
+        var BackFlushConverter = workerContext.ServiceProvider.GetRequiredService<BackFluConverter>();
+        //读取并保存Customer
+        var backFlushsFromExternalList = await BackFlushReader.ReadAsync().ConfigureAwait(false);
+        //转换Customer
+        await BackFlushConverter.ConvertAsync(backFlushsFromExternalList).ConfigureAwait(false);
         Logger.LogInformation($"Completed: Handling {Incoming}");
     }
 

be/DataExchange/Fawtyg/Win_in.Sfs.Wms.DataExchange.Fawtyg.MesAgent/Win_in.Sfs.Wms.DataExchange.Fawtyg.MesAgent.csproj

@@ -28,6 +28,7 @@
 		<ProjectReference Include="..\..\src\Win_in.Sfs.Wms.DataExchange.EntityFrameworkCore\Win_in.Sfs.Wms.DataExchange.EntityFrameworkCore.csproj" />
 		<ProjectReference Include="..\Win_in.Sfs.Wms.DataExchange.Domain.Fawtyg.Eos\Win_in.Sfs.Wms.DataExchange.Domain.Fawtyg.Eos.csproj" />
 		<ProjectReference Include="..\Win_in.Sfs.Wms.DataExchange.Domain.Fawtyg.Mes\Win_in.Sfs.Wms.DataExchange.Domain.Fawtyg.Mes.csproj" />
+		<ProjectReference Include="..\Win_in.Sfs.Wms.DataExchange.Domain.Fawtyg.Tyrp\Win_in.Sfs.Wms.DataExchange.Domain.Fawtyg.Tyrp.csproj" />
 		<ProjectReference Include="..\Win_in.Sfs.Wms.DataExchange.EntityFrameworkCore.Fawtyg.Mes\Win_in.Sfs.Wms.DataExchange.EntityFrameworkCore.Fawtyg.Mes.csproj" />
 	</ItemGroup>
 

be/DataExchange/Fawtyg/Win_in.Sfs.Wms.DataExchange.Fawtyg.MesAgent/appsettings.json

@@ -1,12 +1,12 @@
 {
   "ConnectionStrings": {
-    "Default": "Server=dev.ccwin-in.com,13319;Database=DyWmsAuth;uid=ccwin-in;pwd=Microsoft@2022;",
+    "Default": "Server=dev.ccwin-in.com,21195;Database= WMS;uid=sa;pwd=aA123456!;TrustServerCertificate=True;",
-    "DataExchange": "Server=dev.ccwin-in.com,21195;Database=DataExchange_Main;uid=sa;pwd=aA123456!;",
+    "DataExchange": "Server=dev.ccwin-in.com,21195;Database=DataExchange_Main;uid=sa;pwd=aA123456!;TrustServerCertificate=True;",
-    "MES": "Server=dev.ccwin-in.com;Port=13306;Database=MES;Uid=ccwinin;Pwd=Microsoft@2022;"
+    "MES": "Server=10.164.1.12;Port=3306;Database=erp;Uid=wms;Pwd=123456;"
   },
 
   "AuthServer": {
-    "Authority": "http://dev.ccwin-in.com:59093/",
+    "Authority": "http://dev.ccwin-in.com:21293/",
     "RequireHttpsMetadata": "false",
     "SwaggerClientId": "admin",
     "SwaggerClientSecret": "1q2w3E*",
@@ -24,13 +24,13 @@
 
   "RemoteServices": {
     "BaseData": {
-      "BaseUrl": "http://dev.ccwin-in.com:59094/"
+      "BaseUrl": "http://dev.ccwin-in.com:21294/"
     },
     "Store": {
-      "BaseUrl": "http://dev.ccwin-in.com:59095/"
+      "BaseUrl": "http://dev.ccwin-in.com:21295/"
     },
     "Label": {
-      "BaseUrl": "http://dev.ccwin-in.com:59092/"
+      "BaseUrl": "http://dev.ccwin-in.com:21292/"
     }
   },
   "MesOptions": {

be/DataExchange/Fawtyg/Win_in.Sfs.Wms.DataExchange.Fawtyg.TyrpAgent/Incoming/BackFluReader.cs

@@ -43,7 +43,7 @@ public class BackFluReader : IReader
         //bom逐一转换为bomNote
         var incomingDataList = BuildIncomingFromExternalFromBomAsync(toBeProcessedBack);
         await _incomingFromExternalManager.CreateManyAsync(incomingDataList).ConfigureAwait(false);
-        //await _ibackfluManager.UpdateProcessedListAsync(toBeProcessedBack);
+        await _ibackfluManager.UpdateProcessedListAsync(toBeProcessedBack).ConfigureAwait(false);
         return incomingDataList;
     }
     private List<IncomingFromExternal> BuildIncomingFromExternalFromBomAsync(List<scmout> toBeProcessedIssue)

be/DataExchange/src/Win_in.Sfs.Wms.DataExchange.Agent/AgentModule.cs

@@ -149,7 +149,7 @@ public class AgentModule : AbpModule
     public override void OnApplicationInitialization(
              ApplicationInitializationContext context)
     {
-      //  context.AddBackgroundWorkerAsync<IncomingToWmsWorker>();
+        context.AddBackgroundWorkerAsync<IncomingToWmsWorker>();
-        context.AddBackgroundWorkerAsync<OutgoingFromWmsWorker>();
+        //context.AddBackgroundWorkerAsync<OutgoingFromWmsWorker>();
     }
 }

be/DataExchange/src/Win_in.Sfs.Wms.DataExchange.Agent/IncomingToWmsWorker.cs

@@ -79,64 +79,64 @@ public class IncomingToWmsWorker : AsyncPeriodicBackgroundWorkerBase
         switch (dataType)
         {
             case EnumIncomingDataType.Department:
-                await incomingToWms.HandleDepartmentsAsync(workerContext).ConfigureAwait(false);
+                //await incomingToWms.HandleDepartmentsAsync(workerContext).ConfigureAwait(false);
                 break;
             case EnumIncomingDataType.User:
-                await incomingToWms.HandleUsersAsync(workerContext).ConfigureAwait(false);
+                //await incomingToWms.HandleUsersAsync(workerContext).ConfigureAwait(false);
                 break;
             case EnumIncomingDataType.Item:
-                await incomingToWms.HandleItemsAsync(workerContext).ConfigureAwait(false);
+                //await incomingToWms.HandleItemsAsync(workerContext).ConfigureAwait(false);
                 break;
             case EnumIncomingDataType.Location:
                 await incomingToWms.HandleErpLocationsAsync(workerContext).ConfigureAwait(false);
                 break;
             case EnumIncomingDataType.Bom:
-                await incomingToWms.HandleBomsAsync(workerContext).ConfigureAwait(false);
+                //await incomingToWms.HandleBomsAsync(workerContext).ConfigureAwait(false);
                 break;
             case EnumIncomingDataType.Dict:
                 await incomingToWms.HandleDictsAsync(workerContext).ConfigureAwait(false);
                 break;
             case EnumIncomingDataType.Supplier:
-                await incomingToWms.HandleSuppliersAsync(workerContext).ConfigureAwait(false);
+                //await incomingToWms.HandleSuppliersAsync(workerContext).ConfigureAwait(false);
                 break;
             case EnumIncomingDataType.SupplierItem:
-                await incomingToWms.HandleSupplierItemsAsync(workerContext).ConfigureAwait(false);
+                //await incomingToWms.HandleSupplierItemsAsync(workerContext).ConfigureAwait(false);
                 break;
             case EnumIncomingDataType.ItemPack:
-                await incomingToWms.HandleItemPacksAsync(workerContext).ConfigureAwait(false);
+                //await incomingToWms.HandleItemPacksAsync(workerContext).ConfigureAwait(false);
                 break;
             case EnumIncomingDataType.Customer:
-                await incomingToWms.HandleCustomersAsync(workerContext).ConfigureAwait(false);
+                //await incomingToWms.HandleCustomersAsync(workerContext).ConfigureAwait(false);
                 break;
             case EnumIncomingDataType.CustomerItem:
-                await incomingToWms.HandleCustomerItemsAsync(workerContext).ConfigureAwait(false);
+                //await incomingToWms.HandleCustomerItemsAsync(workerContext).ConfigureAwait(false);
                 break;
             case EnumIncomingDataType.InterfaceCalendar:
-                await incomingToWms.HandleInterfaceCalendarsAsync(workerContext).ConfigureAwait(false);
+                //await incomingToWms.HandleInterfaceCalendarsAsync(workerContext).ConfigureAwait(false);
                 break;
             case EnumIncomingDataType.PurchaseOrder:
-                await incomingToWms.HandlePurchaseOrdersAsync(workerContext).ConfigureAwait(false);
+                //await incomingToWms.HandlePurchaseOrdersAsync(workerContext).ConfigureAwait(false);
                 break;
             case EnumIncomingDataType.SaleOrder:
-                await incomingToWms.HandleSaleOrdersAsync(workerContext).ConfigureAwait(false);
+                //await incomingToWms.HandleSaleOrdersAsync(workerContext).ConfigureAwait(false);
                 break;
             case EnumIncomingDataType.SupplierAsn:
-                await incomingToWms.HandleAsnsAsync(workerContext).ConfigureAwait(false);
+                //await incomingToWms.HandleAsnsAsync(workerContext).ConfigureAwait(false);
                 break;
             case EnumIncomingDataType.ProductReceipt:
-                await incomingToWms.HandleProductReceiptsAsync(workerContext).ConfigureAwait(false);
+                //await incomingToWms.HandleProductReceiptsAsync(workerContext).ConfigureAwait(false);
                 break;
             case EnumIncomingDataType.MaterialRequest:
                 await incomingToWms.HandleMaterialRequestsAsync(workerContext).ConfigureAwait(false);
                 break;
             case EnumIncomingDataType.Scrap:
-                await incomingToWms.HandleScrapsAsync(workerContext).ConfigureAwait(false);
+                //await incomingToWms.HandleScrapsAsync(workerContext).ConfigureAwait(false);
                 break;
             case EnumIncomingDataType.IssueConfirm:
-                await incomingToWms.HandleIssueNoteConfirmAsync(workerContext).ConfigureAwait(false);
+                //await incomingToWms.HandleIssueNoteConfirmAsync(workerContext).ConfigureAwait(false);
                 break;
             case EnumIncomingDataType.PurchaseLabel:
-                await incomingToWms.HandleInventoryLabelsAsync(workerContext).ConfigureAwait(false);
+                //await incomingToWms.HandleInventoryLabelsAsync(workerContext).ConfigureAwait(false);
                 break;
             case EnumIncomingDataType.BackFlush:
                 await incomingToWms.HandleBackFlushsAsync(workerContext).ConfigureAwait(false);