zhibinlv
/
WZC2
3
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

接口代码整理

dev_DY_CC
lvzb 10 months ago
parent
650b5eb2cc
commit
fb2d5cf0b5
5 changed files with 156 additions and 96 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 4
      be/DataExchange/Fawtyg/Win_in.Sfs.Wms.DataExchange.Fawtyg.EosAgent/Incoming/EosIncomingBackgroundWorker.cs
  2. 4
      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. 85
      be/DataExchange/Fawtyg/Win_in.Sfs.Wms.DataExchange.Fawtyg.TyrpAgent/Outgoing/TyrpOutgoingBackgroundWorker.cs

4
be/DataExchange/Fawtyg/Win_in.Sfs.Wms.DataExchange.Fawtyg.EosAgent/Incoming/EosIncomingBackgroundWorker.cs
View File

@ -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}");
} }
} }

4
be/DataExchange/Fawtyg/Win_in.Sfs.Wms.DataExchange.Fawtyg.EosAgent/Outgoing/EosOutgoingBackgroundWorker.cs
View File

@ -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
View File

@ -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
View File

@ -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}");
} }
} }

85
be/DataExchange/Fawtyg/Win_in.Sfs.Wms.DataExchange.Fawtyg.TyrpAgent/Outgoing/TyrpOutgoingBackgroundWorker.cs
View File

@ -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}");
} }
} }

Write Preview
Loading…
Cancel
Save