Browse Source

接口代码整理

dev_DY_CC
lvzb 10 months ago
parent
commit
fb2d5cf0b5
  1. 6
      be/DataExchange/Fawtyg/Win_in.Sfs.Wms.DataExchange.Fawtyg.EosAgent/Incoming/EosIncomingBackgroundWorker.cs
  2. 6
      be/DataExchange/Fawtyg/Win_in.Sfs.Wms.DataExchange.Fawtyg.EosAgent/Outgoing/EosOutgoingBackgroundWorker.cs
  3. 53
      be/DataExchange/Fawtyg/Win_in.Sfs.Wms.DataExchange.Fawtyg.MesAgent/Incoming/MesIncomingBackgroundWorker.cs
  4. 78
      be/DataExchange/Fawtyg/Win_in.Sfs.Wms.DataExchange.Fawtyg.TyrpAgent/Incoming/TyrpIncomingBackgroundWorker.cs
  5. 87
      be/DataExchange/Fawtyg/Win_in.Sfs.Wms.DataExchange.Fawtyg.TyrpAgent/Outgoing/TyrpOutgoingBackgroundWorker.cs

6
be/DataExchange/Fawtyg/Win_in.Sfs.Wms.DataExchange.Fawtyg.EosAgent/Incoming/EosIncomingBackgroundWorker.cs

@ -11,7 +11,7 @@ namespace Win_in.Sfs.Wms.DataExchange.Fawtyg.EosAgent;
public class EosIncomingBackgroundWorker : AsyncPeriodicBackgroundWorkerBase public class EosIncomingBackgroundWorker : AsyncPeriodicBackgroundWorkerBase
{ {
private readonly string Incoming = "EOS 接收"; private readonly string Incoming = "EOS接收";
private readonly IOptions<EosOptions> _options; private readonly IOptions<EosOptions> _options;
@ -28,7 +28,7 @@ public class EosIncomingBackgroundWorker : AsyncPeriodicBackgroundWorkerBase
[UnitOfWork] [UnitOfWork]
protected override async Task DoWorkAsync(PeriodicBackgroundWorkerContext workerContext) protected override async Task DoWorkAsync(PeriodicBackgroundWorkerContext workerContext)
{ {
Logger.LogInformation($"开始: 处理 {Incoming}"); Logger.LogInformation($"开始: 执行 {Incoming}");
if (!_options.Value.IncomingOptions.Active) if (!_options.Value.IncomingOptions.Active)
{ {
Logger.LogInformation($"{Incoming} 已关闭没有执行!"); Logger.LogInformation($"{Incoming} 已关闭没有执行!");
@ -62,7 +62,7 @@ public class EosIncomingBackgroundWorker : AsyncPeriodicBackgroundWorkerBase
await productConverter.ConvertAsync(productsFromExternalList).ConfigureAwait(false); await productConverter.ConvertAsync(productsFromExternalList).ConfigureAwait(false);
Logger.LogInformation($"处理产品【{productsFromExternalList.Count}】条数据"); Logger.LogInformation($"处理产品【{productsFromExternalList.Count}】条数据");
Logger.LogInformation($"提交: 处理 {Incoming}"); Logger.LogInformation($"提交: 执行 {Incoming}");
} }
} }

6
be/DataExchange/Fawtyg/Win_in.Sfs.Wms.DataExchange.Fawtyg.EosAgent/Outgoing/EosOutgoingBackgroundWorker.cs

@ -10,7 +10,7 @@ namespace Win_in.Sfs.Wms.DataExchange.Fawtyg.EosAgent;
public class EosOutgoingBackgroundWorker : AsyncPeriodicBackgroundWorkerBase public class EosOutgoingBackgroundWorker : AsyncPeriodicBackgroundWorkerBase
{ {
private readonly string Outgoing = "EOS 发送"; private readonly string Outgoing = "EOS发送";
private readonly IOptions<EosOptions> _options; private readonly IOptions<EosOptions> _options;
@ -28,7 +28,7 @@ public class EosOutgoingBackgroundWorker : AsyncPeriodicBackgroundWorkerBase
[UnitOfWork] [UnitOfWork]
protected override async Task DoWorkAsync(PeriodicBackgroundWorkerContext workerContext) protected override async Task DoWorkAsync(PeriodicBackgroundWorkerContext workerContext)
{ {
Logger.LogInformation($"开始: 处理 {Outgoing}"); Logger.LogInformation($"开始: 执行 {Outgoing}");
if (!_options.Value.IncomingOptions.Active) if (!_options.Value.IncomingOptions.Active)
{ {
Logger.LogInformation($"{Outgoing} 已关闭没有执行!"); Logger.LogInformation($"{Outgoing} 已关闭没有执行!");
@ -49,7 +49,7 @@ public class EosOutgoingBackgroundWorker : AsyncPeriodicBackgroundWorkerBase
await returnWriter.WriteAsync(returnNoteList).ConfigureAwait(false); await returnWriter.WriteAsync(returnNoteList).ConfigureAwait(false);
Logger.LogInformation($"处理采购退货单【{returnNoteList.Count}】条数据"); Logger.LogInformation($"处理采购退货单【{returnNoteList.Count}】条数据");
Logger.LogInformation($"提交: 处理 {Outgoing}"); Logger.LogInformation($"提交: 执行 {Outgoing}");
} }
} }

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

@ -14,7 +14,7 @@ namespace Win_in.Sfs.Wms.DataExchange.Fawtyg.MesAgent;
public class MesIncomingBackgroundWorker : AsyncPeriodicBackgroundWorkerBase public class MesIncomingBackgroundWorker : AsyncPeriodicBackgroundWorkerBase
{ {
private readonly string Incoming = "MES Incoming"; private readonly string Incoming = "MES接收";
private readonly IOptions<MesOptions> _options; private readonly IOptions<MesOptions> _options;
@ -31,10 +31,10 @@ public class MesIncomingBackgroundWorker : AsyncPeriodicBackgroundWorkerBase
[UnitOfWork] [UnitOfWork]
protected override async Task DoWorkAsync(PeriodicBackgroundWorkerContext workerContext) protected override async Task DoWorkAsync(PeriodicBackgroundWorkerContext workerContext)
{ {
Logger.LogInformation($"Starting: Handling {Incoming}"); Logger.LogInformation($"开始: 执行 {Incoming}");
if (!_options.Value.IncomingOptions.Active) if (!_options.Value.IncomingOptions.Active)
{ {
Logger.LogInformation($"{Incoming} is not active!"); Logger.LogInformation($"{Incoming} 已关闭没有执行!");
return; return;
} }
@ -45,7 +45,8 @@ public class MesIncomingBackgroundWorker : AsyncPeriodicBackgroundWorkerBase
return; return;
} }
Logger.LogInformation($"Read MesOut");//缴库 #region 缴库 MesOut
Logger.LogInformation($"读取缴库(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>();
var TransferNoteConverter = workerContext.ServiceProvider.GetRequiredService<QtyrfeConverter>(); var TransferNoteConverter = workerContext.ServiceProvider.GetRequiredService<QtyrfeConverter>();
@ -59,74 +60,92 @@ public class MesIncomingBackgroundWorker : AsyncPeriodicBackgroundWorkerBase
{ {
await TransferNoteConverter.ConvertAsync(mesOutsFromExternalList_TransferNote).ConfigureAwait(false); await TransferNoteConverter.ConvertAsync(mesOutsFromExternalList_TransferNote).ConfigureAwait(false);
} }
Logger.LogInformation($"处理完工收货(缴库)【{mesOutsFromExternalList_ProductReceipt.Count}】条数据");
Logger.LogInformation($"处理储位调拨【{mesOutsFromExternalList_TransferNote.Count}】条数据");
#endregion
Logger.LogInformation($"Read Scrap");//报废 #region 报废 Scrap
Logger.LogInformation($"读取报废(Scrap)");//报废
var scrapReader = workerContext.ServiceProvider.GetRequiredService<ScrapReader>(); var scrapReader = workerContext.ServiceProvider.GetRequiredService<ScrapReader>();
var scrapConverter = workerContext.ServiceProvider.GetRequiredService<ScrapConverter>(); var scrapConverter = workerContext.ServiceProvider.GetRequiredService<ScrapConverter>();
//读取并保存Scrap //读取并保存Scrap
var scrapsFromExternalList = await scrapReader.ReadAsync().ConfigureAwait(false); var scrapsFromExternalList = await scrapReader.ReadAsync().ConfigureAwait(false);
//转换Scrap //转换Scrap
await scrapConverter.ConvertAsync(scrapsFromExternalList).ConfigureAwait(false); await scrapConverter.ConvertAsync(scrapsFromExternalList).ConfigureAwait(false);
Logger.LogInformation($"处理报废【{scrapsFromExternalList.Count}】条数据");
#endregion
#region 耗用单 BackFlush
Logger.LogInformation($"Read BackFlush");//耗用单 Logger.LogInformation($"读取耗用单 (BackFlush)");//耗用单
var BackFlushReader = workerContext.ServiceProvider.GetRequiredService<BackFluReader>(); var BackFlushReader = workerContext.ServiceProvider.GetRequiredService<BackFluReader>();
var BackFlushConverter = workerContext.ServiceProvider.GetRequiredService<BackFluConverter>(); var BackFlushConverter = workerContext.ServiceProvider.GetRequiredService<BackFluConverter>();
//读取并保存BackFlush //读取并保存BackFlush
var backFlushsFromExternalList = await BackFlushReader.ReadAsync().ConfigureAwait(false); var backFlushsFromExternalList = await BackFlushReader.ReadAsync().ConfigureAwait(false);
//转换BackFlush //转换BackFlush
await BackFlushConverter.ConvertAsync(backFlushsFromExternalList).ConfigureAwait(false); await BackFlushConverter.ConvertAsync(backFlushsFromExternalList).ConfigureAwait(false);
Logger.LogInformation($"处理耗用单【{backFlushsFromExternalList.Count}】条数据");
#endregion
#region 储位调拨 TransferNote
Logger.LogInformation($"Read TransferNote");//储位调拨 Logger.LogInformation($"读取储位调拨 (TransferNote)");//储位调拨
var TransferNoteReader = workerContext.ServiceProvider.GetRequiredService<QtyrfeReader>(); var TransferNoteReader = workerContext.ServiceProvider.GetRequiredService<QtyrfeReader>();
// var TransferNoteConverter = workerContext.ServiceProvider.GetRequiredService<QtyrfeConverter>(); // var TransferNoteConverter = workerContext.ServiceProvider.GetRequiredService<QtyrfeConverter>();
//读取并保存TransferNote //读取并保存TransferNote
var transferNoteFromExternalList = await TransferNoteReader.ReadAsync().ConfigureAwait(false); var transferNoteFromExternalList = await TransferNoteReader.ReadAsync().ConfigureAwait(false);
//转换TransferNote //转换TransferNote
await TransferNoteConverter.ConvertAsync(transferNoteFromExternalList).ConfigureAwait(false); await TransferNoteConverter.ConvertAsync(transferNoteFromExternalList).ConfigureAwait(false);
Logger.LogInformation($"处理储位调拨【{transferNoteFromExternalList.Count}】条数据");
#endregion
Logger.LogInformation($"Read Frozen");//冻结解冻 #region 冻结解冻 Frozen
Logger.LogInformation($"读取冻结解冻 (Frozen)");//冻结解冻
var FrozenReader = workerContext.ServiceProvider.GetRequiredService<FrozenReader>(); var FrozenReader = workerContext.ServiceProvider.GetRequiredService<FrozenReader>();
var FrozenConverter = workerContext.ServiceProvider.GetRequiredService<FrozenConverter>(); var FrozenConverter = workerContext.ServiceProvider.GetRequiredService<FrozenConverter>();
//读取并保存Frozen //读取并保存Frozen
var mesNoteFromExternalList = await FrozenReader.ReadAsync().ConfigureAwait(false); var mesNoteFromExternalList = await FrozenReader.ReadAsync().ConfigureAwait(false);
//转换Frozen //转换Frozen
await FrozenConverter.ConvertAsync(mesNoteFromExternalList).ConfigureAwait(false); await FrozenConverter.ConvertAsync(mesNoteFromExternalList).ConfigureAwait(false);
Logger.LogInformation($"处理冻结解冻【{mesNoteFromExternalList.Count}】条数据");
#endregion
#region 成品发运 Delivery
Logger.LogInformation($"Read Delivery");//成品发运 Logger.LogInformation($"读取成品发运 (Delivery)");//成品发运
var DeliveryReader = workerContext.ServiceProvider.GetRequiredService<DeliveryReader>(); var DeliveryReader = workerContext.ServiceProvider.GetRequiredService<DeliveryReader>();
var DeliveryConverter = workerContext.ServiceProvider.GetRequiredService<DeliveryConverter>(); var DeliveryConverter = workerContext.ServiceProvider.GetRequiredService<DeliveryConverter>();
//读取并保存Delivery //读取并保存Delivery
var deliveryNoteFromExternalList = await DeliveryReader.ReadAsync().ConfigureAwait(false); var deliveryNoteFromExternalList = await DeliveryReader.ReadAsync().ConfigureAwait(false);
//转换Delivery //转换Delivery
await DeliveryConverter.ConvertAsync(deliveryNoteFromExternalList).ConfigureAwait(false); await DeliveryConverter.ConvertAsync(deliveryNoteFromExternalList).ConfigureAwait(false);
Logger.LogInformation($"处理成品发运【{deliveryNoteFromExternalList.Count}】条数据");
#endregion
#region 自动叫料 CallMtl
Logger.LogInformation($"读取自动叫料 (CallMtl)");//自动叫料
Logger.LogInformation($"Read CallMtl");//自动叫料
var CallMtlReader = workerContext.ServiceProvider.GetRequiredService<CallMtlReader>(); var CallMtlReader = workerContext.ServiceProvider.GetRequiredService<CallMtlReader>();
var CallMtlConverter = workerContext.ServiceProvider.GetRequiredService<CallMtlConverter>(); var CallMtlConverter = workerContext.ServiceProvider.GetRequiredService<CallMtlConverter>();
//读取并保存Delivery //读取并保存Delivery
var callMtlFromExternalList = await CallMtlReader.ReadAsync().ConfigureAwait(false); var callMtlFromExternalList = await CallMtlReader.ReadAsync().ConfigureAwait(false);
//转换Delivery //转换Delivery
await CallMtlConverter.ConvertAsync(callMtlFromExternalList).ConfigureAwait(false); await CallMtlConverter.ConvertAsync(callMtlFromExternalList).ConfigureAwait(false);
Logger.LogInformation($"处理自动叫料【{callMtlFromExternalList.Count}】条数据");
#endregion
Logger.LogInformation($"Completed: Handling {Incoming}"); Logger.LogInformation($"提交: 执行 {Incoming}");
#region 未启用接口启用时需要看逻辑修改 #region 未启用接口启用时需要看逻辑修改
//上海和安徽无此接口 //上海和安徽无此接口
//Logger.LogInformation($"Read PullTask");//拉动任务 //Logger.LogInformation($"读取拉动任务 (PullTask)");//拉动任务
//var pullTaskReader = workerContext.ServiceProvider.GetRequiredService<PullTaskReader>(); //var pullTaskReader = workerContext.ServiceProvider.GetRequiredService<PullTaskReader>();
//var pullTaskConverter = workerContext.ServiceProvider.GetRequiredService<PullTaskConverter>(); //var pullTaskConverter = workerContext.ServiceProvider.GetRequiredService<PullTaskConverter>();
////读取并保存PullTask ////读取并保存PullTask
//var pullTaskFromExternalList = await pullTaskReader.ReadAsync().ConfigureAwait(false); //var pullTaskFromExternalList = await pullTaskReader.ReadAsync().ConfigureAwait(false);
////转换PullTask ////转换PullTask
//await pullTaskConverter.ConvertAsync(pullTaskFromExternalList).ConfigureAwait(false); //await pullTaskConverter.ConvertAsync(pullTaskFromExternalList).ConfigureAwait(false);
// Logger.LogInformation($"处理拉动任务【{pullTaskFromExternalList.Count}】条数据");
//上海和安徽无此接口 //上海和安徽无此接口
//Logger.LogInformation($"Read Issue"); //Logger.LogInformation($"Read Issue");
//var pckHandleService = workerContext.ServiceProvider.GetRequiredService<IssueReader>(); //var pckHandleService = workerContext.ServiceProvider.GetRequiredService<IssueReader>();
//var pckConverter = workerContext.ServiceProvider.GetRequiredService<IssueConverter>(); //var pckConverter = workerContext.ServiceProvider.GetRequiredService<IssueConverter>();
////读取并保持Pck ////读取并保持Pck

78
be/DataExchange/Fawtyg/Win_in.Sfs.Wms.DataExchange.Fawtyg.TyrpAgent/Incoming/TyrpIncomingBackgroundWorker.cs

@ -14,7 +14,7 @@ namespace Win_in.Sfs.Wms.DataExchange.Fawtyg.TyrpAgent;
public class TyrpIncomingBackgroundWorker : AsyncPeriodicBackgroundWorkerBase public class TyrpIncomingBackgroundWorker : AsyncPeriodicBackgroundWorkerBase
{ {
private readonly string Incoming = "TYRP Incoming"; private readonly string Incoming = "TYRP接收";
private readonly IOptions<TyrpOptions> _options; private readonly IOptions<TyrpOptions> _options;
@ -33,10 +33,10 @@ public class TyrpIncomingBackgroundWorker : AsyncPeriodicBackgroundWorkerBase
[UnitOfWork] [UnitOfWork]
protected override async Task DoWorkAsync(PeriodicBackgroundWorkerContext workerContext) protected override async Task DoWorkAsync(PeriodicBackgroundWorkerContext workerContext)
{ {
Logger.LogInformation($"Starting: Handling {Incoming}"); Logger.LogInformation($"开始: 执行 {Incoming}");
if (!_options.Value.IncomingOptions.Active) if (!_options.Value.IncomingOptions.Active)
{ {
Logger.LogInformation($"{Incoming} is not active!"); Logger.LogInformation($"{Incoming} 已关闭没有执行!");
return; return;
} }
@ -59,15 +59,20 @@ public class TyrpIncomingBackgroundWorker : AsyncPeriodicBackgroundWorkerBase
common.updatedt = DateTime.Now; common.updatedt = DateTime.Now;
common.isupdate = false; common.isupdate = false;
Logger.LogInformation($"Read ItemBasic");//物品 #region 物品 ItemBasic
Logger.LogInformation($"读取物品 ItemBasic");//物品
var itemBasicReader = workerContext.ServiceProvider.GetRequiredService<ItemBasicReader>(); var itemBasicReader = workerContext.ServiceProvider.GetRequiredService<ItemBasicReader>();
var itemBasicConverter = workerContext.ServiceProvider.GetRequiredService<ItemBasicConverter>(); var itemBasicConverter = workerContext.ServiceProvider.GetRequiredService<ItemBasicConverter>();
//读取并保存itemBasic //读取并保存itemBasic
var itemBasicOutsFromExternalList = await itemBasicReader.ReadAsync().ConfigureAwait(false); var itemBasicOutsFromExternalList = await itemBasicReader.ReadAsync().ConfigureAwait(false);
//转换itemBasic //转换itemBasic
await itemBasicConverter.ConvertAsync(itemBasicOutsFromExternalList).ConfigureAwait(false); await itemBasicConverter.ConvertAsync(itemBasicOutsFromExternalList).ConfigureAwait(false);
Logger.LogInformation($"处理物品【{itemBasicOutsFromExternalList.Count}】条数据");
#endregion
Logger.LogInformation($"Read User");//用户和部门 #region 用户和部门 User
Logger.LogInformation($"读取用户和部门 User");//用户和部门
var userReader = workerContext.ServiceProvider.GetRequiredService<UserReader>(); var userReader = workerContext.ServiceProvider.GetRequiredService<UserReader>();
var userConverter = workerContext.ServiceProvider.GetRequiredService<UserConverter>(); var userConverter = workerContext.ServiceProvider.GetRequiredService<UserConverter>();
var departmentConverter = workerContext.ServiceProvider.GetRequiredService<DepartmentConverter>(); var departmentConverter = workerContext.ServiceProvider.GetRequiredService<DepartmentConverter>();
@ -79,96 +84,129 @@ public class TyrpIncomingBackgroundWorker : AsyncPeriodicBackgroundWorkerBase
await userConverter.ConvertAsync(userOutsFromExternalList).ConfigureAwait(false); await userConverter.ConvertAsync(userOutsFromExternalList).ConfigureAwait(false);
//转换department //转换department
await departmentConverter.ConvertAsync(departmentOutsFromExternalList).ConfigureAwait(false); await departmentConverter.ConvertAsync(departmentOutsFromExternalList).ConfigureAwait(false);
Logger.LogInformation($"处理用户【{userOutsFromExternalList.Count}】条数据");
Logger.LogInformation($"处理部门【{departmentOutsFromExternalList.Count}】条数据");
#endregion
Logger.LogInformation($"Read InterfaceCalendar");//账期 #region 账期 InterfaceCalendar
Logger.LogInformation($"读取账期 InterfaceCalendar");//账期
var interfaceCalendarReader = workerContext.ServiceProvider.GetRequiredService<InterfaceCalendarReader>(); var interfaceCalendarReader = workerContext.ServiceProvider.GetRequiredService<InterfaceCalendarReader>();
var interfaceCalendarConverter = workerContext.ServiceProvider.GetRequiredService<InterfaceCalendarConverter>(); var interfaceCalendarConverter = workerContext.ServiceProvider.GetRequiredService<InterfaceCalendarConverter>();
//读取并保存InterfaceCalendar //读取并保存InterfaceCalendar
var interfaceCalendarOutsFromExternalList = await interfaceCalendarReader.ReadAsync().ConfigureAwait(false); var interfaceCalendarOutsFromExternalList = await interfaceCalendarReader.ReadAsync().ConfigureAwait(false);
//转换InterfaceCalendar //转换InterfaceCalendar
await interfaceCalendarConverter.ConvertAsync(interfaceCalendarOutsFromExternalList).ConfigureAwait(false); await interfaceCalendarConverter.ConvertAsync(interfaceCalendarOutsFromExternalList).ConfigureAwait(false);
Logger.LogInformation($"处理账期【{interfaceCalendarOutsFromExternalList.Count}】条数据");
#endregion
Logger.LogInformation($"Read Dict");//系统代码 #region 系统代码 Dict
Logger.LogInformation($"读取系统代码 Dict");//系统代码
var dictReader = workerContext.ServiceProvider.GetRequiredService<DictReader>(); var dictReader = workerContext.ServiceProvider.GetRequiredService<DictReader>();
var dictConverter = workerContext.ServiceProvider.GetRequiredService<DictConverter>(); var dictConverter = workerContext.ServiceProvider.GetRequiredService<DictConverter>();
//读取并保存Dict //读取并保存Dict
var dictOutsFromExternalList = await dictReader.ReadAsync().ConfigureAwait(false); var dictOutsFromExternalList = await dictReader.ReadAsync().ConfigureAwait(false);
//转换Dict //转换Dict
await dictConverter.ConvertAsync(dictOutsFromExternalList).ConfigureAwait(false); await dictConverter.ConvertAsync(dictOutsFromExternalList).ConfigureAwait(false);
Logger.LogInformation($"处理系统代码【{dictOutsFromExternalList.Count}】条数据");
#endregion
Logger.LogInformation($"Read Bom"); #region Bom
Logger.LogInformation($"读取报目 Bom");
var BomReader = workerContext.ServiceProvider.GetRequiredService<BomReader>(); var BomReader = workerContext.ServiceProvider.GetRequiredService<BomReader>();
var BomConverter = workerContext.ServiceProvider.GetRequiredService<BomConverter>(); var BomConverter = workerContext.ServiceProvider.GetRequiredService<BomConverter>();
//读取并保存Bom //读取并保存Bom
var bomsFromExternalList = await BomReader.ReadAsync().ConfigureAwait(false); var bomsFromExternalList = await BomReader.ReadAsync().ConfigureAwait(false);
//转换Bom //转换Bom
await BomConverter.ConvertAsync(bomsFromExternalList).ConfigureAwait(false); await BomConverter.ConvertAsync(bomsFromExternalList).ConfigureAwait(false);
Logger.LogInformation($"处理Bom【{bomsFromExternalList.Count}】条数据");
#endregion
Logger.LogInformation($"Read Supplier");//供应商 #region 供应商 Supplier
Logger.LogInformation($"读取供应商 Supplier");//供应商
var SupplierReader = workerContext.ServiceProvider.GetRequiredService<SupplierReader>(); var SupplierReader = workerContext.ServiceProvider.GetRequiredService<SupplierReader>();
var SupplierConverter = workerContext.ServiceProvider.GetRequiredService<SupplierConverter>(); var SupplierConverter = workerContext.ServiceProvider.GetRequiredService<SupplierConverter>();
//读取并保存Supplier //读取并保存Supplier
var suppliersFromExternalList = await SupplierReader.ReadAsync().ConfigureAwait(false); var suppliersFromExternalList = await SupplierReader.ReadAsync().ConfigureAwait(false);
//转换Supplier //转换Supplier
await SupplierConverter.ConvertAsync(suppliersFromExternalList).ConfigureAwait(false); await SupplierConverter.ConvertAsync(suppliersFromExternalList).ConfigureAwait(false);
Logger.LogInformation($"处理供应商【{suppliersFromExternalList.Count}】条数据");
#endregion
Logger.LogInformation($"Read Dictpj");//专案代码 #region 专案代码 Dictpj
Logger.LogInformation($"读取专案代码 Dictpj");//专案代码
var DictpjReader = workerContext.ServiceProvider.GetRequiredService<DictpjReader>(); var DictpjReader = workerContext.ServiceProvider.GetRequiredService<DictpjReader>();
//读取并保存Dictpj //读取并保存Dictpj
var dictpjOutsFromExternalList = await DictpjReader.ReadAsync().ConfigureAwait(false); var dictpjOutsFromExternalList = await DictpjReader.ReadAsync().ConfigureAwait(false);
//转换Dictpj //转换Dictpj
await dictConverter.ConvertAsync(dictpjOutsFromExternalList).ConfigureAwait(false); await dictConverter.ConvertAsync(dictpjOutsFromExternalList).ConfigureAwait(false);
Logger.LogInformation($"处理专案代码【{dictpjOutsFromExternalList.Count}】条数据");
#endregion
#region ERP库位 ErpLocation
Logger.LogInformation($"Read ErpLocation");//ERP库位 Logger.LogInformation($"读取ERP库位 ErpLocation");//ERP库位
var ErpLocationReader = workerContext.ServiceProvider.GetRequiredService<ErpLocationReader>(); var ErpLocationReader = workerContext.ServiceProvider.GetRequiredService<ErpLocationReader>();
var ErpLocationConverter = workerContext.ServiceProvider.GetRequiredService<ErpLocationConverter>(); var ErpLocationConverter = workerContext.ServiceProvider.GetRequiredService<ErpLocationConverter>();
//读取并保存ErpLocationItem //读取并保存ErpLocationItem
var erpLocationFromExternalList = await ErpLocationReader.ReadAsync().ConfigureAwait(false); var erpLocationFromExternalList = await ErpLocationReader.ReadAsync().ConfigureAwait(false);
//转换ErpLocationItem //转换ErpLocationItem
await ErpLocationConverter.ConvertAsync(erpLocationFromExternalList).ConfigureAwait(false); await ErpLocationConverter.ConvertAsync(erpLocationFromExternalList).ConfigureAwait(false);
Logger.LogInformation($"处理ERP库位【{erpLocationFromExternalList.Count}】条数据");
#endregion
#region 客户资料 Customer
Logger.LogInformation($"Read Customer");//客户资料 Logger.LogInformation($"读取客户资料 Customer");//客户资料
var CustomerReader = workerContext.ServiceProvider.GetRequiredService<CustomerReader>(); var CustomerReader = workerContext.ServiceProvider.GetRequiredService<CustomerReader>();
var CustomerConverter = workerContext.ServiceProvider.GetRequiredService<CustomerConverter>(); var CustomerConverter = workerContext.ServiceProvider.GetRequiredService<CustomerConverter>();
//读取并保存Customer //读取并保存Customer
var customersFromExternalList = await CustomerReader.ReadAsync().ConfigureAwait(false); var customersFromExternalList = await CustomerReader.ReadAsync().ConfigureAwait(false);
//转换Customer //转换Customer
await CustomerConverter.ConvertAsync(customersFromExternalList).ConfigureAwait(false); await CustomerConverter.ConvertAsync(customersFromExternalList).ConfigureAwait(false);
Logger.LogInformation($"处理客户资料【{customersFromExternalList.Count}】条数据");
#endregion
Logger.LogInformation($"Read ErpLocationItem");//储位与物品对应关系(开账) #region 储位与物品对应关系(开账) ErpLocationItem
Logger.LogInformation($"读取储位与物品对应关系(开账) ErpLocationItem");//储位与物品对应关系(开账)
var ErpLocationItemReader = workerContext.ServiceProvider.GetRequiredService<ErpLocationItemReader>(); var ErpLocationItemReader = workerContext.ServiceProvider.GetRequiredService<ErpLocationItemReader>();
var ErpLocationItemConverter = workerContext.ServiceProvider.GetRequiredService<ErpLocationItemConverter>(); var ErpLocationItemConverter = workerContext.ServiceProvider.GetRequiredService<ErpLocationItemConverter>();
//读取并保存ErpLocationItem //读取并保存ErpLocationItem
var erpLocationItemFromExternalList = await ErpLocationItemReader.ReadAsync().ConfigureAwait(false); var erpLocationItemFromExternalList = await ErpLocationItemReader.ReadAsync().ConfigureAwait(false);
//转换ErpLocationItem //转换ErpLocationItem
await ErpLocationItemConverter.ConvertAsync(erpLocationItemFromExternalList).ConfigureAwait(false); await ErpLocationItemConverter.ConvertAsync(erpLocationItemFromExternalList).ConfigureAwait(false);
Logger.LogInformation($"处理开账【{erpLocationItemFromExternalList.Count}】条数据");
#endregion
#region 采购价格 PurchasePrice
Logger.LogInformation($"Read PurchasePrice");//采购价格 Logger.LogInformation($"读取采购价格 PurchasePrice");//采购价格
var PurchasePriceReader = workerContext.ServiceProvider.GetRequiredService<PurchasePriceReader>(); var PurchasePriceReader = workerContext.ServiceProvider.GetRequiredService<PurchasePriceReader>();
var PurchasePriceConverter = workerContext.ServiceProvider.GetRequiredService<PurchasePriceConverter>(); var PurchasePriceConverter = workerContext.ServiceProvider.GetRequiredService<PurchasePriceConverter>();
//读取并保存PurchasePrice //读取并保存PurchasePrice
var purchasePriceFromExternalList = await PurchasePriceReader.ReadAsync().ConfigureAwait(false); var purchasePriceFromExternalList = await PurchasePriceReader.ReadAsync().ConfigureAwait(false);
//转换PurchasePrice //转换PurchasePrice
await PurchasePriceConverter.ConvertAsync(purchasePriceFromExternalList).ConfigureAwait(false); await PurchasePriceConverter.ConvertAsync(purchasePriceFromExternalList).ConfigureAwait(false);
Logger.LogInformation($"处理采购价格【{purchasePriceFromExternalList.Count}】条数据");
#endregion
Logger.LogInformation($"Read SalePrice");//销售价格 #region 销售价格 SalePrice
Logger.LogInformation($"读取销售价格 SalePrice");//销售价格
var SalePriceReader = workerContext.ServiceProvider.GetRequiredService<SalePriceReader>(); var SalePriceReader = workerContext.ServiceProvider.GetRequiredService<SalePriceReader>();
var SalePriceConverter = workerContext.ServiceProvider.GetRequiredService<SalePriceConverter>(); var SalePriceConverter = workerContext.ServiceProvider.GetRequiredService<SalePriceConverter>();
//读取并保存SalePrice //读取并保存SalePrice
var salePriceFromExternalList = await SalePriceReader.ReadAsync().ConfigureAwait(false); var salePriceFromExternalList = await SalePriceReader.ReadAsync().ConfigureAwait(false);
//转换SalePrice //转换SalePrice
await SalePriceConverter.ConvertAsync(salePriceFromExternalList).ConfigureAwait(false); await SalePriceConverter.ConvertAsync(salePriceFromExternalList).ConfigureAwait(false);
Logger.LogInformation($"处理销售价格【{salePriceFromExternalList.Count}】条数据");
#endregion
Logger.LogInformation($"Read StdCostPrice");//标准成本价格 #region 标准成本价格 StdCostPrice
Logger.LogInformation($"读取标准成本价格 StdCostPrice");//标准成本价格
var StdCostPriceReader = workerContext.ServiceProvider.GetRequiredService<StdCostPriceReader>(); var StdCostPriceReader = workerContext.ServiceProvider.GetRequiredService<StdCostPriceReader>();
var StdCostPriceConverter = workerContext.ServiceProvider.GetRequiredService<StdCostPriceConverter>(); var StdCostPriceConverter = workerContext.ServiceProvider.GetRequiredService<StdCostPriceConverter>();
//读取并保存StdCostPrice //读取并保存StdCostPrice
var stdCostPriceFromExternalList = await StdCostPriceReader.ReadAsync().ConfigureAwait(false); var stdCostPriceFromExternalList = await StdCostPriceReader.ReadAsync().ConfigureAwait(false);
//转换StdCostPrice //转换StdCostPrice
await StdCostPriceConverter.ConvertAsync(stdCostPriceFromExternalList).ConfigureAwait(false); await StdCostPriceConverter.ConvertAsync(stdCostPriceFromExternalList).ConfigureAwait(false);
Logger.LogInformation($"处理标准成本价格【{stdCostPriceFromExternalList.Count}】条数据");
#endregion
} }
else else
{ {
@ -184,7 +222,7 @@ public class TyrpIncomingBackgroundWorker : AsyncPeriodicBackgroundWorkerBase
////转换Customer ////转换Customer
//await BackFlushConverter.ConvertAsync(backFlushsFromExternalList).ConfigureAwait(false); //await BackFlushConverter.ConvertAsync(backFlushsFromExternalList).ConfigureAwait(false);
Logger.LogInformation($"Completed: Handling {Incoming}"); Logger.LogInformation($"提交: 执行 {Incoming}");
} }
} }

87
be/DataExchange/Fawtyg/Win_in.Sfs.Wms.DataExchange.Fawtyg.TyrpAgent/Outgoing/TyrpOutgoingBackgroundWorker.cs

@ -14,7 +14,7 @@ namespace Win_in.Sfs.Wms.DataExchange.Fawtyg.TyrpAgent;
public class TyrpOutgoingBackgroundWorker : AsyncPeriodicBackgroundWorkerBase public class TyrpOutgoingBackgroundWorker : AsyncPeriodicBackgroundWorkerBase
{ {
private readonly string Outgoing = "TYRP Outgoing"; private readonly string Outgoing = "TYRP发送";
private readonly IOptions<TyrpOptions> _options; private readonly IOptions<TyrpOptions> _options;
@ -32,11 +32,11 @@ public class TyrpOutgoingBackgroundWorker : AsyncPeriodicBackgroundWorkerBase
[UnitOfWork(true, isolationLevel: IsolationLevel.ReadUncommitted, 50)] [UnitOfWork(true, isolationLevel: IsolationLevel.ReadUncommitted, 50)]
protected override async Task DoWorkAsync(PeriodicBackgroundWorkerContext workerContext) protected override async Task DoWorkAsync(PeriodicBackgroundWorkerContext workerContext)
{ {
Logger.LogInformation($"Starting: Handling {Outgoing}"); Logger.LogInformation($"开始: 执行 {Outgoing}");
if (!_options.Value.OutgoingOptions.Active) if (!_options.Value.OutgoingOptions.Active)
{ {
Logger.LogInformation($"{Outgoing} is not active!"); Logger.LogInformation($"{Outgoing} 已关闭没有执行!");
return; return;
} }
var scontrolWriter = workerContext.ServiceProvider.GetRequiredService<ScontrolWriter>();//scontrol中间表服务 var scontrolWriter = workerContext.ServiceProvider.GetRequiredService<ScontrolWriter>();//scontrol中间表服务
@ -47,93 +47,93 @@ public class TyrpOutgoingBackgroundWorker : AsyncPeriodicBackgroundWorkerBase
int mesout_asd_count = 0; //mesout_asd插入条数 int mesout_asd_count = 0; //mesout_asd插入条数
#region 采购单 PurchaseOrder scontrol #region 采购单 PurchaseOrder scontrol
Logger.LogInformation($"Write PurchaseOrder");//采购单 Logger.LogInformation($"传出采购单 PurchaseOrder");//采购单
var purchaseOrderConvert = workerContext.ServiceProvider.GetRequiredService<PurchaseOrderConverter>(); var purchaseOrderConvert = workerContext.ServiceProvider.GetRequiredService<PurchaseOrderConverter>();
var purchaseOrderList = await purchaseOrderConvert.ConvertAsync().ConfigureAwait(false); var purchaseOrderList = await purchaseOrderConvert.ConvertAsync().ConfigureAwait(false);
await scontrolWriter.WriteAsync(purchaseOrderList).ConfigureAwait(false); await scontrolWriter.WriteAsync(purchaseOrderList).ConfigureAwait(false);
Logger.LogInformation($"采购单-PurchaseOrder处理{purchaseOrderList.Count}条");
if (purchaseOrderList.Count > 0) if (purchaseOrderList.Count > 0)
{ {
Logger.LogInformation($"采购单-PurchaseOrder处理{purchaseOrderList.Count}条");
scontrol_count += purchaseOrderList.Count; scontrol_count += purchaseOrderList.Count;
} }
#endregion #endregion
#region 采购退货单 PurchaseReturn scontrol #region 采购退货单 PurchaseReturn scontrol
Logger.LogInformation($"Write PurchaseReturn");//采购退货单(汇总) Logger.LogInformation($"传出采购退货单 PurchaseReturn");//采购退货单(汇总)
var purchaseReturnConvert = workerContext.ServiceProvider.GetRequiredService<PurchaseReturnConverter>(); var purchaseReturnConvert = workerContext.ServiceProvider.GetRequiredService<PurchaseReturnConverter>();
var purchaseReturnList = await purchaseReturnConvert.ConvertAsync().ConfigureAwait(false); var purchaseReturnList = await purchaseReturnConvert.ConvertAsync().ConfigureAwait(false);
await scontrolWriter.WriteAsync(purchaseReturnList).ConfigureAwait(false); await scontrolWriter.WriteAsync(purchaseReturnList).ConfigureAwait(false);
Logger.LogInformation($"采购退货单-PurchaseReturn处理{purchaseReturnList.Count}条");
if (purchaseReturnList.Count > 0) if (purchaseReturnList.Count > 0)
{ {
Logger.LogInformation($"采购退货单-PurchaseReturn处理{purchaseReturnList.Count}条");
scontrol_count += purchaseReturnList.Count; scontrol_count += purchaseReturnList.Count;
} }
#endregion #endregion
#region 验收单 Putaway scontrol #region 验收单 Putaway scontrol
Logger.LogInformation($"Write PutawayNote");//验收单(汇总) Logger.LogInformation($"传出验收单 PutawayNote");//验收单(汇总)
var putawayNoteConvert = workerContext.ServiceProvider.GetRequiredService<PutawayNoteConverter>(); var putawayNoteConvert = workerContext.ServiceProvider.GetRequiredService<PutawayNoteConverter>();
var putawayNoteList = await putawayNoteConvert.ConvertAsync().ConfigureAwait(false); var putawayNoteList = await putawayNoteConvert.ConvertAsync().ConfigureAwait(false);
await scontrolWriter.WriteAsync(putawayNoteList).ConfigureAwait(false); await scontrolWriter.WriteAsync(putawayNoteList).ConfigureAwait(false);
Logger.LogInformation($"验收单-Putaway处理{putawayNoteList.Count}条");
if (putawayNoteList.Count > 0) if (putawayNoteList.Count > 0)
{ {
Logger.LogInformation($"验收单-Putaway处理{putawayNoteList.Count}条");
scontrol_count += putawayNoteList.Count; scontrol_count += putawayNoteList.Count;
} }
#endregion #endregion
#region 线边仓领料单 Issue scontrol #region 线边仓领料单 Issue scontrol
Logger.LogInformation($"Write IssueNote");//线边仓领料单(汇总) Logger.LogInformation($"传出线边仓领料单 IssueNote");//线边仓领料单(汇总)
var issueNoteConvert = workerContext.ServiceProvider.GetRequiredService<IssueNoteConverter>(); var issueNoteConvert = workerContext.ServiceProvider.GetRequiredService<IssueNoteConverter>();
var issueNoteList = await issueNoteConvert.ConvertAsync().ConfigureAwait(false); var issueNoteList = await issueNoteConvert.ConvertAsync().ConfigureAwait(false);
await scontrolWriter.WriteAsync(issueNoteList).ConfigureAwait(false); await scontrolWriter.WriteAsync(issueNoteList).ConfigureAwait(false);
Logger.LogInformation($"线边仓领料单-Issue处理{issueNoteList.Count}条");
if (issueNoteList.Count > 0) if (issueNoteList.Count > 0)
{ {
Logger.LogInformation($"线边仓领料单-Issue处理{issueNoteList.Count}条");
scontrol_count += issueNoteList.Count; scontrol_count += issueNoteList.Count;
} }
#endregion #endregion
#region 线边仓退料单 ProductionReturn scontrol #region 线边仓退料单 ProductionReturn scontrol
Logger.LogInformation($"Write ProductionReturnNote");//线边仓退料单(汇总) Logger.LogInformation($"传出线边仓退料单 ProductionReturnNote");//线边仓退料单(汇总)
var productionReturnNoteConvert = workerContext.ServiceProvider.GetRequiredService<ProductionReturnNoteConverter>(); var productionReturnNoteConvert = workerContext.ServiceProvider.GetRequiredService<ProductionReturnNoteConverter>();
var productionReturnNoteList = await productionReturnNoteConvert.ConvertAsync().ConfigureAwait(false); var productionReturnNoteList = await productionReturnNoteConvert.ConvertAsync().ConfigureAwait(false);
await scontrolWriter.WriteAsync(productionReturnNoteList).ConfigureAwait(false); await scontrolWriter.WriteAsync(productionReturnNoteList).ConfigureAwait(false);
Logger.LogInformation($"线边仓退料单-ProductionReturn处理{productionReturnNoteList.Count}条");
if (productionReturnNoteList.Count > 0) if (productionReturnNoteList.Count > 0)
{ {
Logger.LogInformation($"线边仓退料单-ProductionReturn处理{productionReturnNoteList.Count}条");
scontrol_count += productionReturnNoteList.Count; scontrol_count += productionReturnNoteList.Count;
} }
#endregion #endregion
#region 半成品上架 SemiPutaway scontrol #region 半成品上架 SemiPutaway scontrol
Logger.LogInformation($"Write SemiPutawayNote");//半成品上架 Logger.LogInformation($"传出半成品上架 SemiPutawayNote");//半成品上架
var semiPutawayNoteConvert = workerContext.ServiceProvider.GetRequiredService<SemiPutawayNoteConverter>(); var semiPutawayNoteConvert = workerContext.ServiceProvider.GetRequiredService<SemiPutawayNoteConverter>();
var semiPutawayNoteList = await semiPutawayNoteConvert.ConvertAsync().ConfigureAwait(false); var semiPutawayNoteList = await semiPutawayNoteConvert.ConvertAsync().ConfigureAwait(false);
await scontrolWriter.WriteAsync(semiPutawayNoteList).ConfigureAwait(false); await scontrolWriter.WriteAsync(semiPutawayNoteList).ConfigureAwait(false);
Logger.LogInformation($"半成品上架-SemiPutaway处理{semiPutawayNoteList.Count}条");
if (semiPutawayNoteList.Count > 0) if (semiPutawayNoteList.Count > 0)
{ {
Logger.LogInformation($"半成品上架-SemiPutaway处理{semiPutawayNoteList.Count}条");
scontrol_count += semiPutawayNoteList.Count; scontrol_count += semiPutawayNoteList.Count;
} }
#endregion #endregion
#region 储位、线边仓调拨单 和 客户储位调拨单 Transfer scontrol #region 储位、线边仓调拨单 和 客户储位调拨单 Transfer scontrol
Logger.LogInformation($"Write TransferNote");//储位、线边仓调拨单 和 客户储位调拨单(汇总) Logger.LogInformation($"传出储位、线边仓调拨单 和 客户储位调拨单 TransferNote");//储位、线边仓调拨单 和 客户储位调拨单(汇总)
var transferNoteConvert = workerContext.ServiceProvider.GetRequiredService<TransferNoteConverter>(); var transferNoteConvert = workerContext.ServiceProvider.GetRequiredService<TransferNoteConverter>();
var transferNoteList = await transferNoteConvert.ConvertAsync().ConfigureAwait(false); var transferNoteList = await transferNoteConvert.ConvertAsync().ConfigureAwait(false);
var transferNoteForErpList = transferNoteList.Where(r => r.DataType == EnumOutgoingDataType.TransferForErp.ToString()).ToList();//储位、线边仓调拨单 var transferNoteForErpList = transferNoteList.Where(r => r.DataType == EnumOutgoingDataType.TransferForErp.ToString()).ToList();//储位、线边仓调拨单
var transferNoteForCustomList = transferNoteList.Where(r => r.DataType == EnumOutgoingDataType.TransferForCustom.ToString()).ToList();//客户储位调拨单 var transferNoteForCustomList = transferNoteList.Where(r => r.DataType == EnumOutgoingDataType.TransferForCustom.ToString()).ToList();//客户储位调拨单
await scontrolWriter.WriteAsync(transferNoteForErpList).ConfigureAwait(false); await scontrolWriter.WriteAsync(transferNoteForErpList).ConfigureAwait(false);
await wmsoutmWriter.WriteAsync(transferNoteForCustomList).ConfigureAwait(false); await wmsoutmWriter.WriteAsync(transferNoteForCustomList).ConfigureAwait(false);
Logger.LogInformation($"储位、线边仓调拨单-Transfer处理{transferNoteForErpList.Count}条");
Logger.LogInformation($"客户储位调拨单-Transfer处理{transferNoteForCustomList.Count}条");
if (transferNoteForErpList.Count > 0) if (transferNoteForErpList.Count > 0)
{ {
Logger.LogInformation($"储位、线边仓调拨单-Transfer处理{transferNoteForErpList.Count}条");
scontrol_count += transferNoteForErpList.Count; scontrol_count += transferNoteForErpList.Count;
} }
if (transferNoteForCustomList.Count > 0) if (transferNoteForCustomList.Count > 0)
{ {
Logger.LogInformation($"客户储位调拨单-Transfer处理{transferNoteForCustomList.Count}条");
wmsoutm_count += transferNoteForCustomList.Count; wmsoutm_count += transferNoteForCustomList.Count;
} }
#endregion #endregion
@ -145,68 +145,73 @@ public class TyrpOutgoingBackgroundWorker : AsyncPeriodicBackgroundWorkerBase
} }
#region 出货单 Deliver wmsoutm #region 出货单 Deliver wmsoutm
Logger.LogInformation($"Write DeliverNote");//出货单(汇总) Logger.LogInformation($"传出出货单 DeliverNote");//出货单(汇总)
var deliverNoteConvert = workerContext.ServiceProvider.GetRequiredService<DeliverNoteConverter>(); var deliverNoteConvert = workerContext.ServiceProvider.GetRequiredService<DeliverNoteConverter>();
var deliverNoteList = await deliverNoteConvert.ConvertAsync().ConfigureAwait(false); var deliverNoteList = await deliverNoteConvert.ConvertAsync().ConfigureAwait(false);
await wmsoutmWriter.WriteAsync(deliverNoteList).ConfigureAwait(false); await wmsoutmWriter.WriteAsync(deliverNoteList).ConfigureAwait(false);
Logger.LogInformation($"出货单-Deliver处理{deliverNoteList.Count}条");
if (deliverNoteList.Count > 0) if (deliverNoteList.Count > 0)
{ {
Logger.LogInformation($"出货单-Deliver处理{deliverNoteList.Count}条");
wmsoutm_count += deliverNoteList.Count; wmsoutm_count += deliverNoteList.Count;
} }
#endregion #endregion
#region 客户退货单 CustomerReturn wmsoutm #region 客户退货单 CustomerReturn wmsoutm
Logger.LogInformation($"Write CustomerReturnNote");//退货单 Logger.LogInformation($"传出退货单 CustomerReturnNote");//退货单
var customerReturnNoteConvert = workerContext.ServiceProvider.GetRequiredService<CustomerReturnNoteConverter>(); var customerReturnNoteConvert = workerContext.ServiceProvider.GetRequiredService<CustomerReturnNoteConverter>();
var customerReturnNoteList = await customerReturnNoteConvert.ConvertAsync().ConfigureAwait(false); var customerReturnNoteList = await customerReturnNoteConvert.ConvertAsync().ConfigureAwait(false);
await wmsoutmWriter.WriteAsync(customerReturnNoteList).ConfigureAwait(false); await wmsoutmWriter.WriteAsync(customerReturnNoteList).ConfigureAwait(false);
Logger.LogInformation($"退货单-CustomerReturn处理{customerReturnNoteList.Count}条");
if (customerReturnNoteList.Count > 0)
{
wmsoutm_count += customerReturnNoteList.Count;
}
#endregion #endregion
#region 非生产领料单 UnplannedIssue wmsoutm #region 非生产领料单 UnplannedIssue wmsoutm
Logger.LogInformation($"Write UnplannedIssueNote");//非生产领料单(汇总) Logger.LogInformation($"传出非生产领料单 UnplannedIssueNote");//非生产领料单(汇总)
var unplannedIssueNoteConvert = workerContext.ServiceProvider.GetRequiredService<UnplannedIssueNoteConverter>(); var unplannedIssueNoteConvert = workerContext.ServiceProvider.GetRequiredService<UnplannedIssueNoteConverter>();
var unplannedIssueNoteNoteList = await unplannedIssueNoteConvert.ConvertAsync().ConfigureAwait(false); var unplannedIssueNoteNoteList = await unplannedIssueNoteConvert.ConvertAsync().ConfigureAwait(false);
await wmsoutmWriter.WriteAsync(unplannedIssueNoteNoteList).ConfigureAwait(false); await wmsoutmWriter.WriteAsync(unplannedIssueNoteNoteList).ConfigureAwait(false);
Logger.LogInformation($"非生产领料单-UnplannedIssue处理{unplannedIssueNoteNoteList.Count}条");
if (unplannedIssueNoteNoteList.Count > 0) if (unplannedIssueNoteNoteList.Count > 0)
{ {
Logger.LogInformation($"非生产领料单-UnplannedIssue处理{unplannedIssueNoteNoteList.Count}条");
wmsoutm_count += unplannedIssueNoteNoteList.Count; wmsoutm_count += unplannedIssueNoteNoteList.Count;
} }
#endregion #endregion
#region 非生产退料 UnplannedReceipt wmsoutm #region 非生产退料 UnplannedReceipt wmsoutm
Logger.LogInformation($"Write UnplannedReceiptNote");//非生产退料(汇总) Logger.LogInformation($"传出非生产退料 UnplannedReceiptNote");//非生产退料(汇总)
var unplannedReceiptNoteConvert = workerContext.ServiceProvider.GetRequiredService<UnplannedReceiptNoteConverter>(); var unplannedReceiptNoteConvert = workerContext.ServiceProvider.GetRequiredService<UnplannedReceiptNoteConverter>();
var unplannedReceiptNoteList = await unplannedReceiptNoteConvert.ConvertAsync().ConfigureAwait(false); var unplannedReceiptNoteList = await unplannedReceiptNoteConvert.ConvertAsync().ConfigureAwait(false);
await wmsoutmWriter.WriteAsync(unplannedReceiptNoteList).ConfigureAwait(false); await wmsoutmWriter.WriteAsync(unplannedReceiptNoteList).ConfigureAwait(false);
Logger.LogInformation($"非生产退料-UnplannedReceipt处理{unplannedReceiptNoteList.Count}条");
if (unplannedReceiptNoteList.Count > 0) if (unplannedReceiptNoteList.Count > 0)
{ {
Logger.LogInformation($"非生产退料-UnplannedReceipt处理{unplannedReceiptNoteList.Count}条");
wmsoutm_count += unplannedReceiptNoteList.Count; wmsoutm_count += unplannedReceiptNoteList.Count;
} }
#endregion #endregion
#region 回收料入库单 RecycledMaterialReceipt wmsoutm #region 回收料入库单 RecycledMaterialReceipt wmsoutm
Logger.LogInformation($"Write RecycledMaterialReceiptNote");//回收料入库单 Logger.LogInformation($"传出回收料入库单 RecycledMaterialReceiptNote");//回收料入库单
var recycledMaterialReceiptNoteConvert = workerContext.ServiceProvider.GetRequiredService<RecycledMaterialReceiptNoteConverter>(); var recycledMaterialReceiptNoteConvert = workerContext.ServiceProvider.GetRequiredService<RecycledMaterialReceiptNoteConverter>();
var recycledMaterialReceiptNoteList = await recycledMaterialReceiptNoteConvert.ConvertAsync().ConfigureAwait(false); var recycledMaterialReceiptNoteList = await recycledMaterialReceiptNoteConvert.ConvertAsync().ConfigureAwait(false);
await wmsoutmWriter.WriteAsync(recycledMaterialReceiptNoteList).ConfigureAwait(false); await wmsoutmWriter.WriteAsync(recycledMaterialReceiptNoteList).ConfigureAwait(false);
Logger.LogInformation($"回收料入库单-RecycledMaterialReceipt处理{recycledMaterialReceiptNoteList.Count}条");
if (recycledMaterialReceiptNoteList.Count > 0) if (recycledMaterialReceiptNoteList.Count > 0)
{ {
Logger.LogInformation($"回收料入库单-RecycledMaterialReceipt处理{recycledMaterialReceiptNoteList.Count}条");
wmsoutm_count += recycledMaterialReceiptNoteList.Count; wmsoutm_count += recycledMaterialReceiptNoteList.Count;
} }
#endregion #endregion
#region 退拆单 ProductRecycle wmsoutm #region 退拆单 ProductRecycle wmsoutm
Logger.LogInformation($"Write BackFlushNote");//退拆单 Logger.LogInformation($"传出退拆单 BackFlushNote");//退拆单
var productRecycleNoteConvert = workerContext.ServiceProvider.GetRequiredService<ProductRecycleNoteConverter>(); var productRecycleNoteConvert = workerContext.ServiceProvider.GetRequiredService<ProductRecycleNoteConverter>();
var productRecycleNoteList = await productRecycleNoteConvert.ConvertAsync().ConfigureAwait(false); var productRecycleNoteList = await productRecycleNoteConvert.ConvertAsync().ConfigureAwait(false);
await wmsoutmWriter.WriteAsync(productRecycleNoteList).ConfigureAwait(false); await wmsoutmWriter.WriteAsync(productRecycleNoteList).ConfigureAwait(false);
Logger.LogInformation($"退拆单-ProductRecycle处理{productRecycleNoteList.Count}条");
if (productRecycleNoteList.Count > 0) if (productRecycleNoteList.Count > 0)
{ {
Logger.LogInformation($"退拆单-ProductRecycle处理{productRecycleNoteList.Count}条");
wmsoutm_count += productRecycleNoteList.Count; wmsoutm_count += productRecycleNoteList.Count;
} }
#endregion #endregion
@ -219,44 +224,44 @@ public class TyrpOutgoingBackgroundWorker : AsyncPeriodicBackgroundWorkerBase
#region --接口以关闭-- 盘点调整单 CountAdjust mesout_asd #region --接口以关闭-- 盘点调整单 CountAdjust mesout_asd
//东阳上海和安徽暂时关闭此接口 //东阳上海和安徽暂时关闭此接口
//Logger.LogInformation($"Write CountAdjusNote");//盘点调整单 //Logger.LogInformation($"传出 CountAdjusNote");//盘点调整单
//var countadjustNoteConvert = workerContext.ServiceProvider.GetRequiredService<CountAdjustNoteConverter>(); //var countadjustNoteConvert = workerContext.ServiceProvider.GetRequiredService<CountAdjustNoteConverter>();
//var countadjustNoteList = await countadjustNoteConvert.ConvertAsync().ConfigureAwait(false); //var countadjustNoteList = await countadjustNoteConvert.ConvertAsync().ConfigureAwait(false);
//await countadjustWriter.WriteAsync(countadjustNoteList).ConfigureAwait(false); //await countadjustWriter.WriteAsync(countadjustNoteList).ConfigureAwait(false);
#endregion #endregion
#region 线边仓调整单 WIPAdjust mesout_asd #region 线边仓调整单 WIPAdjust mesout_asd
Logger.LogInformation($"Write WIPAdjusNote");//线边仓调整单(汇总) Logger.LogInformation($"传出线边仓调整单 WIPAdjusNote");//线边仓调整单(汇总)
var wipAdjustNoteConvert = workerContext.ServiceProvider.GetRequiredService<WIPAdjusNoteConverter>(); var wipAdjustNoteConvert = workerContext.ServiceProvider.GetRequiredService<WIPAdjusNoteConverter>();
var wipAdjustNoteList = await wipAdjustNoteConvert.ConvertAsync().ConfigureAwait(false); var wipAdjustNoteList = await wipAdjustNoteConvert.ConvertAsync().ConfigureAwait(false);
await countadjustWriter.WriteAsync(wipAdjustNoteList).ConfigureAwait(false); await countadjustWriter.WriteAsync(wipAdjustNoteList).ConfigureAwait(false);
Logger.LogInformation($"线边仓调整单-WIPAdjust处理{wipAdjustNoteList.Count}条");
if (wipAdjustNoteList.Count > 0) if (wipAdjustNoteList.Count > 0)
{ {
Logger.LogInformation($"线边仓调整单-WIPAdjust处理{wipAdjustNoteList.Count}条");
mesout_asd_count += wipAdjustNoteList.Count; mesout_asd_count += wipAdjustNoteList.Count;
} }
#endregion #endregion
#region 回收料调整单 Item_Transform mesout_asd #region 回收料调整单 Item_Transform mesout_asd
Logger.LogInformation($"Write ItemTransformNote");//回收料调整单(汇总) Logger.LogInformation($"传出回收料调整单 ItemTransformNote");//回收料调整单(汇总)
var ItemTransformNoteConvert = workerContext.ServiceProvider.GetRequiredService<ItemTransformNoteConverter>(); var ItemTransformNoteConvert = workerContext.ServiceProvider.GetRequiredService<ItemTransformNoteConverter>();
var ItemTransformNoteList = await ItemTransformNoteConvert.ConvertAsync().ConfigureAwait(false); var ItemTransformNoteList = await ItemTransformNoteConvert.ConvertAsync().ConfigureAwait(false);
await countadjustWriter.WriteAsync(ItemTransformNoteList).ConfigureAwait(false); await countadjustWriter.WriteAsync(ItemTransformNoteList).ConfigureAwait(false);
Logger.LogInformation($"回收料调整单-Item_Transform处理{ItemTransformNoteList.Count}条");
if (ItemTransformNoteList.Count > 0) if (ItemTransformNoteList.Count > 0)
{ {
Logger.LogInformation($"回收料调整单-Item_Transform处理{ItemTransformNoteList.Count}条");
mesout_asd_count += ItemTransformNoteList.Count; mesout_asd_count += ItemTransformNoteList.Count;
} }
#endregion #endregion
#region 报废单、线边仓报废单 Scrap mesout_asd #region 报废单、线边仓报废单 Scrap mesout_asd
Logger.LogInformation($"Write ScrapNote");//报废单、线边仓报废单 Logger.LogInformation($"传出报废单、线边仓报废单 ScrapNote");//报废单、线边仓报废单
var scrapNoteConvert = workerContext.ServiceProvider.GetRequiredService<ScrapNoteConverter>(); var scrapNoteConvert = workerContext.ServiceProvider.GetRequiredService<ScrapNoteConverter>();
var scrapNoteList = await scrapNoteConvert.ConvertAsync().ConfigureAwait(false); var scrapNoteList = await scrapNoteConvert.ConvertAsync().ConfigureAwait(false);
await countadjustWriter.WriteAsync(scrapNoteList).ConfigureAwait(false); await countadjustWriter.WriteAsync(scrapNoteList).ConfigureAwait(false);
Logger.LogInformation($"报废单、线边仓报废单-Scrap处理{scrapNoteList.Count}条");
if (scrapNoteList.Count > 0) if (scrapNoteList.Count > 0)
{ {
Logger.LogInformation($"报废单、线边仓报废单-Scrap处理{scrapNoteList.Count}条");
mesout_asd_count += scrapNoteList.Count; mesout_asd_count += scrapNoteList.Count;
} }
#endregion #endregion
@ -268,18 +273,16 @@ public class TyrpOutgoingBackgroundWorker : AsyncPeriodicBackgroundWorkerBase
} }
#region 缴库单 ProductReceipt mesout #region 缴库单 ProductReceipt mesout
Logger.LogInformation($"Write ProductReceiptNote");//缴库单 Logger.LogInformation($"传出缴库单 ProductReceiptNote");//缴库单
var productReceiptNoteConvert = workerContext.ServiceProvider.GetRequiredService<ProductReceiptNoteConverter>(); var productReceiptNoteConvert = workerContext.ServiceProvider.GetRequiredService<ProductReceiptNoteConverter>();
var productReceiptNoteList = await productReceiptNoteConvert.ConvertAsync().ConfigureAwait(false); var productReceiptNoteList = await productReceiptNoteConvert.ConvertAsync().ConfigureAwait(false);
var productReceiptNoteWriter = workerContext.ServiceProvider.GetRequiredService<ProductReceiptNoteWriter>();//mesout中间表的服务 var productReceiptNoteWriter = workerContext.ServiceProvider.GetRequiredService<ProductReceiptNoteWriter>();//mesout中间表的服务
await productReceiptNoteWriter.WriteAsync(productReceiptNoteList).ConfigureAwait(false); await productReceiptNoteWriter.WriteAsync(productReceiptNoteList).ConfigureAwait(false);
if (productReceiptNoteList.Count > 0) Logger.LogInformation($"缴库单-ProductReceipt处理{productReceiptNoteList.Count}条");
{
Logger.LogInformation($"缴库单-ProductReceipt处理{productReceiptNoteList.Count}条");
}
#endregion #endregion
Logger.LogInformation($"Completed: Handling {Outgoing}"); Logger.LogInformation($"提交: 执行 {Outgoing}");
} }
} }

Loading…
Cancel
Save