using System;
using System.Data;
using System.Diagnostics;
using System.DirectoryServices.ActiveDirectory;
using System.Dynamic;
using System.Security.Cryptography.X509Certificates;
using System.Security.Policy;
using System.Text;
using System.Text.Json.Nodes;
using System.Text.RegularExpressions;
using System.Threading;
using Aop.Api.Domain;
using Aspose.Cells.Charts;
using Aspose.Cells.Drawing;
using JNPF;
using JNPF.Common.Cache;
using JNPF.Common.Core.Manager;
using JNPF.Common.Dtos.VisualDev;
using JNPF.Common.Extension;
using JNPF.Common.Security;
using JNPF.FriendlyException;
using JNPF.Logging;
using JNPF.Systems.Interfaces.System;
using JNPF.TaskScheduler;
using Microsoft.AspNetCore.Identity;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;
using NetTaste;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using Npgsql;
using NPOI.HPSF;
using NPOI.OpenXmlFormats;
using Org.BouncyCastle.Asn1.X509;
using Org.BouncyCastle.Asn1.X509.Qualified;
using Qiniu.Util;
using Senparc.CO2NET.Helpers.Serializers;
using SqlSugar;
using Tnb.BasicData;
using Tnb.WarehouseMgr.Entities.Dto;
//using Swashbuckle.AspNetCore.SwaggerGen;
using Tnb.BasicData.Entities;
using Tnb.Common.Extension;
using Tnb.Common.Redis;
using Tnb.Common.Utils;
using Tnb.EquipMgr.Entities;
using Tnb.ProductionMgr.Entities;
using Tnb.ProductionMgr.Entities.Dto;
using Tnb.ProductionMgr.Entities.Enums;
using Tnb.ProductionMgr.Interfaces;
using Tnb.WarehouseMgr;
using Tnb.WarehouseMgr.Entities;
using Tnb.WarehouseMgr.Entities.Configs;
using Tnb.WarehouseMgr.Entities.Consts;
using Tnb.WarehouseMgr.Entities.Dto.Inputs;
using Tnb.WarehouseMgr.Entities.Dto.Queries;
using Tnb.WarehouseMgr.Entities.Entity;
using Tnb.WarehouseMgr.Entities.Enums;
using Tnb.WarehouseMgr.Interfaces;
using Org.BouncyCastle.Bcpg.OpenPgp;
using JNPF.Systems.Entitys.Permission;
using JNPF.Systems.Entitys.System;
namespace Tnb.ProductionMgr
{
//redis定时获取数采数据
public class RedisBackGround : IHostedService, IDisposable
{
#region 全局变量
private static Timer? GenTaskExecutetimer;
private static Timer? Readtimer;
private static Timer? CheckGettimer;
private static Timer? Scantimer;
private static Timer? SSXcodetimer;
// 八工位缓存区补充空托盘
private static Timer? BGWCarrySupplementtimer;
// 供料叠盘机空托盘自动入库
private static Timer? YCLGLDPJInstocktimer;
// 外协叠盘机空托盘自动入库
private static Timer? YCLWXDPJInstocktimer;
// 二楼上升降机
private static Timer? Floor2UpMachinecodetimer;
// 二楼料架配送
private static Timer? Floor2timer送空托到上升降区;
private static Timer? Floor2timer送满托到下升降区;
private static Timer? Floor2timer移走上升降区未生成预任务且满托的料架;
private static Timer? Floor2timer移走下升降区未生成预任务且空托的料架;
// 四楼待灭菌仓到灭菌线
private static Timer? Floor4DMJ2MJXtimer;
// 四楼待灭菌线到灭菌仓
private static Timer? Floor4MJX2MJCtimer;
// 四楼灭菌仓到成品库
private static Timer? Floor4DMC2CPKtimer;
// 四楼包材自动到二楼包材库
private static Timer? PackOutstockServicetimer;
// 二楼空托盘自动补充到线边
private static Timer? F2KTPsupplementtimer;
// 原材料仓内转移
private static Timer? YCLInternalTransfertimer;
// 生成物料齐套配送计划
private static Timer? WmsMaterialkittimer;
// 电梯
private static Timer? elevatorTimer;
// 生成AGV到电梯的任务
private static Timer? agvelevatorTimer;
public SemaphoreSlim s_taskCheckGet = new(1);
public SemaphoreSlim s_taskScan = new(1);
public SemaphoreSlim s_taskSSXcode = new(1);
public SemaphoreSlim s_taskBGWCarrySupplement = new(1);
public SemaphoreSlim s_taskYCLGLDPJInstock = new(1);
public SemaphoreSlim s_taskYCLWXDPJInstock = new(1);
public SemaphoreSlim s_taskExecuteFloor2UpMachinecodetimer = new(1);
public SemaphoreSlim s_task送空托到上升降区 = new(1);
public SemaphoreSlim s_task送满托到下升降区 = new(1);
public SemaphoreSlim s_task移走上升降区未生成预任务且满托的料架 = new(1);
public SemaphoreSlim s_task移走下升降区未生成预任务且空托的料架 = new(1);
//public SemaphoreSlim s_taskPackOutstockService = new(1);
public SemaphoreSlim s_taskFloor4DMJ2MJXService = new(1);
public SemaphoreSlim s_taskFloor4MJX2MJCService = new(1);
public SemaphoreSlim s_taskFloor4DMC2CPKService = new(1);
public SemaphoreSlim s_taskF2KTPsupplement = new(1);
public SemaphoreSlim s_taskYCLInternalTransfer = new(1);
public SemaphoreSlim s_taskWmsMaterialkit = new(1);
///
/// AGV到电梯任务
///
private StackExRedisHelper _redisData;
private readonly IPrdInstockService _prdInstockService;
private readonly ISqlSugarRepository _repository;
private ISqlSugarClient db_Scantimer;
private ISqlSugarClient db_CheckGettimer;
private ISqlSugarClient db_SSXcodetimer;
private ISqlSugarClient db_BGWCarrySupplementtimer;
private ISqlSugarClient db_YCLGLDPJInstocktimer;
private ISqlSugarClient db_YCLWXDPJInstocktimer;
private ISqlSugarClient db_Floor2UpMachinecodetimer;
private ISqlSugarClient db_Floor2timer送空托到上升降区;
private ISqlSugarClient db_Floor2timer送满托到下升降区;
private ISqlSugarClient db_Floor2timer移走上升降区未生成预任务且满托的料架;
private ISqlSugarClient db_Floor2timer移走下升降区未生成预任务且空托的料架;
private ISqlSugarClient db_PackOutstockService;
private ISqlSugarClient db_Floor4DMJ2MJX;
private ISqlSugarClient db_Floor4MJX2MJC;
private ISqlSugarClient db_Floor4DMC2CPK;
private ISqlSugarClient db_F2KTPsupplement;
private ISqlSugarClient db_YCLInternalTransfer;
private ISqlSugarClient db_WmsMaterialkit;
private readonly IWmsPDAScanInStockService _wmsPDAScanInStock;
private readonly IUserManager _userManager;
private readonly IBillRullService _billRullService;
private readonly IWareHouseService _wareHouseService;
private readonly IWmsCarryBindService _wmsCarryBindService;
private readonly IWmsCarryUnbindService _wmsCarryUnbindService;
private readonly IWmsEmptyOutstockService _wmsEmptyOutstockService;
private readonly IWmsPackOutstockService _wmsPackOutstockService;
private readonly IWmsMaterialTransferService _wmsMaterialTransferService;
private readonly ElevatorControlConfiguration _eleCtlCfg = App.Configuration.Build();
static ConnectionStringsOptions connectionOpts = App.GetConfig("ConnectionStrings", true);
static ConnectionConfig cfg = new()
{
ConfigId = connectionOpts.ConfigId,
ConnectionString = connectionOpts.ConnectString,
DbType = SqlSugar.DbType.PostgreSQL,
IsAutoCloseConnection = true,
};
#endregion
#region 构造函数
public RedisBackGround(StackExRedisHelper redisData, IPrdInstockService prdInstockService, ISqlSugarRepository repository, IWmsPDAScanInStockService wmsPDAScanInStock
, IUserManager userManager, IBillRullService billRullService, IWareHouseService wareHouseService, IWmsCarryBindService wmsCarryBindService,
IWmsCarryUnbindService wmsCarryUnbindService, IWmsEmptyOutstockService wmsEmptyOutstockService, IWmsPackOutstockService wmsPackOutstockService,
IWmsMaterialTransferService wmsMaterialTransferService)
{
_redisData = redisData;
_prdInstockService = prdInstockService;
_repository = repository;
_wmsPDAScanInStock = wmsPDAScanInStock;
_userManager = userManager;
_billRullService = billRullService;
_wareHouseService = wareHouseService;
_wmsCarryBindService = wmsCarryBindService;
_wmsEmptyOutstockService = wmsEmptyOutstockService;
_wmsCarryUnbindService = wmsCarryUnbindService;
_wmsPackOutstockService = wmsPackOutstockService;
_wmsMaterialTransferService = wmsMaterialTransferService;
db_CheckGettimer = repository.CopyNew();
db_Scantimer = repository.CopyNew();
db_SSXcodetimer = repository.CopyNew();
db_BGWCarrySupplementtimer = repository.CopyNew();
db_YCLGLDPJInstocktimer = repository.CopyNew();
db_YCLWXDPJInstocktimer = repository.CopyNew();
db_Floor2UpMachinecodetimer = repository.CopyNew();
db_Floor2timer送空托到上升降区 = repository.CopyNew();
db_Floor2timer送满托到下升降区 = repository.CopyNew();
db_Floor2timer移走上升降区未生成预任务且满托的料架 = repository.CopyNew();
db_Floor2timer移走下升降区未生成预任务且空托的料架 = repository.CopyNew();
db_PackOutstockService = repository.CopyNew();
db_Floor4DMJ2MJX = repository.CopyNew();
db_Floor4MJX2MJC = repository.CopyNew();
db_Floor4DMC2CPK = repository.CopyNew();
db_F2KTPsupplement = repository.CopyNew();
db_YCLInternalTransfer = repository.CopyNew();
db_WmsMaterialkit = repository.CopyNew();
List elevatorAreas = repository.CopyNew().Queryable().Select(r => r.area_code).Distinct().ToList();
foreach (var s_elevatorArea in elevatorAreas)
{
ISqlSugarClient db_ElevatorTaskExceptionHandle = repository.CopyNew();
_wareHouseService.db_ElevatorTaskExceptionHandles.Add(db_ElevatorTaskExceptionHandle);
SemaphoreSlim s_elevatortask = new(1);
_wareHouseService.s_elevatortaskDic.Add(s_elevatorArea, s_elevatortask);
SemaphoreSlim s_elevatortaskWCSRequest = new(1);
_wareHouseService.s_elevatortaskWCSRequestDic.Add(s_elevatorArea, s_elevatortaskWCSRequest);
}
}
#endregion
#region ctu取货
//ctu取货
private async void CheckGet(object? state)
{
if (s_taskCheckGet.CurrentCount == 0)
return;
await s_taskCheckGet.WaitAsync();
Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();
try
{
Console.WriteLine($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")} 开始执行CheckGet");
LoggerTimer.LogInformation($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")} 开始执行CheckGet");
Dictionary getdic = new Dictionary();
getdic.Add("SSX-021-005", new string[] { "YTCS", "AllowFullOut_CS05", "LiftCode" });
getdic.Add("SSX-011-002", new string[] { "YTCS", "AllowAgvFullIn_CS02", "Code_CS02" });
getdic.Add("SSX-011-004", new string[] { "YTCS", "AllowCtuFullOut_CS04", "Code_CS04" });
getdic.Add("SSX-011-008", new string[] { "东面提升机输送线", "入库输送线8允许出箱", "入库输送线8条码" });
getdic.Add("SSX-111-011", new string[] { "东面提升机输送线", "下升降机11允许出箱", "下升降机11条码" });
getdic.Add("SSX-111-012", new string[] { "东面提升机输送线", "下升降机12允许出箱", "下升降机12条码" });
getdic.Add("ZSSSXCTU02", new string[] { "YTCS", "AllowAgvEmptyOut_CS03", "" });
getdic.Add("ZSSSXCTU01", new string[] { "YTCS", "AllowAgvEmptyOut_CS01", "" });
// s_taskCheckGet
foreach (var key in getdic.Keys)
{
var strs = getdic.Where(p => p.Key == key).First().Value;
bool result = await GetBoolTag(strs[0], strs[1]);
if (result)
{
if (!string.IsNullOrEmpty(strs[2]))
{
string coderesult = await GetStringTag(strs[0], strs[2]);
coderesult = coderesult.Replace("\r", "").Replace("\\r", "").Replace(" ", "");
if (string.IsNullOrEmpty(coderesult))
{
continue;
}
LoggerSSX.LogInformation($@"【定时任务CheckGet】 成功取到{strs[2]}值:{coderesult}");
//using (var _db = _repository.AsSugarClient().CopyNew())
//{
var DistaskH = db_CheckGettimer.Queryable().Where(p => p.carry_code == coderesult && p.status == WmsWareHouseConst.TASK_BILL_STATUS_YXD_ID && string.IsNullOrEmpty(p.extras)).First();
if (DistaskH != null)
{
LoggerSSX.LogInformation($@"【定时任务CheckGet】 成功找到载具:{coderesult} 对应的任务执行单{DistaskH.bill_code}");
dynamic reqBody = new ExpandoObject();
reqBody.taskCode = DistaskH.bill_code;
reqBody.slotCode = key;
reqBody.containerCode = coderesult;
CancellationTokenSource Ctu = new();
LoggerSSX.LogInformation($"【定时任务CheckGet】 开始发送请求到 http://192.168.11.104:1880/wcs/notify/cargo 载具:{coderesult}");
dynamic respBody = HttpClientHelper.PostStreamAsync("http://192.168.11.104:1880/wcs/notify/cargo", reqBody, Ctu.Token).Result;
LoggerSSX.LogInformation($"【定时任务CheckGet】 接收请求 http://192.168.11.104:1880/wcs/notify/cargo 结果 {respBody} ");
DistaskH.extras = respBody;
db_CheckGettimer.Updateable(DistaskH).ExecuteCommand();
Ctu.Dispose();
}
else
{
LoggerSSX.LogInformation($@"【定时任务CheckGet】 {key}->{strs[0]} {strs[2]}
采集结果:{$@"任务执行(wms_distask_h)中找不到匹配的记录 任务执行需要存在载具编号(carry_code)为{coderesult}
且单据状态(status)为已下达(26126853976101) 且扩展字段(extras)为空的记录 (可能是WCS系统中存在载具{coderesult}的历史任务未清空)
select extras,* from wms_distask_h
where carry_code = '{coderesult}' and status = '{WmsWareHouseConst.TASK_BILL_STATUS_YXD_ID}' "}");
}
//}
}
}
}
}
catch (NpgsqlException ex)
{
Console.WriteLine("【CheckGet】" + ex.Message);
LoggerSSX.LogError(ex.ToString());
//db_CheckGettimer = new SqlSugarClient(cfg);
}
catch (Exception ex)
{
Console.WriteLine("【CheckGet】" + ex.Message);
LoggerSSX.LogError(ex.ToString());
}
finally
{
s_taskCheckGet.Release();
stopwatch.Stop();
Console.WriteLine($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")} 结束执行CheckGet {stopwatch.ElapsedMilliseconds} ms");
LoggerTimer.LogInformation($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")} 结束执行CheckGet {stopwatch.ElapsedMilliseconds} ms");
}
}
#endregion
#region 弃用
////获取redis数据
//private async void GetRedisData(object? state)
//{
// var _redisReadConfigs = _repository.AsQueryable().Where(p => p.enabled == 1).ToList();
// foreach (var config in _redisReadConfigs)
// {
// try
// {
// var json = await _redisData.GetHash(config.dev_name!, config.tag_name!);
// if (json == null)
// {
// continue;
// }
// JObject? res = JsonConvert.DeserializeObject(json);
// if (config.data_type == (int)DataType.INT)
// {
// if (config.check_type == (int)CheckType.相等)
// {
// if (res.Value("Value") == int.Parse(config.data!))
// {
// InstockInput instockInput = new()
// {
// equip_code = res["DevName"]!.ToString(),
// label_code = res["TagName"]!.ToString()
// };
// TriggerEvent((EventType)config.event_type, instockInput);
// }
// }
// else if (config.check_type == (int)CheckType.包含)
// {
// int[] ints = Array.ConvertAll(config.data!.Replace("[", "").Replace("]", "").Split(",", StringSplitOptions.RemoveEmptyEntries), int.Parse);
// if (ints.Contains(res.Value("Value")))
// {
// InstockInput instockInput = new()
// {
// equip_code = res["DevName"]!.ToString(),
// label_code = res["TagName"]!.ToString()
// };
// TriggerEvent((EventType)config.event_type, instockInput);
// }
// }
// }
// else if (config.data_type == (int)DataType.BOOL)
// {
// if (config.check_type == (int)CheckType.相等)
// {
// if (res.Value("Value") == bool.Parse(config.data!))
// {
// InstockInput instockInput = new()
// {
// equip_code = res["DevName"]!.ToString(),
// label_code = res["TagName"]!.ToString()
// };
// TriggerEvent((EventType)config.event_type, instockInput);
// }
// }
// }
// }
// catch (Exception)
// {
// }
// }
//}
private void TriggerEvent(EventType eventType, InstockInput instockInput)
{
switch (eventType)
{
case EventType.注塑空满箱请求:
_prdInstockService.InstockTypeOne(instockInput);
break;
case EventType.挤出空满箱请求:
_prdInstockService.InstockTubeOne(instockInput);
break;
case EventType.限位请求:
_prdInstockService.InstockOutPack(instockInput);
break;
default:
break;
}
}
#endregion
#region 八工位
//扫码入库
private async void ScanInStock(object? state)
{
if (_wareHouseService.s_taskExecuteSemaphore_YCLInstock.CurrentCount == 0)
return;
await _wareHouseService.s_taskExecuteSemaphore_YCLInstock.WaitAsync();
Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();
try
{
Console.WriteLine($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")} 开始执行ScanInStock");
LoggerTimer.LogInformation($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")} 开始执行ScanInStock");
Dictionary getdic = new Dictionary();
getdic.Add("BGWRKYCL02", new string[] { "CP8", "AllowGetFullBox1", "code1", "PutDoneEmptyBox", "false" });
getdic.Add("BGWRKYCL01", new string[] { "CP8", "AllowGetFullBox2", "code2", "PutDoneEmptyBox", "false" });
foreach (var key in getdic.Keys)
{
var strs = getdic.Where(p => p.Key == key).First().Value;
bool result = await GetBoolTag(strs[0], strs[1]);
if (result)
{
LoggerBGWCarrySupplement.LogInformation($"【ScanInStock】 八工位 {key} {strs[1]}采集到 {result}");
Dictionary dicCommand = new(StringComparer.OrdinalIgnoreCase)
{
["DevName"] = strs[0],
["token"] = _eleCtlCfg.token,
["TagName"] = strs[3],
["Value"] = strs[4],
};
LoggerBGWCarrySupplement.LogInformation($"【ScanInStock】 八工位 {key} 发送PutDoneEmptyBox指令 {_eleCtlCfg.WriteTagUrl} {JsonConvert.SerializeObject(dicCommand)}");
HttpClientHelper.GetRequestAsync(_eleCtlCfg.WriteTagUrl, dicCommand).Wait();
string coderesult = await GetStringTag(strs[0], strs[2]);
LoggerBGWCarrySupplement.LogInformation($"【ScanInStock】 八工位 {key} 获取到扫码信息: {coderesult}");
//using (var _db = _repository.AsSugarClient().CopyNew())
{
WmsCarryH? carry = db_Scantimer.Queryable().Single(it => it.carry_code == coderesult);
LoggerBGWCarrySupplement.LogInformation($"【ScanInStock】 八工位 {key} 查找{coderesult}绑定的托盘: {JsonConvert.SerializeObject(carry)}");
if (carry.location_id != WmsWareHouseConst.LOCATION_YCLBGWDRK)
{
LoggerBGWCarrySupplement.LogInformation($"【ScanInStock】 八工位 {key} 查找{coderesult}绑定的托盘{carry.carry_code}不是待入库状态(还未绑定物料)，此时不能生成入库任务(防止重复生成任务)");
continue;
}
if (carry != null)
{
if (db_Scantimer.Queryable().Where(p => p.carry_id == carry.id && p.status != WmsWareHouseConst.TASK_BILL_STATUS_COMPLE_ID && p.status != WmsWareHouseConst.TASK_BILL_STATUS_CANCEL_ID).Any())
{
LoggerBGWCarrySupplement.LogInformation($"【ScanInStock】 八工位 {key} 托盘 {carry.carry_code} 找到了执行任务状态(status)既不是26126860808229(已完成)也不是26126863175461(已取消)的历史任务，此时不能执行入库");
continue;
}
var WmsCarryCode = db_Scantimer.Queryable().Where(it => it.carry_id == carry.id).OrderByDescending(it => it.id).First();
// 用适当的字段替换 YourTimestampField
if (WmsCarryCode != null)
{
LoggerBGWCarrySupplement.LogInformation($"【ScanInStock】 八工位 {key} 查找到托盘{carry.carry_code}在WmsCarryCode中存在");
VisualDevModelDataCrInput input = new VisualDevModelDataCrInput();
input.data = new Dictionary();
input.data.Add("barcode", coderesult);
input.data.Add("codeqty", WmsCarryCode.codeqty);//条码数量
input.data.Add("material_code", WmsCarryCode.material_code);
input.data.Add("extras", key);//location_code
input.data.Add("warehouse_id", "1");//TEST
input.data.Add("bill_code", "");//采购收货单号
input.data.Add("code_batch", WmsCarryCode.code_batch!);//批次
input.data.Add("material_specification", WmsCarryCode.material_specification!);//规格型号
input.data.Add("container_no", WmsCarryCode.container_no!);//箱号
input.data.Add("material_id", WmsCarryCode.material_id);
input.data.Add("物料条码", WmsCarryCode.barcode);
input.data.Add("id", null);
_wmsPDAScanInStock.ScanInStockByRedis(input, db_Scantimer).Wait();
}
else
{
LoggerBGWCarrySupplement.LogInformation($"【ScanInStock】 八工位 {key} 托盘 {carry.carry_code} 未绑定物料条码！");
}
}
}
}
}
}
catch (ObjectDisposedException ex)
{
LoggerBGWCarrySupplement.LogError($"【ScanInStock】 数据库连接异常:{ex.Message}");
LoggerBGWCarrySupplement.LogError($"【ScanInStock】 数据库连接异常:{ex.StackTrace}");
if (ex.Source == "Npgsql")
db_Scantimer = _repository.AsSugarClient().CopyNew();
}
catch (Exception ex)
{
Console.WriteLine("【ScanInStock】" + ex.Message);
LoggerBGWCarrySupplement.LogError($"【ScanInStock】 八工位扫到码发送入库请求发生异常:{ex}");
// 数据库连接断开时会报错
try { await db_Scantimer.Ado.RollbackTranAsync(); } catch { };
}
finally
{
_wareHouseService.s_taskExecuteSemaphore_YCLInstock.Release();
stopwatch.Stop();
Console.WriteLine($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")} 结束执行ScanInStock {stopwatch.ElapsedMilliseconds} ms");
LoggerTimer.LogInformation($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")} 结束执行ScanInStock {stopwatch.ElapsedMilliseconds} ms");
}
}
///
/// 八工位空托盘补充
///
private async void BGWCarrySupplement(object? state)
{
if (s_taskBGWCarrySupplement.CurrentCount == 0)
return;
await s_taskBGWCarrySupplement.WaitAsync();
Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();
try
{
Console.WriteLine($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")} 开始执行BGWCarrySupplement");
LoggerTimer.LogInformation($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")} 开始执行BGWCarrySupplement");
Dictionary getdic = new Dictionary();
getdic.Add("YCLCKBGW", new string[] { "CP8", "AllowPutEmptyBox1" });
await db_BGWCarrySupplementtimer.Ado.BeginTranAsync();
foreach (var key in getdic.Keys)
{
var strs = getdic.Where(p => p.Key == key).First().Value;
bool result = await GetBoolTag(strs[0], strs[1]);
if (result)
{
LoggerBGWCarrySupplement.LogInformation($"【BGWCarrySupplementtimer】读取到信号{strs[1]} 值为{result} ");
//using (var _db = _repository.AsSugarClient().CopyNew())
{
BasLocation endLocation = db_BGWCarrySupplementtimer.Queryable().Where(r => r.location_code == key).First();
if (endLocation == null)
{
LoggerBGWCarrySupplement.LogWarning($"【BGWCarrySupplementtimer】 {key}未维护库位信息");
continue;
}
if (endLocation.is_lock == 1)
{
LoggerBGWCarrySupplement.LogInformation($"【BGWCarrySupplementtimer】 八工位 {key} 已锁定");
continue;
}
// 未锁定且已占用且库位中没有记录托盘 此时认为是叠盘机送过来的
// 20241018 业务变更
var wmsLoc = db_BGWCarrySupplementtimer.Queryable()
.LeftJoin((a, b) => a.id == b.location_id)
.Where((a, b) => a.is_lock == 0 && a.is_use == "1"
&& a.wh_id == WmsWareHouseConst.WAREHOUSE_YCL_ID && a.location_code.Contains("YCL-")
&& a.is_type == "0")
.OrderBy((a, b) => a.location_code) // 当前是按库位排序出库
.Select((a, b) => new
{
BasLocation = a,
WmsCarryH = b
}).ToList().GroupBy(p => p.BasLocation)
.Where(group =>
{
// 是否存在托盘
bool isExistsCarry = false;
foreach (var item in group)
{
if (!string.IsNullOrEmpty(item.WmsCarryH.carry_code))
{
isExistsCarry = true;
break;
}
}
if (isExistsCarry)
return false;
else
return true;
}).Select(r => r.Key).ToList();
if (wmsLoc.Count() == 0)
{
OutStockStrategyQuery OutStockStrategyInput = new()
{
carrystd_id = WmsWareHouseConst.CARRY_TP_ID,
warehouse_id = WmsWareHouseConst.WAREHOUSE_YCL_ID,
Size = 1
};
List? carrys = await _wareHouseService.OutStockStrategy(OutStockStrategyInput, db_BGWCarrySupplementtimer);
if (carrys.Count > 0)
{
wmsLoc = await db_BGWCarrySupplementtimer.Queryable().Where(r => r.id == carrys[0].location_id).ToListAsync();
}
}
if (wmsLoc.Count() == 0)
{
LoggerBGWCarrySupplement.LogInformation($"【BGWCarrySupplementtimer】 没有未锁定且已占用且库位中没有记录托盘的数据");
continue;
}
WmsPretaskH wmsPretaskH = db_BGWCarrySupplementtimer.Queryable().Where(r => r.endlocation_code == endLocation.location_code
&& r.status != WmsWareHouseConst.PRETASK_BILL_STATUS_COMPLE_ID && r.status != WmsWareHouseConst.PRETASK_BILL_STATUS_CANCEL_ID).First();
if (wmsPretaskH != null)
{
LoggerBGWCarrySupplement.LogWarning($"【BGWCarrySupplementtimer】存在未完成的预任务{wmsPretaskH.bill_code} 不能送托盘！");
continue;
}
BasLocation startLocation = wmsLoc.First();
//锁定起点库位
await db_BGWCarrySupplementtimer.Updateable().SetColumns(r => r.is_lock == 1).Where(r => r.id == startLocation.id).ExecuteCommandAsync();
////锁定终点库位 更新为空闲
//await _db.Updateable().SetColumns(r => new BasLocation { is_lock = 1, is_use = "0" }).Where(r => r.id == endLocation.id).ExecuteCommandAsync();
LoggerBGWCarrySupplement.LogInformation($"【BGWCarrySupplementtimer】锁定起点库位 开始生成 {startLocation.location_code} 到 {endLocation.location_code} 预任务 ");
bool result_createPretask = await createPretask(startLocation.id, endLocation.id, "", "", LoggerBGWCarrySupplement, db_BGWCarrySupplementtimer);
if (!result_createPretask)
{
LoggerBGWCarrySupplement.LogWarning($"【BGWCarrySupplementtimer】 {startLocation.location_code} 到 {endLocation.location_code} 预任务生成失败 ");
throw new Exception($"【BGWCarrySupplementtimer】 {startLocation.location_code} 到 {endLocation.location_code} 预任务生成失败");
}
LoggerBGWCarrySupplement.LogInformation($"【BGWCarrySupplementtimer】 {startLocation.location_code} 到 {endLocation.location_code} 预任务生成成功");
}
_ = _wareHouseService.GenTaskExecute();
}
}
await db_BGWCarrySupplementtimer.Ado.CommitTranAsync();
}
catch (ObjectDisposedException ex)
{
LoggerBGWCarrySupplement.LogError($"【BGWCarrySupplementtimer】 数据库连接异常:{ex.Message}");
LoggerBGWCarrySupplement.LogError($"【BGWCarrySupplementtimer】 数据库连接异常:{ex.StackTrace}");
if (ex.Source == "Npgsql")
db_BGWCarrySupplementtimer = _repository.AsSugarClient().CopyNew();
}
catch (Exception ex)
{
Console.WriteLine("【BGWCarrySupplement】" + ex.Message);
LoggerBGWCarrySupplement.LogError($"【BGWCarrySupplementtimer】 数据库连接异常:{ex}");
// 数据库连接断开时会报错
try { await db_BGWCarrySupplementtimer.Ado.RollbackTranAsync(); } catch { };
}
finally
{
s_taskBGWCarrySupplement.Release();
stopwatch.Stop();
Console.WriteLine($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")} 结束执行BGWCarrySupplement {stopwatch.ElapsedMilliseconds} ms");
LoggerTimer.LogInformation($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")} 结束执行BGWCarrySupplement {stopwatch.ElapsedMilliseconds} ms");
}
}
///
/// 原材料仓内转移
///
///
private async void YCLInternalTransfer(object? state)
{
if (_wareHouseService.s_taskExecuteSemaphore_YCLInstock.CurrentCount == 0)
return;
if (_wareHouseService.s_taskExecuteSemaphore_YCLOutstock.CurrentCount == 0)
return;
var YCLInnerTransfer = await db_YCLInternalTransfer.Queryable().Where(p => p.key == "YCLInnerTransfer").FirstAsync();
// 0则不进行移转
if (YCLInnerTransfer != null && YCLInnerTransfer.value == "0")
{
return;
}
await _wareHouseService.s_taskExecuteSemaphore_YCLInstock.WaitAsync();
await _wareHouseService.s_taskExecuteSemaphore_YCLOutstock.WaitAsync();
Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();
try
{
Console.WriteLine($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")} 开始执行YCLInternalTransfer");
LoggerTimer.LogInformation($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")} 开始执行YCLInternalTransfer");
OutStockStrategyQuery outStockStrategyInput = new()
{
warehouse_id = WmsWareHouseConst.WAREHOUSE_YCL_ID,
Region_id = WmsWareHouseConst.REGION_YCLCache_ID,
AvoidBusyPassage = true,
Size = 76,
filter_carry_status = false
};
List items = await _wareHouseService.OutStockStrategy(outStockStrategyInput);
if (items.Count < 1)
{
LoggerYCLInternalTransfer.LogWarning($"【YCLInternalTransfer】 没有可以出库的载具");
return;
}
#region 小件物料入外协存储区
var carry_mats = await db_YCLInternalTransfer.Queryable()
.InnerJoin((a, b) => a.material_id == b.id)
.Where((a, b) => items.Select(r => r.id).Contains(a.carry_id)).Select((a, b) => new carry_matEntity
{
carry_id = a.carry_id,
material_code = b.code,
categorys = b.category_id
}).ToListAsync();
foreach (var row in carry_mats)
{
row.category_list = JsonConvert.DeserializeObject>(row.categorys);
}
var basRegionMats = await db_YCLInternalTransfer.Queryable()
.InnerJoin((a, b) => a.material_type == b.Id).Select((a, b) => new
{
region_id = a.region_id,
region_code = a.region_code,
category = b.EnCode
}).ToListAsync();
for (int carry_mat_index = 0; carry_mat_index < carry_mats.Count; carry_mat_index++)
{
var carry_mat = carry_mats[carry_mat_index];
bool isexists = false;
foreach (var basRegionMat in basRegionMats)
{
if (carry_mat.category_list.Contains(basRegionMat.category))
{
carry_mat.category = basRegionMat.category;
carry_mat.region_id = basRegionMat.region_id;
carry_mat.region_code = basRegionMat.region_code;
isexists = true;
break;
}
}
if (!isexists)
{
carry_mats.RemoveAt(carry_mat_index); carry_mat_index--;
}
}
#endregion
foreach (WmsCarryH wmsCarryH in items)
{
BasLocation startlocation = await db_YCLInternalTransfer.Queryable().Where(r => r.id == wmsCarryH.location_id).FirstAsync();
InStockStrategyQuery inStockStrategyInput = null;
List endLocations = new List();
// 小件物料入外协存储区
var carry_mat = carry_mats.Where(r => r.carry_id == wmsCarryH.id).FirstOrDefault();
if (carry_mat != null && !string.IsNullOrEmpty(carry_mat.category))
{
inStockStrategyInput = new() { warehouse_id = "1", Size = 1, passage = startlocation.passage, AvoidBusyPassage = true, Region_id = carry_mat.region_id, PolicyCode = WmsWareHouseConst.POLICY_YCLINSTOCK };
endLocations = await _wareHouseService.InStockStrategy(inStockStrategyInput);
LoggerYCLInternalTransfer.LogInformation($"【ScanInStockByRedis】托盘物料{carry_mat.material_code} 物料类型为{carry_mat.category} 配置的入库区域为{carry_mat.region_code} 巷道{startlocation.passage} 托盘{wmsCarryH.carry_code}在检查外协存储区库存时找到可入库位数量为{endLocations.Count}");
}
if (endLocations?.Count == 0)
{
inStockStrategyInput = new() { warehouse_id = "1", Size = 1, passage = startlocation.passage, AvoidBusyPassage = true, Region_id = WmsWareHouseConst.REGION_Purchase_ID, PolicyCode = WmsWareHouseConst.POLICY_YCLINSTOCK };
endLocations = await _wareHouseService.InStockStrategy(inStockStrategyInput);
LoggerYCLInternalTransfer.LogInformation($"【ScanInStockByRedis】托盘{wmsCarryH.carry_code} 巷道{startlocation.passage} 在检查采购存储区库存时找到可入库位数量为{endLocations.Count}");
}
if (endLocations.Count() == 0)
{
LoggerYCLInternalTransfer.LogWarning($"【YCLInternalTransfer】 当前巷道没有空库位可以入库或者有任务正在执行");
continue;
}
BasLocation endLocation = endLocations.First();
await db_YCLInternalTransfer.Ado.BeginTranAsync();
LoggerYCLInternalTransfer.LogInformation($"【YCLInternalTransfer】托盘{wmsCarryH.carry_code} {wmsCarryH.location_code} 转移到 {endLocation.location_code}");
bool result_createPretask = await createPretask(wmsCarryH.location_id, endLocation.id, wmsCarryH.id, wmsCarryH.carry_code, LoggerYCLInternalTransfer, db_YCLInternalTransfer);
if (!result_createPretask)
{
LoggerYCLInternalTransfer.LogWarning($"【YCLInternalTransfer】 {wmsCarryH.location_code} 到 {endLocation.location_code} 预任务生成失败");
throw new Exception($"【YCLInternalTransfer】 {wmsCarryH.location_code} 到 {endLocation.location_code} 预任务生成失败");
}
LoggerYCLInternalTransfer.LogWarning($"【YCLInternalTransfer】 {wmsCarryH.location_code} 到 {endLocation.location_code} 预任务生成成功");
await db_YCLInternalTransfer.Ado.CommitTranAsync();
}
_ = _wareHouseService.GenTaskExecute();
}
catch (ObjectDisposedException ex)
{
LoggerYCLInternalTransfer.LogError($"【YCLInternalTransfer】 数据库连接异常:{ex.Message}");
LoggerYCLInternalTransfer.LogError($"【YCLInternalTransfer】 数据库连接异常:{ex.StackTrace}");
if (ex.Source == "Npgsql")
db_YCLInternalTransfer = _repository.AsSugarClient().CopyNew();
}
catch (Exception ex)
{
Console.WriteLine("【YCLInternalTransfer】" + ex.Message);
LoggerYCLInternalTransfer.LogError($"【YCLInternalTransfer】 数据库连接异常:{ex}");
// 数据库连接断开时会报错
try { await db_YCLInternalTransfer.Ado.RollbackTranAsync(); } catch { };
}
finally
{
_wareHouseService.s_taskExecuteSemaphore_YCLInstock.Release();
_wareHouseService.s_taskExecuteSemaphore_YCLOutstock.Release();
stopwatch.Stop();
Console.WriteLine($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")} 结束执行YCLInternalTransfer {stopwatch.ElapsedMilliseconds} ms");
LoggerTimer.LogInformation($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")} 结束执行YCLInternalTransfer {stopwatch.ElapsedMilliseconds} ms");
}
}
///
/// 供料叠盘机空托盘自动入库
///
private async void YCLGLDPJInstock(object? state)
{
if (_wareHouseService.s_taskExecuteSemaphore_YCLInstock.CurrentCount == 0)
return;
await _wareHouseService.s_taskExecuteSemaphore_YCLInstock.WaitAsync();
Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();
try
{
Console.WriteLine($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")} 开始执行YCLGLDPJInstock");
LoggerTimer.LogInformation($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")} 开始执行YCLGLDPJInstock");
Dictionary getdic = new Dictionary();
getdic.Add("SGW-YCL", new string[] { "CP3-5", "AllowGetFullBox" });
await db_YCLGLDPJInstocktimer.Ado.BeginTranAsync();
foreach (var key in getdic.Keys)
{
var strs = getdic.Where(p => p.Key == key).First().Value;
bool result = await GetBoolTag(strs[0], strs[1]);
if (result)
{
LoggerYCLGLDPJInstock.LogInformation($"【YCLGLDPJInstock】 三工位叠盘机 {key} {strs[1]}采集到 {result}");
//using (var db = _repository.AsSugarClient().CopyNew())
{
BasLocation startLocation = db_YCLGLDPJInstocktimer.Queryable().Where(r => r.location_code == key).First();
if (startLocation == null)
{
LoggerYCLGLDPJInstock.LogWarning($"【YCLGLDPJInstock】 {key}未维护库位信息");
continue;
}
if (startLocation.is_lock == 1)
{
LoggerYCLGLDPJInstock.LogInformation($"【YCLGLDPJInstock】 三工位叠盘机 {key} 已锁定");
continue;
}
// 找到未锁定且未占用的库位
InStockStrategyQuery inStockStrategyInput = new() { warehouse_id = "1", Size = 1, AvoidBusyPassage = true, Region_id = WmsWareHouseConst.REGION_Purchase_ID };
List endLocations = await _wareHouseService.InStockStrategy(inStockStrategyInput);
if (endLocations.Count() == 0)
{
LoggerYCLGLDPJInstock.LogWarning($"【YCLGLDPJInstock】 当前没有空库位可以入库");
continue;
}
BasLocation endLocation = endLocations.First();
//锁定起点库位 更新为空闲
await db_YCLGLDPJInstocktimer.Updateable().SetColumns(r => new BasLocation { is_lock = 1, is_use = "0" }).Where(r => r.id == startLocation.id).ExecuteCommandAsync();
//锁定终点库位
await db_YCLGLDPJInstocktimer.Updateable().SetColumns(r => new BasLocation { is_lock = 1 }).Where(r => r.id == endLocation.id).ExecuteCommandAsync();
bool result_createPretask = await createPretask(startLocation.id, endLocation.id, "", "", LoggerYCLGLDPJInstock, db_YCLGLDPJInstocktimer, "", "", "", WmsWareHouseConst.WMS_PRETASK_INSTOCK_TYPE_ID);
if (!result_createPretask)
{
LoggerYCLGLDPJInstock.LogWarning($"【YCLGLDPJInstock】 {startLocation.location_code} 到 {endLocation.location_code} 预任务生成失败");
throw new Exception($"【YCLGLDPJInstock】 {startLocation.location_code} 到 {endLocation.location_code} 预任务生成失败");
}
LoggerYCLGLDPJInstock.LogWarning($"【YCLGLDPJInstock】 {startLocation.location_code} 到 {endLocation.location_code} 预任务生成成功");
}
_ = _wareHouseService.GenTaskExecute();
}
}
await db_YCLGLDPJInstocktimer.Ado.CommitTranAsync();
}
catch (ObjectDisposedException ex)
{
LoggerYCLGLDPJInstock.LogError($"【YCLGLDPJInstock】 数据库连接异常:{ex.Message}");
LoggerYCLGLDPJInstock.LogError($"【YCLGLDPJInstock】 数据库连接异常:{ex.StackTrace}");
if (ex.Source == "Npgsql")
db_YCLGLDPJInstocktimer = _repository.AsSugarClient().CopyNew();
}
catch (Exception ex)
{
Console.WriteLine("【YCLGLDPJInstock】" + ex.Message);
LoggerYCLGLDPJInstock.LogError($"【YCLGLDPJInstock】 数据库连接异常:{ex}");
// 数据库连接断开时会报错
try { await db_YCLGLDPJInstocktimer.Ado.RollbackTranAsync(); } catch { };
}
finally
{
_wareHouseService.s_taskExecuteSemaphore_YCLInstock.Release();
stopwatch.Stop();
Console.WriteLine($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")} 结束执行YCLGLDPJInstock {stopwatch.ElapsedMilliseconds} ms");
LoggerTimer.LogInformation($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")} 结束执行YCLGLDPJInstock {stopwatch.ElapsedMilliseconds} ms");
}
}
///
/// 外协叠盘机空托盘自动入库
///
private async void YCLWXDPJInstock(object? state)
{
if (_wareHouseService.s_taskExecuteSemaphore_YCLInstock.CurrentCount == 0)
return;
await _wareHouseService.s_taskExecuteSemaphore_YCLInstock.WaitAsync();
Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();
try
{
Console.WriteLine($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")} 开始执行YCLWXDPJInstock");
LoggerTimer.LogInformation($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")} 开始执行YCLWXDPJInstock");
Dictionary getdic = new Dictionary();
getdic.Add("SCW-YCL", new string[] { "CP3-3", "AllowGetFullBox" });
await db_YCLWXDPJInstocktimer.Ado.BeginTranAsync();
foreach (var key in getdic.Keys)
{
var strs = getdic.Where(p => p.Key == key).First().Value;
bool result = await GetBoolTag(strs[0], strs[1]);
if (result)
{
LoggerYCLGLDPJInstock.LogInformation($"【YCLWXDPJInstock】 外协叠盘机 {key} {strs[1]}采集到 {result}");
BasLocation startLocation = db_YCLWXDPJInstocktimer.Queryable().Where(r => r.location_code == key).First();
if (startLocation == null)
{
LoggerYCLGLDPJInstock.LogWarning($"【YCLWXDPJInstock】 {key}未维护库位信息");
continue;
}
if (startLocation.is_lock == 1)
{
LoggerYCLGLDPJInstock.LogInformation($"【YCLWXDPJInstock】 外协叠盘机 {key} 已锁定");
continue;
}
// 找到未锁定且未占用的库位
InStockStrategyQuery inStockStrategyInput = new() { warehouse_id = "1", Size = 1, AvoidBusyPassage = true, Region_id = WmsWareHouseConst.REGION_Purchase_ID };
List endLocations = await _wareHouseService.InStockStrategy(inStockStrategyInput);
if (endLocations.Count() == 0)
{
LoggerYCLGLDPJInstock.LogWarning($"【YCLWXDPJInstock】 当前没有空库位可以入库");
continue;
}
BasLocation endLocation = endLocations.First();
//锁定起点库位 更新为空闲
await db_YCLWXDPJInstocktimer.Updateable().SetColumns(r => new BasLocation { is_lock = 1, is_use = "0" }).Where(r => r.id == startLocation.id).ExecuteCommandAsync();
//锁定终点库位
await db_YCLWXDPJInstocktimer.Updateable().SetColumns(r => new BasLocation { is_lock = 1 }).Where(r => r.id == endLocation.id).ExecuteCommandAsync();
bool result_createPretask = await createPretask(startLocation.id, endLocation.id, "", "", LoggerYCLGLDPJInstock, db_YCLWXDPJInstocktimer, "", "", "", WmsWareHouseConst.WMS_PRETASK_INSTOCK_TYPE_ID);
if (!result_createPretask)
{
LoggerYCLGLDPJInstock.LogWarning($"【YCLWXDPJInstock】 {startLocation.location_code} 到 {endLocation.location_code} 预任务生成失败");
throw new Exception($"【YCLWXDPJInstock】 {startLocation.location_code} 到 {endLocation.location_code} 预任务生成失败");
}
LoggerYCLGLDPJInstock.LogWarning($"【YCLWXDPJInstock】 {startLocation.location_code} 到 {endLocation.location_code} 预任务生成成功");
_ = _wareHouseService.GenTaskExecute();
}
}
await db_YCLWXDPJInstocktimer.Ado.CommitTranAsync();
}
catch (ObjectDisposedException ex)
{
LoggerYCLGLDPJInstock.LogError($"【YCLWXDPJInstock】 数据库连接异常:{ex.Message}");
LoggerYCLGLDPJInstock.LogError($"【YCLWXDPJInstock】 数据库连接异常:{ex.StackTrace}");
if (ex.Source == "Npgsql")
db_YCLWXDPJInstocktimer = _repository.AsSugarClient().CopyNew();
}
catch (Exception ex)
{
Console.WriteLine("【YCLGLDPJInstock】" + ex.Message);
LoggerYCLGLDPJInstock.LogError($"【YCLWXDPJInstock】 数据库连接异常:{ex}");
// 数据库连接断开时会报错
try { await db_YCLWXDPJInstocktimer.Ado.RollbackTranAsync(); } catch { };
}
finally
{
_wareHouseService.s_taskExecuteSemaphore_YCLInstock.Release();
stopwatch.Stop();
Console.WriteLine($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")} 结束执行YCLWXDPJInstock {stopwatch.ElapsedMilliseconds} ms");
LoggerTimer.LogInformation($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")} 结束执行YCLWXDPJInstock {stopwatch.ElapsedMilliseconds} ms");
}
}
#endregion
#region 中储仓
private async void SSXcode(object? state)
{
if (s_taskSSXcode.CurrentCount == 0)
return;
await s_taskSSXcode.WaitAsync();
Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();
try
{
Console.WriteLine($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")} 开始执行SSXcode");
LoggerTimer.LogInformation($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")} 开始执行SSXcode");
Dictionary dic = new Dictionary();
dic.Add("东面提升机输送线", new string[] { "下升降机判断请求", "下升降机判断条码", "下升降机判断完毕", "下升降机判断结果" });
Dictionary putdic = new Dictionary();
putdic.Add("SSX-111-011", 11);
putdic.Add("SSX-111-012", 12);
foreach (var key in dic.Keys)
{
var strs = dic.Where(p => p.Key == key).First().Value;
JObject reObj = await GetObjectTag(key, strs[0]);
if (reObj == null)
continue;
bool re = false;
DateTime timestamp_judgeCode = DateTime.MinValue;
if (reObj.TryGetValue("Value", out JToken valueToken1))
{
re = bool.Parse(valueToken1.ToString());
if (reObj.TryGetValue("TimeStamp", out JToken valueToken2))
timestamp_judgeCode = DateTime.Parse(valueToken2.ToString());
}
if (!re)
continue;
JObject reObj_code = await GetObjectTag(key, strs[1]);
if (reObj_code == null)
continue;
string? result = "";
DateTime timestamp_code = DateTime.MinValue;
if (reObj_code.TryGetValue("Value", out JToken valueToken3))
{
result = valueToken3.ToString();
if (reObj_code.TryGetValue("TimeStamp", out JToken valueToken4))
timestamp_code = DateTime.Parse(valueToken4.ToString());
}
if (!string.IsNullOrEmpty(result))
{
if (result.Length < 5)
{
result = "LX" + result.Replace("\r", "");
}
if (timestamp_judgeCode < timestamp_code)
{
LoggerSSX.LogInformation($"【定时任务SSXcode】下升降机入中储仓 判定料箱{result}的条码判断请求信号时间{timestamp_judgeCode.ToString("yyyy-MM-dd HH:mm:ss")} 早于条码更新的时间{timestamp_code.ToString("yyyy-MM-dd HH:mm:ss")},将跳过此次执行");
continue;
}
var DistaskH = db_SSXcodetimer.Queryable().Where(p => p.carry_code == result && p.status != WmsWareHouseConst.TASK_BILL_STATUS_COMPLE_ID && p.status != WmsWareHouseConst.TASK_BILL_STATUS_CANCEL_ID).OrderByDescending(p => p.create_time).First();
if (DistaskH != null)
{
string target = putdic.Keys.Contains(DistaskH.startlocation_code) ? putdic.Where(p => p.Key == DistaskH.startlocation_code).First().Value.ToString() : "13";
LoggerSSX.LogInformation($"【定时任务SSXcode】下升降机入中储仓任务{DistaskH.bill_code} 判定料箱{result} 去{target}线");
Dictionary dicCommand2 = new(StringComparer.OrdinalIgnoreCase)
{
["DevName"] = key,
["token"] = _eleCtlCfg.token,
["TagName"] = strs[3],
["Value"] = target,
};
HttpClientHelper.GetRequestAsync(_eleCtlCfg.WriteTagUrl, dicCommand2).Wait();
Dictionary dicCommand = new(StringComparer.OrdinalIgnoreCase)
{
["DevName"] = key,
["token"] = _eleCtlCfg.token,
["TagName"] = strs[2],
["Value"] = "true",
};
HttpClientHelper.GetRequestAsync(_eleCtlCfg.WriteTagUrl, dicCommand).Wait();
}
else
{
LoggerSSX.LogInformation($"【定时任务SSXcode】找不到料箱对应的下升降机入中储仓任务 判定料箱{result} 去13线 ");
Dictionary dicCommand2 = new(StringComparer.OrdinalIgnoreCase)
{
["DevName"] = key,
["token"] = _eleCtlCfg.token,
["TagName"] = strs[3],
["Value"] = "13",
};
HttpClientHelper.GetRequestAsync(_eleCtlCfg.WriteTagUrl, dicCommand2).Wait();
Dictionary dicCommand = new(StringComparer.OrdinalIgnoreCase)
{
["DevName"] = key,
["token"] = _eleCtlCfg.token,
["TagName"] = strs[2],
["Value"] = "true",
};
HttpClientHelper.GetRequestAsync(_eleCtlCfg.WriteTagUrl, dicCommand).Wait();
}
}
}
}
catch (Exception ex)
{
Console.WriteLine("【SSXcode】" + ex.Message);
LoggerSSX.LogInformation($"【定时任务SSXcode】发生异常 {ex}");
}
finally
{
s_taskSSXcode.Release();
stopwatch.Stop();
Console.WriteLine($"{DateTime.Now.ToString($"yyyy-MM-dd HH:mm:ss")} 结束执行SSXcode {stopwatch.ElapsedMilliseconds} ms");
LoggerTimer.LogInformation($"{DateTime.Now.ToString($"yyyy-MM-dd HH:mm:ss")} 结束执行SSXcode {stopwatch.ElapsedMilliseconds} ms");
}
}
#endregion
#region 二楼上升降机机械臂
// 上升降机扫码 需要等待空料架区 此处需要轮询
private async void Floor2UpMachinecode(object? args)
{
if (s_taskExecuteFloor2UpMachinecodetimer.CurrentCount == 0)
return;
s_taskExecuteFloor2UpMachinecodetimer.Wait();
Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();
try
{
Console.WriteLine($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")} 开始执行Floor2UpMachinecode");
LoggerTimer.LogInformation($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")} 开始执行Floor2UpMachinecode");
string barcode = await GetStringTag("东面提升机输送线", MechanicalArmConsts.上升降机条码);
if (string.IsNullOrEmpty(barcode))
{
LoggerFloor2UpDownMachine.LogError($@"【上升降机】未取到条码数据");
return;
}
//using (var db = _repository.AsSugarClient().CopyNew())
{
// 读取上升降机的左右料架区配置
string[] configs = new string[2] { "二楼上升降机机械臂左", "二楼上升降机机械臂右" };
// 左右料架区配置
List WmsMechanicalArmHs = db_Floor2UpMachinecodetimer.Queryable()
.Where(r => configs.Contains(r.name) && r.agvconfirm == 1).ToList();
// 是否可以放货
if (WmsMechanicalArmHs.Count == 0)
{
LoggerFloor2UpDownMachine.LogWarning($@"【上升降机】目前没有可以放货的料架区(料架区一个料架都没有，如果实际有料架说明系统缓存表与实际不对应，需要重置缓存表信息)");
return;
}
// 如果条码已被绑定
if (WmsMechanicalArmHs.Where(r => !string.IsNullOrEmpty(r.barcodes) && r.barcodes.Contains(barcode)).Count() > 0)
{
LoggerFloor2UpDownMachine.LogWarning($@"【上升降机】条码{barcode}已被绑定");
return;
}
LoggerFloor2UpDownMachine.LogInformation($@"【上升降机】扫描到有效条码 {barcode}");
// 获取下到输送线9和10的未完成的转库单
List WmsMaterialTransfers = db_Floor2UpMachinecodetimer.Queryable()
.InnerJoin((a, b) => a.id == b.bill_id)
.Where((a, b) => (a.warehouse_instock == WmsWareHouseConst.WAREHOUSE_ZCC_ID || a.warehouse_instock == WmsWareHouseConst.WAREHOUSE_HCC_ID || a.warehouse_instock == WmsWareHouseConst.WAREHOUSE_ZZXBK_ID) && a.warehouse_outstock == "2" && a.remainbindracknum > 0
&& b.carry_code == barcode).ToList();
if (WmsMaterialTransfers.Count() == 0)
{
LoggerFloor2UpDownMachine.LogWarning($@"【上升降机】未找到条码{barcode}的输送线为9、10的转库单，可能是出入仓库选择有误或者此载具在中储仓发生了错乱");
return;
}
// 转库单
WmsMaterialTransfer WmsMaterialTransfer = WmsMaterialTransfers.OrderByDescending(r => r.create_time).First();
// 找到条码在的转库单
string ckdCode = WmsMaterialTransfer.bill_code;
int ckdRemainBindRackNum = (int)(WmsMaterialTransfer.remainbindracknum != null ? WmsMaterialTransfer.remainbindracknum : 0);
//扫描到的料箱 a.对应转库单的b.码垛计数未达到满托数量的料架区
IEnumerable targetConfigs = WmsMechanicalArmHs.Where(r => r.outbill == ckdCode && r.stackingcount < r.maxnum);
WmsMechanicalArmH target;
await db_Floor2UpMachinecodetimer.Ado.BeginTranAsync();
// 找不到对应的料架
if (targetConfigs.Count() == 0)
{
// 有空闲料架区且绑定了料架时
targetConfigs = WmsMechanicalArmHs.Where(r => string.IsNullOrEmpty(r.outbill)).OrderBy(r => r.id);
if (targetConfigs.Count() > 0)
{
target = targetConfigs.First();
// 计算当前料架区的满托数量
int? maxnum = ckdRemainBindRackNum > target.maxracknum ? target.maxracknum : ckdRemainBindRackNum;
// 更新 转库单、满托数量
LoggerFloor2UpDownMachine.LogInformation($@"【上升降机】为条码 {barcode} 所在的转库单 {ckdCode} 占用了一个空闲料架");
await db_Floor2UpMachinecodetimer.Updateable().SetColumns(r => new WmsMechanicalArmH
{
outbill = ckdCode,
maxnum = maxnum
}).Where(r => r.id == target.id).ExecuteCommandAsync();
bool result = await Floor2UpDownMachinecode_SetTag($"上升降机满托{target.stackingposition}数量", maxnum.ToString());
LoggerFloor2UpDownMachine.LogInformation($@"【上升降机】设定升降机满托{target.stackingposition}满托数量为 {maxnum} 结果为 {result}");
if (!result)
{
throw new Exception($@"【上升降机】设定升降机满托{target.stackingposition}满托数量为 {maxnum} 结果为 {result}");
}
// 尝试写入空托送到信号
bool result上升降机空托送到 = await Floor2UpDownMachinecode_SetTag($"上升降机空托{target.stackingposition}送到", "true");
LoggerFloor2UpDownMachine.LogInformation($@"【上升降机】回写 上升降机空托{target.stackingposition}送到 结果为{result上升降机空托送到}");
if (!result上升降机空托送到)
{
return;
}
}
else
{
LoggerFloor2UpDownMachine.LogError($@"【上升降机】条码{barcode}找不到绑定转库单{ckdCode}的料架区，且没有空闲的料架区可以用于绑定此转库单！");
await db_Floor2UpMachinecodetimer.Ado.RollbackTranAsync();
return;
}
}
//如有多个料架绑定同个转库单则取第一个未满托的料架
target = targetConfigs.First();
LoggerFloor2UpDownMachine.LogInformation($@"【上升降机】当前条码目标料架区为 {JsonConvert.SerializeObject(target)}");
// 料架信息
WmsCarryH rack = db_Floor2UpMachinecodetimer.Queryable().Where(r => r.id == target.rackid).ToList()[0];
// 料箱信息
WmsCarryH LX = db_Floor2UpMachinecodetimer.Queryable().Where(r => r.carry_code == barcode).ToList()[0];
// 绑定料箱到料架
CarryBindInput carryBindInput = new();
carryBindInput.carry_id = target.rackid;
carryBindInput.carry_code = target.rackcode;
carryBindInput.membercarry_id = LX.id;
carryBindInput.membercarry_code = LX.carry_code;
carryBindInput.carrystd_id = rack.carrystd_id;
carryBindInput.source_code = target.outbill;
int row = await db_Floor2UpMachinecodetimer.Updateable().SetColumns(r => r.carry_status == ((int)(EnumCarryStatus.齐套)).ToString()).Where(r => r.id == target.rackid).ExecuteCommandAsync();
if (row == 0)
{
throw new Exception($"【上升降机】料架{target.rackcode}状态回写失败");
}
WarehouseMgr.Entities.Dto.Outputs.Result bindResult = await _wmsCarryBindService.CarryBind(carryBindInput, db_Floor2UpMachinecodetimer);
if (bindResult.code != JNPF.Common.Enums.HttpStatusCode.OK)
{
throw new Exception(bindResult.msg);
}
// 回写料箱条码、码垛计数
await db_Floor2UpMachinecodetimer.Updateable().SetColumns(r => new WmsMechanicalArmH
{
barcodes = $"{target.barcodes},{barcode}".Trim(','),
stackingcount = r.stackingcount + 1,
mechanicalconfirm = 1
}).Where(r => r.id == target.id).ExecuteCommandAsync();
LoggerFloor2UpDownMachine.LogInformation($@"【上升降机】回写料箱条码、码垛计数");
// 回写转库单的剩余可绑定料架数量
await db_Floor2UpMachinecodetimer.Updateable().SetColumns(r => new WmsMaterialTransfer
{
remainbindracknum = r.remainbindracknum - 1
}).Where(r => r.id == WmsMaterialTransfer.id).ExecuteCommandAsync();
LoggerFloor2UpDownMachine.LogInformation($@"【上升降机】回写转库单的剩余可绑定料架数量");
// 开始码垛
bool result_开始码垛 = await Floor2UpDownMachinecode_SetTag(MechanicalArmConsts.上升降机当前码垛位, target.stackingposition.ToString());
LoggerFloor2UpDownMachine.LogInformation($@"【上升降机】码垛位{target.stackingposition}码垛结果 {result_开始码垛}");
if (!result_开始码垛)
{
throw new Exception($@"【上升降机】码垛结果 {result_开始码垛}");
}
await db_Floor2UpMachinecodetimer.Ado.CommitTranAsync();
}
}
catch (ObjectDisposedException ex)
{
LoggerFloor2UpDownMachine.LogError($"【上升降机】 数据库连接异常:{ex.Message}");
LoggerFloor2UpDownMachine.LogError($"【上升降机】 数据库连接异常:{ex.StackTrace}");
if (ex.Source == "Npgsql")
db_Floor2UpMachinecodetimer = _repository.AsSugarClient().CopyNew();
}
catch (Exception ex)
{
Console.WriteLine("【上升降机】" + ex.Message);
LoggerFloor2UpDownMachine.LogError($"【上升降机】 数据库连接异常:{ex}");
// 数据库连接断开时会报错
try { await db_Floor2UpMachinecodetimer.Ado.RollbackTranAsync(); } catch { };
}
finally
{
s_taskExecuteFloor2UpMachinecodetimer.Release();
if (!db_Floor2UpMachinecodetimer.Ado.Transaction.IsNull())
try { await db_Floor2UpMachinecodetimer.Ado.CommitTranAsync(); } catch { };
stopwatch.Stop();
Console.WriteLine($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")} 结束执行Floor2UpMachinecode {stopwatch.ElapsedMilliseconds} ms");
LoggerTimer.LogInformation($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")} 结束执行Floor2UpMachinecode {stopwatch.ElapsedMilliseconds} ms");
}
}
// 二楼机械臂信号对应机械臂字典
Dictionary floor2mechanicalAtmDic = new Dictionary()
{
{"上升降机请求送空托1","二楼上升降机机械臂左"},
{"上升降机请求送空托2","二楼上升降机机械臂右"},
{"下升降机请求送满托1","二楼下升降机机械臂左"},
{"下升降机请求送满托2","二楼下升降机机械臂右"},
{"上升降机请求取满托1","二楼上升降机机械臂左"},
{"上升降机请求取满托2","二楼上升降机机械臂右"},
{"下升降机请求取空托1","二楼下升降机机械臂左"},
{"下升降机请求取空托2","二楼下升降机机械臂右"},
};
///
/// 送空托到上升降区
///
///
public async void 送空托到上升降区(object? args)
{
if (_wareHouseService.s_taskExecuteSemaphore_F2ZCCOutstock.CurrentCount == 0)
return;
await _wareHouseService.s_taskExecuteSemaphore_F2ZCCOutstock.WaitAsync();
Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();
try
{
Console.WriteLine($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")} 开始执行送空托到上升降区");
LoggerTimer.LogInformation($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")} 开始执行送空托到上升降区");
#region 检查信号
List configs_upMachine = new List();
if (await GetBoolTag("东面提升机输送线", $"上升降机请求送空托1"))
{
LoggerFloor2RackDelivery.LogInformation($"【送空托到上升降区】上升降机请求送空托1 true");
configs_upMachine.Add(floor2mechanicalAtmDic["上升降机请求送空托1"]);
}
if (await GetBoolTag("东面提升机输送线", $"上升降机请求送空托2"))
{
LoggerFloor2RackDelivery.LogInformation($"【送空托到上升降区】上升降机请求送空托2 true");
configs_upMachine.Add(floor2mechanicalAtmDic["上升降机请求送空托2"]);
}
// 没有有效信号
if (configs_upMachine.Count == 0)
return;
#endregion
//using (var db = _repository.AsSugarClient().CopyNew())
{
// 找到没有绑定料架的且库位未锁定的料架区
ISugarQueryable WmsMechanicalArmHsuagar = db_Floor2timer送空托到上升降区.Queryable()
.InnerJoin((a, b) => a.location_id == b.id)
.Where((a, b) => string.IsNullOrEmpty(a.rackcode) && b.is_lock == 0 && configs_upMachine.Contains(a.name));
List WmsMechanicalArmHs = WmsMechanicalArmHsuagar.ToList();
if (WmsMechanicalArmHs.Count() == 0)
{
LoggerFloor2RackDelivery.LogWarning($"【送空托到上升降区】 无需补充料架区 {WmsMechanicalArmHsuagar.ToSqlString()}");
return;
}
await db_Floor2timer送空托到上升降区.Ado.BeginTranAsync();
// 料架区
foreach (WmsMechanicalArmH wmsMechanicalArmH in WmsMechanicalArmHs)
{
// 找到占用且未锁定的库位上的空料架
ISugarQueryable rackStartLocations =
db_Floor2timer送空托到上升降区.Queryable()
.InnerJoin((a, b) => a.id == b.location_id)
.LeftJoin((a, b, c) => b.id == c.carry_id)
.Where((a, b, c) => a.wh_id == "33780009364245" && a.is_use == "1" && a.is_lock == 0 && a.is_type == "0" && string.IsNullOrEmpty(c.id)
&& b.carrystd_id == WmsWareHouseConst.CARRY_LJSTD_ID).OrderBy(a => a.id).Take(1);
if (rackStartLocations.Count() == 0)
{
LoggerFloor2RackDelivery.LogWarning($"【送空托到上升降区】 暂存仓中没有可用的空料架 {rackStartLocations.ToSqlString()}");
continue;
}
LoggerFloor2RackDelivery.LogInformation($"【送空托到上升降区】 即将补充料架区{wmsMechanicalArmH.name}");
BasLocation startLocation = rackStartLocations.First();
List wmsCarryHs = db_Floor2timer送空托到上升降区.Queryable().Where(r => r.location_id == startLocation.id
&& r.carrystd_id == WmsWareHouseConst.CARRY_LJSTD_ID).ToList();
if (wmsCarryHs.Count == 0)
{
LoggerFloor2RackDelivery.LogError($"【送空托到上升降区】 起点{startLocation.id} {startLocation.location_code}上找不到料架");
continue;
}
if (wmsCarryHs.Count > 1)
{
LoggerFloor2RackDelivery.LogError($"【送空托到上升降区】 起点{startLocation.id} {startLocation.location_code}上存在多个料架");
continue;
}
WmsPretaskH wmsPretaskH = db_Floor2timer送空托到上升降区.Queryable().Where(r => r.endlocation_code == wmsMechanicalArmH.location_code
&& r.status != WmsWareHouseConst.PRETASK_BILL_STATUS_COMPLE_ID && r.status != WmsWareHouseConst.PRETASK_BILL_STATUS_CANCEL_ID).First();
if (wmsPretaskH != null)
{
LoggerFloor2RackDelivery.LogWarning($"【送空托到上升降区】料架区{wmsMechanicalArmH.location_code}存在未完成的预任务{wmsPretaskH.bill_code}！");
continue;
}
// 空料架
WmsCarryH targetCarry = wmsCarryHs[0];
await db_Floor2timer送空托到上升降区.Updateable().SetColumns(r => new BasLocation
{
is_lock = 1
}).Where(r => r.id == startLocation.id).ExecuteCommandAsync();
await db_Floor2timer送空托到上升降区.Updateable().SetColumns(r => new BasLocation
{
is_lock = 1
}).Where(r => r.id == wmsMechanicalArmH.location_id).ExecuteCommandAsync();
LoggerFloor2RackDelivery.LogInformation($"【送空托到上升降区】 开始生成预任务 起点{startLocation.location_code} 终点{wmsMechanicalArmH.location_code} 料架 {targetCarry.carry_code}");
bool result = await createPretask(startLocation.id, wmsMechanicalArmH.location_id, targetCarry.id, targetCarry.carry_code, LoggerFloor2RackDelivery, db_Floor2timer送空托到上升降区, WmsWareHouseConst.BIZTYPE_ZCCKNZY_ID);
if (!result)
{
LoggerFloor2RackDelivery.LogInformation($"【送空托到上升降区】 未成功生成预任务 起点{startLocation.location_code} 终点{wmsMechanicalArmH.location_code} 料架 {targetCarry.carry_code}");
throw new Exception($"【送空托到上升降区】 未成功生成预任务 起点{startLocation.location_code} 终点{wmsMechanicalArmH.location_code} 料架 {wmsMechanicalArmH.rackcode}");
}
}
await db_Floor2timer送空托到上升降区.Ado.CommitTranAsync();
}
}
catch (ObjectDisposedException ex)
{
LoggerFloor2RackDelivery.LogError($"【送空托到上升降区】 数据库连接异常:{ex.Message}");
LoggerFloor2RackDelivery.LogError($"【送空托到上升降区】 数据库连接异常:{ex.StackTrace}");
if (ex.Source == "Npgsql")
db_Floor2timer送空托到上升降区 = _repository.AsSugarClient().CopyNew();
}
catch (Exception ex)
{
Console.WriteLine("【上升降机】" + ex.Message);
LoggerFloor2RackDelivery.LogError($"【送空托到上升降区】 {ex.Message}");
LoggerFloor2RackDelivery.LogError($"【送空托到上升降区】 {ex.StackTrace}");
// 数据库连接断开时会报错
try { await db_Floor2timer送空托到上升降区.Ado.RollbackTranAsync(); } catch { };
}
finally
{
_wareHouseService.s_taskExecuteSemaphore_F2ZCCOutstock.Release();
if (!db_Floor2timer送空托到上升降区.Ado.Transaction.IsNull())
try { await db_Floor2timer送空托到上升降区.Ado.CommitTranAsync(); } catch { };
_wareHouseService.GenTaskExecute();
stopwatch.Stop();
Console.WriteLine($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")} 结束执行送空托到上升降区 {stopwatch.ElapsedMilliseconds} ms");
LoggerTimer.LogInformation($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")} 结束执行送空托到上升降区 {stopwatch.ElapsedMilliseconds} ms");
}
}
///
/// 送满托到下升降区
///
///
public async void 送满托到下升降区(object? args)
{
if (_wareHouseService.s_taskExecuteSemaphore_F2ZCCOutstock.CurrentCount == 0)
return;
await _wareHouseService.s_taskExecuteSemaphore_F2ZCCOutstock.WaitAsync();
Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();
try
{
Console.WriteLine($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")} 开始执行送满托到下升降区");
LoggerTimer.LogInformation($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")} 开始执行送满托到下升降区");
#region 检查信号
List configs_upMachine = new List();
if (await GetBoolTag("东面提升机输送线", $"下升降机请求送满托1"))
{
LoggerFloor2RackDelivery.LogInformation($"【送满托到下升降区】下升降机请求送满托1 true");
configs_upMachine.Add(floor2mechanicalAtmDic["下升降机请求送满托1"]);
}
if (await GetBoolTag("东面提升机输送线", $"下升降机请求送满托2"))
{
LoggerFloor2RackDelivery.LogInformation($"【送满托到下升降区】下升降机请求送满托2 true");
configs_upMachine.Add(floor2mechanicalAtmDic["下升降机请求送满托2"]);
}
// 没有有效信号
if (configs_upMachine.Count == 0)
return;
#endregion
//using (var db = _repository.AsSugarClient().CopyNew())
{
// 找到没有绑定料架的且库位未锁定的料架区
ISugarQueryable WmsMechanicalArmHsuagar = db_Floor2timer送满托到下升降区.Queryable()
.InnerJoin((a, b) => a.location_id == b.id)
.Where((a, b) => string.IsNullOrEmpty(a.rackcode) && b.is_lock == 0 && b.is_use == "0" && configs_upMachine.Contains(a.name));
List WmsMechanicalArmHs = WmsMechanicalArmHsuagar.ToList();
if (WmsMechanicalArmHs.Count() == 0)
{
LoggerFloor2RackDelivery.LogWarning($"【送满托到下升降区】 无需补充料架区 {WmsMechanicalArmHsuagar.ToSqlString()}");
return;
}
await db_Floor2timer送满托到下升降区.Ado.BeginTranAsync();
// 料架区
foreach (WmsMechanicalArmH wmsMechanicalArmH in WmsMechanicalArmHs)
{
// 找到占用且未锁定的库位上的满料架且料架中的料箱是空的
List rackStartLocations =
db_Floor2timer送满托到下升降区.Queryable()
.InnerJoin((a, b) => a.id == b.location_id)
.LeftJoin((a, b, c) => b.id == c.carry_id) // 有料箱
.LeftJoin((a, b, c, d) => c.membercarry_id == d.carry_id)
.Where((a, b, c, d) => a.wh_id == "33780009364245" && a.is_use == "1" && a.is_lock == 0 && a.is_type == "0" && !string.IsNullOrEmpty(c.id)
&& b.carrystd_id == WmsWareHouseConst.CARRY_LJSTD_ID).OrderBy((a, b, c, d) => d.id).Select((a, b, c, d) => new // 关联载具物料明细表
{
wmsCarryH = b,
basLocation = a,
WmsCarryCode_id = d.id
}).ToList().GroupBy(r => r.basLocation.location_code).Select(r =>
{
var item = r.FirstOrDefault();
// 空载具入库: 前面通过OrderBy(d => d.id)对WmsCarryCode_id进行了排序 那么如果第一行有数据则说明存在非空料箱
// 没有物料且没有退料标记的不满足出库条件
if (!string.IsNullOrEmpty(item.WmsCarryCode_id) && item.wmsCarryH.carry_status != ((int)(EnumCarryStatus.退料)).ToString())
{
return new BasLocation();
}
else
{
// 进这里说明库位下的料箱都为空
return item.basLocation;
}
})
// 筛选非空库位数据
.Where(r => !string.IsNullOrEmpty(r.location_code)).ToList();
if (rackStartLocations.Count() == 0)
{
//LoggerFloor2RackDelivery.LogWarning($"【送满托到下升降区】 暂存仓中没有可用的满料架 {db_Floor2timer送满托到下升降区.Queryable()
//.InnerJoin((a, b) => a.id == b.location_id)
//.LeftJoin((a, b, c) => b.id == c.carry_id) // 有料箱
//.LeftJoin((a, b, c, d) => c.membercarry_id == d.carry_id)
//.Where((a, b, c, d) => a.wh_id == "33780009364245" && a.is_use == "1" && a.is_lock == 0 && a.is_type == "0" && !string.IsNullOrEmpty(c.id)
//&& b.carrystd_id == WmsWareHouseConst.CARRY_LJSTD_ID).OrderBy((a, b, c, d) => d.id).Select((a, b, c, d) => new // 关联载具物料明细表
//{
// basLocation = a,
// WmsCarryCode_id = d.id
//}).ToSqlString()}");
continue;
}
LoggerFloor2RackDelivery.LogInformation($"【送满托到下升降区】 即将补充料架区{wmsMechanicalArmH.name}");
BasLocation startLocation = rackStartLocations.First();
List wmsCarryHs = db_Floor2timer送满托到下升降区.Queryable().Where(r => r.location_id == startLocation.id
&& r.carrystd_id == WmsWareHouseConst.CARRY_LJSTD_ID).ToList();
if (wmsCarryHs.Count == 0)
{
LoggerFloor2RackDelivery.LogError($"【送满托到下升降区】 起点{startLocation.id} {startLocation.location_code}上找不到料架");
continue;
}
if (wmsCarryHs.Count > 1)
{
LoggerFloor2RackDelivery.LogError($"【送满托到下升降区】 起点{startLocation.id} {startLocation.location_code}上存在多个料架");
continue;
}
WmsPretaskH wmsPretaskH = db_Floor2timer送满托到下升降区.Queryable().Where(r => r.endlocation_code == wmsMechanicalArmH.location_code
&& r.status != WmsWareHouseConst.PRETASK_BILL_STATUS_COMPLE_ID && r.status != WmsWareHouseConst.PRETASK_BILL_STATUS_CANCEL_ID).First();
if (wmsPretaskH != null)
{
LoggerFloor2RackDelivery.LogWarning($"【送满托到下升降区】料架区{wmsMechanicalArmH.location_code}存在未完成的预任务{wmsPretaskH.bill_code}！");
continue;
}
// 满料架
WmsCarryH targetCarry = wmsCarryHs[0];
await db_Floor2timer送满托到下升降区.Updateable().SetColumns(r => new BasLocation
{
is_lock = 1
}).Where(r => r.id == startLocation.id).ExecuteCommandAsync();
await db_Floor2timer送满托到下升降区.Updateable().SetColumns(r => new BasLocation
{
is_lock = 1
}).Where(r => r.id == wmsMechanicalArmH.location_id).ExecuteCommandAsync();
LoggerFloor2RackDelivery.LogInformation($"【送满托到下升降区】 开始生成预任务 起点{startLocation.location_code} 终点{wmsMechanicalArmH.location_code} 料架 {targetCarry.carry_code}");
bool result = await createPretask(startLocation.id, wmsMechanicalArmH.location_id, targetCarry.id, targetCarry.carry_code, LoggerFloor2RackDelivery, db_Floor2timer送满托到下升降区, WmsWareHouseConst.BIZTYPE_ZCCKNZY_ID);
if (!result)
{
LoggerFloor2RackDelivery.LogInformation($"【送满托到下升降区】 未成功生成预任务 起点{startLocation.location_code} 终点{wmsMechanicalArmH.location_code} 料架 {targetCarry.carry_code}");
throw new Exception($"【送满托到下升降区】 未成功生成预任务 起点{startLocation.location_code} 终点{wmsMechanicalArmH.location_code} 料架 {targetCarry.carry_code}");
}
}
await db_Floor2timer送满托到下升降区.Ado.CommitTranAsync();
}
}
catch (ObjectDisposedException ex)
{
LoggerFloor2RackDelivery.LogError($"【送满托到下升降区】 数据库连接异常:{ex.Message}");
LoggerFloor2RackDelivery.LogError($"【送满托到下升降区】 数据库连接异常:{ex.StackTrace}");
if (ex.Source == "Npgsql")
db_Floor2timer送满托到下升降区 = _repository.AsSugarClient().CopyNew();
}
catch (Exception ex)
{
Console.WriteLine("【上升降机】" + ex.Message);
LoggerFloor2RackDelivery.LogError($"【送满托到下升降区】 {ex.Message}");
LoggerFloor2RackDelivery.LogError($"【送满托到下升降区】 {ex.StackTrace}");
// 数据库连接断开时会报错
try { await db_Floor2timer送满托到下升降区.Ado.RollbackTranAsync(); } catch { };
}
finally
{
_wareHouseService.s_taskExecuteSemaphore_F2ZCCOutstock.Release();
if (!db_Floor2timer送满托到下升降区.Ado.Transaction.IsNull())
try { await db_Floor2timer送满托到下升降区.Ado.CommitTranAsync(); } catch { };
_wareHouseService.GenTaskExecute();
stopwatch.Stop();
Console.WriteLine($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")} 结束执行送满托到下升降区 {stopwatch.ElapsedMilliseconds} ms");
LoggerTimer.LogInformation($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")} 结束执行送满托到下升降区 {stopwatch.ElapsedMilliseconds} ms");
}
}
///
/// 移走上升降区未生成预任务且满托的料架
///
///
public async void 移走上升降区未生成预任务且满托的料架(object? args)
{
if (_wareHouseService.s_taskExecuteSemaphore_F2ZCCInstock.CurrentCount == 0)
return;
await _wareHouseService.s_taskExecuteSemaphore_F2ZCCInstock.WaitAsync();
Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();
try
{
Console.WriteLine($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")} 开始执行移走上升降区未生成预任务且满托的料架");
LoggerTimer.LogInformation($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")} 开始执行移走上升降区未生成预任务且满托的料架");
#region 检查信号
List configs_upMachine = new List();
if (await GetBoolTag("东面提升机输送线", $"上升降机请求取满托1"))
{
LoggerFloor2RackDelivery.LogInformation($"【移走上升降区未生成预任务且满托的料架】上升降机请求取满托1 true");
configs_upMachine.Add(floor2mechanicalAtmDic["上升降机请求取满托1"]);
}
if (await GetBoolTag("东面提升机输送线", $"上升降机请求取满托2"))
{
LoggerFloor2RackDelivery.LogInformation($"【移走上升降区未生成预任务且满托的料架】上升降机请求取满托2 true");
configs_upMachine.Add(floor2mechanicalAtmDic["上升降机请求取满托2"]);
}
// 没有有效信号
if (configs_upMachine.Count == 0)
return;
#endregion
//using (var db = _repository.AsSugarClient().CopyNew())
{
//await db.BeginTranAsync();
// 读取上升降机的左右料架区配置
await db_Floor2timer移走上升降区未生成预任务且满托的料架.Ado.BeginTranAsync();
List WmsMechanicalArmHs = db_Floor2timer移走上升降区未生成预任务且满托的料架.Queryable().Where(r => r.stackingcount == r.maxnum && r.maxnum != 0 && !string.IsNullOrEmpty(r.rackcode) && r.iscreatepretask == 0 && configs_upMachine.Contains(r.name) && r.mechanicalconfirm == 1).ToList();
foreach (WmsMechanicalArmH wmsMechanicalArmH in WmsMechanicalArmHs)
{
LoggerFloor2RackDelivery.LogInformation($"【移走上升降区满托的料架】 开始执行预任务生成 {wmsMechanicalArmH.location_code} {wmsMechanicalArmH.outbill} {wmsMechanicalArmH.barcodes}");
await db_Floor2timer移走上升降区未生成预任务且满托的料架.Updateable().SetColumns(r => new WmsMechanicalArmH
{
iscreatepretask = 1
}).Where(r => r.id == wmsMechanicalArmH.id).ExecuteCommandAsync();
// 找到未占用且未锁定的库位
ISugarQueryable rackEndLocations =
db_Floor2timer移走上升降区未生成预任务且满托的料架.Queryable()
.Where(r => r.wh_id == "33780009364245" && r.is_use == "0" && r.is_lock == 0 && r.is_type == "0").OrderBy(a => a.id).Take(1);
if (rackEndLocations.Count() == 0)
{
LoggerFloor2RackDelivery.LogWarning($"【移走上升降区满托的料架】 暂存仓中没有可用的空库位 {rackEndLocations.ToSqlString()}");
continue;
}
BasLocation endLocation = rackEndLocations.First();
// 锁住终点库位
await db_Floor2timer移走上升降区未生成预任务且满托的料架.Updateable(r => new BasLocation
{
is_lock = 1
}).Where(r => r.id == endLocation.id).ExecuteCommandAsync();
LoggerFloor2RackDelivery.LogInformation($"【移走上升降区满托的料架】 开始执行预任务生成: 料架区为{wmsMechanicalArmH.name}{wmsMechanicalArmH.stackingposition} 料架为{wmsMechanicalArmH.rackcode}");
WmsMaterialTransfer wmsMaterialTransfer = await db_Floor2timer移走上升降区未生成预任务且满托的料架.Queryable().Where(r => r.bill_code == wmsMechanicalArmH.outbill).FirstAsync();
string wmsMaterialTransferId = "";
if (wmsMaterialTransfer != null)
{
wmsMaterialTransferId = wmsMaterialTransfer.id;
}
else
{
LoggerFloor2RackDelivery.LogWarning($"【移走上升降区满托的料架】找不到转库单{wmsMechanicalArmH.outbill}");
}
bool result = await createPretask(wmsMechanicalArmH.location_id, endLocation.id, wmsMechanicalArmH.rackid, wmsMechanicalArmH.rackcode, LoggerFloor2RackDelivery, db_Floor2timer移走上升降区未生成预任务且满托的料架, WmsWareHouseConst.BIZTYPE_ZCCKNZY_ID, wmsMaterialTransferId);
if (!result)
{
LoggerFloor2RackDelivery.LogError($"【移走上升降区满托的料架】 未成功生成预任务 起点{wmsMechanicalArmH.location_code} 终点{endLocation.location_code} 料架 {wmsMechanicalArmH.rackcode}");
throw new Exception($"【移走上升降区满托的料架】 未成功生成预任务 起点{wmsMechanicalArmH.location_code} 终点{endLocation.location_code} 料架 {wmsMechanicalArmH.rackcode}");
}
LoggerFloor2RackDelivery.LogInformation($"【移走上升降区满托的料架】 成功生成预任务 {result}");
}
await db_Floor2timer移走上升降区未生成预任务且满托的料架.Ado.CommitTranAsync();
}
}
catch (ObjectDisposedException ex)
{
LoggerFloor2RackDelivery.LogError($"【移走上升降区未生成预任务且满托的料架】 数据库连接异常:{ex.Message}");
LoggerFloor2RackDelivery.LogError($"【移走上升降区未生成预任务且满托的料架】 数据库连接异常:{ex.StackTrace}");
if (ex.Source == "Npgsql")
db_Floor2timer移走上升降区未生成预任务且满托的料架 = _repository.AsSugarClient().CopyNew();
}
catch (Exception ex)
{
Console.WriteLine("【上升降机】" + ex.Message);
LoggerFloor2RackDelivery.LogError($"【移走上升降区未生成预任务且满托的料架】{ex.Message}");
LoggerFloor2RackDelivery.LogError($"【移走上升降区未生成预任务且满托的料架】{ex.StackTrace}");
// 数据库连接断开时会报错
try { await db_Floor2timer移走上升降区未生成预任务且满托的料架.Ado.RollbackTranAsync(); } catch { };
}
finally
{
_wareHouseService.s_taskExecuteSemaphore_F2ZCCInstock.Release();
if (!db_Floor2timer移走上升降区未生成预任务且满托的料架.Ado.Transaction.IsNull())
// 数据库连接断开时会报错
try { await db_Floor2timer移走上升降区未生成预任务且满托的料架.Ado.CommitTranAsync(); } catch { };
_wareHouseService.GenTaskExecute();
stopwatch.Stop();
Console.WriteLine($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")} 结束执行移走上升降区未生成预任务且满托的料架 {stopwatch.ElapsedMilliseconds} ms");
LoggerTimer.LogInformation($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")} 结束执行移走上升降区未生成预任务且满托的料架 {stopwatch.ElapsedMilliseconds} ms");
}
}
///
/// 移走下升降区未生成预任务且空托的料架
///
///
public async void 移走下升降区未生成预任务且空托的料架(object? args)
{
if (_wareHouseService.s_taskExecuteSemaphore_F2ZCCInstock.CurrentCount == 0)
return;
await _wareHouseService.s_taskExecuteSemaphore_F2ZCCInstock.WaitAsync();
Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();
try
{
Console.WriteLine($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")} 开始执行移走下升降区未生成预任务且空托的料架");
LoggerTimer.LogInformation($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")} 开始执行移走下升降区未生成预任务且空托的料架");
#region 检查信号
List configs_upMachine = new List();
if (await GetBoolTag("东面提升机输送线", $"下升降机请求取空托1"))
{
LoggerFloor2RackDelivery.LogInformation($"【移走下升降区空托的料架】下升降机请求取空托1 true");
configs_upMachine.Add(floor2mechanicalAtmDic["下升降机请求取空托1"]);
}
if (await GetBoolTag("东面提升机输送线", $"下升降机请求取空托2"))
{
LoggerFloor2RackDelivery.LogInformation($"【移走下升降区空托的料架】下升降机请求取空托2 true");
configs_upMachine.Add(floor2mechanicalAtmDic["下升降机请求取空托2"]);
}
// 没有有效信号
if (configs_upMachine.Count == 0)
return;
#endregion
//using (var db = _repository.AsSugarClient().CopyNew())
{
//await db.BeginTranAsync();
// 读取下升降机的左右料架区配置
List WmsMechanicalArmHs = db_Floor2timer移走下升降区未生成预任务且空托的料架.Queryable().Where(r => !string.IsNullOrEmpty(r.rackcode) && r.iscreatepretask == 0 && configs_upMachine.Contains(r.name)).ToList();
foreach (WmsMechanicalArmH wmsMechanicalArmH in WmsMechanicalArmHs)
{
LoggerFloor2RackDelivery.LogInformation($"【移走下升降区空托的料架】 开始执行预任务生成 {wmsMechanicalArmH.location_code} {wmsMechanicalArmH.outbill} {wmsMechanicalArmH.barcodes}");
await db_Floor2timer移走下升降区未生成预任务且空托的料架.Ado.BeginTranAsync();
await db_Floor2timer移走下升降区未生成预任务且空托的料架.Updateable().SetColumns(r => new WmsMechanicalArmH
{
iscreatepretask = 1
}).Where(r => r.id == wmsMechanicalArmH.id).ExecuteCommandAsync();
// 找到未占用且未锁定的库位
ISugarQueryable rackEndLocations =
db_Floor2timer移走下升降区未生成预任务且空托的料架.Queryable()
.Where(r => r.wh_id == "33780009364245" && r.is_use == "0" && r.is_lock == 0 && r.is_type == "0").OrderBy(a => a.id).Take(1);
if (rackEndLocations.Count() == 0)
{
//LoggerFloor2RackDelivery.LogWarning($"【移走下升降区空托的料架】 暂存仓中没有可用的空库位 {rackEndLocations.ToSqlString()}");
continue;
}
BasLocation endLocation = rackEndLocations.First();
int row = await db_Floor2timer移走下升降区未生成预任务且空托的料架.Updateable().SetColumns(r => r.carry_status == "0").Where(r => r.id == wmsMechanicalArmH.rackid).ExecuteCommandAsync();
if (row == 0)
{
throw new Exception($"【移走下升降区空托的料架】料架{wmsMechanicalArmH.rackcode}状态回写失败");
}
// 解除绑定料箱到料架
CarryBindInput carryBindInput = new() { };
carryBindInput.carry_id = wmsMechanicalArmH.rackid;
carryBindInput.carry_code = wmsMechanicalArmH.rackcode;
carryBindInput.source_code = wmsMechanicalArmH.outbill;
Tnb.WarehouseMgr.Entities.Dto.Outputs.Result unbindResult = await _wmsCarryUnbindService.CarryUnbind(carryBindInput, db_Floor2timer移走下升降区未生成预任务且空托的料架);
if (unbindResult.code != JNPF.Common.Enums.HttpStatusCode.OK)
{
throw new Exception(unbindResult.msg);
}
// 锁住终点库位
await db_Floor2timer移走下升降区未生成预任务且空托的料架.Updateable(r => new BasLocation
{
is_lock = 1
}).Where(r => r.id == endLocation.id).ExecuteCommandAsync();
LoggerFloor2RackDelivery.LogInformation($"【移走下升降区空托的料架】 开始执行预任务生成: 料架区为{wmsMechanicalArmH.name}{wmsMechanicalArmH.stackingposition} 料架为{wmsMechanicalArmH.rackcode}");
bool result = await createPretask(wmsMechanicalArmH.location_id, endLocation.id, wmsMechanicalArmH.rackid, wmsMechanicalArmH.rackcode, LoggerFloor2RackDelivery, db_Floor2timer移走下升降区未生成预任务且空托的料架, WmsWareHouseConst.BIZTYPE_ZCCKNZY_ID);
if (!result)
{
LoggerFloor2RackDelivery.LogInformation($"【移走下升降区空托的料架】 未成功生成预任务 起点{wmsMechanicalArmH.location_code} 终点{endLocation.location_code} 料架 {wmsMechanicalArmH.rackcode}");
throw new Exception($"【移走下升降区空托的料架】 未成功生成预任务 起点{wmsMechanicalArmH.location_code} 终点{endLocation.location_code} 料架 {wmsMechanicalArmH.rackcode}");
}
await db_Floor2timer移走下升降区未生成预任务且空托的料架.Ado.CommitTranAsync();
}
}
}
catch (ObjectDisposedException ex)
{
LoggerFloor2RackDelivery.LogError($"【移走下升降区空托的料架】 数据库连接异常:{ex.Message}");
LoggerFloor2RackDelivery.LogError($"【移走下升降区空托的料架】 数据库连接异常:{ex.StackTrace}");
if (ex.Source == "Npgsql")
db_Floor2timer移走下升降区未生成预任务且空托的料架 = _repository.AsSugarClient().CopyNew();
}
catch (Exception ex)
{
Console.WriteLine("【移走下升降区空托的料架】" + ex.Message);
LoggerFloor2RackDelivery.LogError($"【移走下升降区空托的料架】{ex.Message}");
LoggerFloor2RackDelivery.LogError($"【移走下升降区空托的料架】{ex.StackTrace}");
// 数据库连接断开时会报错
try { await db_Floor2timer移走下升降区未生成预任务且空托的料架.Ado.RollbackTranAsync(); } catch { };
}
finally
{
_wareHouseService.s_taskExecuteSemaphore_F2ZCCInstock.Release();
if (!db_Floor2timer移走下升降区未生成预任务且空托的料架.Ado.Transaction.IsNull())
try { await db_Floor2timer移走下升降区未生成预任务且空托的料架.Ado.CommitTranAsync(); } catch { };
_wareHouseService.GenTaskExecute();
stopwatch.Stop();
Console.WriteLine($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")} 结束执行移走下升降区未生成预任务且空托的料架 {stopwatch.ElapsedMilliseconds} ms");
LoggerTimer.LogInformation($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")} 结束执行移走下升降区未生成预任务且空托的料架 {stopwatch.ElapsedMilliseconds} ms");
}
}
///
/// 定时触发一次任务执行生成
///
///
public async void GenTaskExecute(object? args)
{
Console.WriteLine($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")} 触发任务执行");
LoggerTimer.LogInformation($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")} 触发任务执行");
_wareHouseService.GenTaskExecute();
}
// 上下升降机生成预任务（补充料架、上升降机取货到料架、上升降机满托运走，下升降机拿货到输送线、下升降机空托运走）
private async Task createPretask(string startlocation_id, string endlocation_id, string carry_id, string carry_code, ILogger logger, ISqlSugarClient dbConn, string biz_type = "", string source_id = "", string require_id = "", string task_type = "")
{
CommonCreatePretaskInput commonCreatePretaskInput = new CommonCreatePretaskInput();
commonCreatePretaskInput.startlocation_id = startlocation_id;
commonCreatePretaskInput.endlocation_id = endlocation_id;
commonCreatePretaskInput.carry_id = carry_id;
commonCreatePretaskInput.carry_code = carry_code;
commonCreatePretaskInput.task_type = task_type ?? WmsWareHouseConst.BIZTYPE_WMSTRANSFER_ID;
commonCreatePretaskInput.biz_type = biz_type;
commonCreatePretaskInput.require_id = require_id;
commonCreatePretaskInput.source_id = source_id;
commonCreatePretaskInput.isExcuteMission = false;
if (task_type == WmsWareHouseConst.WMS_PRETASK_INSTOCK_TYPE_ID)
commonCreatePretaskInput.priority = WmsWareHouseConst.priority_instock;
logger.LogInformation($"开始执行 GenPreTask {JsonConvert.SerializeObject(commonCreatePretaskInput)}");
var res = await _wareHouseService.CommonCreatePretask(commonCreatePretaskInput, dbConn);
if (res.code == JNPF.Common.Enums.HttpStatusCode.OK)
{
logger.LogInformation($"GenPreTask 结果 {JsonConvert.SerializeObject(res)}");
return true;
}
return false;
}
///
/// 四楼包材自动到二楼包材库
///
///
//public async void PackOutstockService(object? args)
//{
// if (s_taskPackOutstockService.CurrentCount == 0)
// return;
// await s_taskPackOutstockService.WaitAsync();
// Stopwatch stopwatch = new Stopwatch();
// stopwatch.Start();
// try
// {
// Console.WriteLine($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")} 开始执行四楼包材自动到二楼包材库");
// LoggerTimer.LogInformation($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")} 开始执行四楼包材自动到二楼包材库");
// await _wmsPackOutstockService.Distribute();
// }
// catch (Exception ex)
// {
// Console.WriteLine("【四楼包材自动到二楼包材库】" + ex.Message);
// LoggerFloor2RackDelivery.LogError($"【四楼包材自动到二楼包材库】{ex.Message}");
// LoggerFloor2RackDelivery.LogError($"【四楼包材自动到二楼包材库】{ex.StackTrace}");
// }
// finally
// {
// s_taskPackOutstockService.Release();
// stopwatch.Stop();
// Console.WriteLine($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")} 结束四楼包材自动到二楼包材库 {stopwatch.ElapsedMilliseconds} ms");
// LoggerTimer.LogInformation($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")} 结束执行四楼包材自动到二楼包材库 {stopwatch.ElapsedMilliseconds} ms");
// }
//}
///
/// 生成电梯任务
///
///
async void ElevatorTaskExceptionHandle(object args)
{
Task[] taskActions = new Task[_wareHouseService.s_elevatortaskDic.Count];
int index = 0;
foreach (string area in _wareHouseService.s_elevatortaskDic.Keys)
{
SemaphoreSlim s_elevatortask = _wareHouseService.s_elevatortaskDic[area];
SemaphoreSlim s_elevatortaskWCSRequest = _wareHouseService.s_elevatortaskWCSRequestDic[area];
if (s_elevatortask.CurrentCount == 0)
return;
if (s_elevatortaskWCSRequest.CurrentCount == 0)
return;
await s_elevatortask.WaitAsync();
//WCS下发任务前会判断是否一托下 防止向WCS发送一托下指令和下发任务同步进行
await s_elevatortaskWCSRequest.WaitAsync();
var db_ElevatorTaskExceptionHandle = _wareHouseService.db_ElevatorTaskExceptionHandles[index];
taskActions[index] = Task.Run(async () =>
{
try
{
// 获取未判定几托下的电梯任务或者已判定一托下的电梯任务
// 因为电梯任务判定为一托下之后会回写act_start_date，后续同电梯小车不会进入到已判定过几托下的电梯，不存在同电梯既有act_start_date为空又有act_start_date不为空的情况
List elevatorTasks = db_ElevatorTaskExceptionHandle.Queryable()
.Where(r => r.area_code == area && r.act_end_date == null
&& r.status != WmsWareHouseConst.TASK_BILL_STATUS_CANCEL_ID && r.status != WmsWareHouseConst.TASK_BILL_STATUS_COMPLE_ID).ToList();
LoggerElevatorTask.Information($"【ElevatorTaskExceptionHandle】检查到需要恢复/执行的电梯{area}任务{elevatorTasks.Count}条 {string.Join(',', elevatorTasks.Select(x => x.bill_code))}");
if (elevatorTasks?.Count > 0)
{
LoggerElevatorTask.Information($"【ElevatorTaskExceptionHandle】{JsonConvert.SerializeObject(elevatorTasks)}");
List> elevatorTaskGroup = elevatorTasks.GroupBy(r => $"{r.endlocation_code} {r.end_floor}").ToList();
foreach (IGrouping group in elevatorTaskGroup)
{
List wmsDistaskHs = group.ToList();
ElevagorInfoQuery q = new() { endlocation_id = wmsDistaskHs[0].endlocation_id, taskCode = wmsDistaskHs[0].bill_code };
LoggerElevatorTask.Information($"【ElevatorTaskExceptionHandle】执行电梯任务时 根据任务单号获取电梯参数 {JsonConvert.SerializeObject(q)}");
var e = await _wareHouseService.FindElevatorFromPars(q);
LoggerElevatorTask.Information($"【ElevatorTaskExceptionHandle】执行电梯任务时 根据任务单号获取电梯结果 {JsonConvert.SerializeObject(e)}");
// 三、四号梯发货带两托货
string[] doubleCarryRunElevators =
{
"Elevator3","Elevator4"
};
if (doubleCarryRunElevators.Contains(e.elevator_code) && wmsDistaskHs[0].end_floor == 1)
{
// 存在叉车已放货完成电梯任务还没生成的情况，这种情况等待完成
WmsElevatorH wmsElevator = await db_ElevatorTaskExceptionHandle.Queryable().Where(r => r.elevator_id == e.device_id).FirstAsync();
if (wmsElevator.carry_count != elevatorTasks.Count)
{
throw new Exception($"电梯{e.elevator_code}内放货托盘为{wmsElevator.carry_count}托，已生成的电梯任务为{elevatorTasks.Count}，需要等待电梯任务生成");
}
LoggerElevatorTask.Information($"【ElevatorTaskExceptionHandle】判断为三四号梯任务");
LoggerElevatorTask.Information($"【ElevatorTaskExceptionHandle】现在{e.elevator_code}有{group.Count()}托货");
// 电梯内放置两托货呼叫电梯下
if (group.Count() == 2)
{
if (e != null)
{
wmsDistaskHs[0].device_id = e.device_id;
wmsDistaskHs[1].device_id = e.device_id;
}
LoggerElevatorTask.Information($"【ElevatorTaskExceptionHandle】呼叫电梯 {e.elevator_code}");
await _wareHouseService.ExecuteTargetFloorTask(wmsDistaskHs, db_ElevatorTaskExceptionHandle);
LoggerElevatorTask.Information($"【ElevatorTaskExceptionHandle】呼叫电梯 {e.elevator_code}执行完成");
}
// 一托货
else if (group.Count() == 1)
{
// 如果当前电梯没有执行中且货位不同的任务 则呼叫电梯下
List _wmsDistaskHs = await db_ElevatorTaskExceptionHandle.Queryable()
.InnerJoin((a, b) => a.startlocation_id == b.location_id)
.Where((a, b) => a.status != WmsWareHouseConst.TASK_BILL_STATUS_COMPLE_ID
&& a.status != WmsWareHouseConst.TASK_BILL_STATUS_CANCEL_ID && a.endlocation_id == wmsDistaskHs[0].startlocation_id
&& !wmsElevator.innerpos.Contains(b.name)
).ToListAsync();
if (_wmsDistaskHs.Count() == 0)
{
if (e != null)
{
wmsDistaskHs[0].device_id = e.device_id;
}
LoggerElevatorTask.Information($"【ElevatorTaskExceptionHandle】呼叫电梯 {e.elevator_code}");
await _wareHouseService.ExecuteTargetFloorTask(wmsDistaskHs, db_ElevatorTaskExceptionHandle);
LoggerElevatorTask.Information($"【ElevatorTaskExceptionHandle】呼叫电梯 {e.elevator_code}执行完成");
}
else
{
LoggerElevatorTask.Information($"【ElevatorTaskExceptionHandle】等待 {string.Join(',', _wmsDistaskHs.Select(r => r.carry_code ))}");
}
}
else
{
LoggerElevatorTask.LogError($"【ElevatorTaskExceptionHandle】电梯 {e.elevator_code} 待执行的电梯任务数异常 目前是{group.Count()} 超过了两托");
}
}
else
{
LoggerElevatorTask.Information($"【ElevatorTaskExceptionHandle】判断为非三四号梯任务");
if (e != null)
{
wmsDistaskHs[0].device_id = e.device_id;
}
LoggerElevatorTask.Information($"【ElevatorTaskExceptionHandle】呼叫电梯 {e.elevator_code}");
await _wareHouseService.ExecuteTargetFloorTask(wmsDistaskHs, db_ElevatorTaskExceptionHandle);
LoggerElevatorTask.Information($"【ElevatorTaskExceptionHandle】呼叫电梯 {e.elevator_code}执行完成");
}
}
}
}
catch (ObjectDisposedException ex)
{
LoggerElevatorTask.LogWarning($"【ElevatorTaskExceptionHandle】 数据库连接异常:{ex.Message}");
LoggerElevatorTask.LogWarning($"【ElevatorTaskExceptionHandle】 数据库连接异常:{ex.StackTrace}");
if (ex.Source == "Npgsql")
db_ElevatorTaskExceptionHandle = _repository.AsSugarClient().CopyNew();
}
catch (Exception ex)
{
Console.WriteLine("【ElevatorTaskExceptionHandle】" + ex.Message);
LoggerElevatorTask.LogError($"【ElevatorTaskExceptionHandle】 {ex.Message}");
LoggerElevatorTask.LogError($"【ElevatorTaskExceptionHandle】 {ex.StackTrace}");
// 数据库连接断开时会报错
try { await db_ElevatorTaskExceptionHandle.Ado.RollbackTranAsync(); } catch { };
}
finally
{
s_elevatortask.Release();
if (s_elevatortaskWCSRequest.CurrentCount == 0)
s_elevatortaskWCSRequest.Release();
}
});
index++;
}
Task.WaitAll(taskActions);
}
///
/// 电梯第三次改动 生成Agv到电梯任务
///
///
async void AgvelevatorTimerTaskExceptionHandle(object args)
{
await _wareHouseService.AgvelevatorTimerTaskExceptionHandle();
}
#region 内存测试
public async Task GetBoolTag(string DevName, string field)
{
try
{
string jsonString = await _redisData.GetHash(DevName, field);
Log.Information($"查询X2Server数据 {DevName} {field}:" + jsonString);
if (string.IsNullOrEmpty(jsonString))
return false;
JObject jsonObject = JObject.Parse(jsonString);
if (jsonObject.TryGetValue("StatusCode", out JToken valueToken1))
{
if (valueToken1.ToString() == "-1")
return false;
}
if (jsonObject.TryGetValue("Value", out JToken valueToken2))
{
return bool.Parse(valueToken2.ToString());
}
else
{
Console.WriteLine($"未找到匹配项 {DevName} {field}");
}
}
catch (Exception ex)
{
Console.WriteLine($"未找到匹配项{DevName} {field}");
}
return false;
}
public async Task GetStringTag(string DevName, string field)
{
#region
try
{
string jsonString = await _redisData.GetHash(DevName, field);
Log.Information($"查询X2Server数据 {DevName} {field}:" + jsonString);
JObject jsonObject = JObject.Parse(jsonString);
if (jsonObject.TryGetValue("StatusCode", out JToken valueToken1))
{
if (valueToken1.ToString() == "-1")
return "";
}
if (jsonObject.TryGetValue("Value", out JToken valueToken2))
{
return valueToken2.ToString();
}
else
{
Console.WriteLine($"未找到匹配项 {DevName} {field}");
}
}
catch (Exception ex)
{
// 捕获并处理异常
Console.WriteLine($"发生异常: {ex.Message}");
}
return $"未找到匹配项 {DevName} {field}";
#endregion
//try
//{
// string jsonString = await _redisData.GetHash(DevName, field);
// if (string.IsNullOrEmpty(jsonString))
// return "";
// string pattern = "\"Value\":\"(.*?)\"";
// System.Text.RegularExpressions.Match match = Regex.Match(jsonString, pattern);
// if (match.Success)
// {
// return match.Groups[1].Value;
// }
// else
// {
// Console.WriteLine($"未找到匹配项{DevName} {field}");
// }
//}
//catch (Exception ex)
//{
// Console.WriteLine($"未找到匹配项{DevName} {field}");
//}
//return $"未找到匹配项 {DevName} {field}";
}
private async Task Floor2UpDownMachinecode_SetTag(string tag, string value)
{
string DevName = "东面提升机输送线";
Dictionary dicCommand = new(StringComparer.OrdinalIgnoreCase)
{
["DevName"] = DevName,
["token"] = _eleCtlCfg.token,
["TagName"] = tag,
["Value"] = value,
};
string result = await HttpClientHelper.GetRequestAsync(_eleCtlCfg.WriteTagUrl, dicCommand);
return result.Contains("Ok");
//测试
//string DevName = "东面提升机输送线";
//JObject valueJson = new JObject();
//valueJson["Value"] = value;
//_redisData.SetHash(DevName, tag, valueJson.ToString());
//return true;
}
public async Task GetObjectTag(string DevName, string field)
{
#region
try
{
string jsonString = await _redisData.GetHash(DevName, field);
Log.Information($"查询X2Server数据 {DevName} {field}:" + jsonString);
JObject jsonObject = JObject.Parse(jsonString);
if (jsonObject.TryGetValue("StatusCode", out JToken valueToken1))
{
if (valueToken1.ToString() == "-1")
return null;
}
return jsonObject;
}
catch (Exception ex)
{
// 捕获并处理异常
Console.WriteLine($"发生异常: {ex.Message}");
}
return null;
#endregion
}
#endregion
#endregion
#region 灭菌仓
///
/// 四楼待灭菌仓到灭菌线
///
///
private async void Floor4DMJ2MJX(object? args)
{
if (s_taskFloor4DMJ2MJXService.CurrentCount == 0)
return;
await s_taskFloor4DMJ2MJXService.WaitAsync();
Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();
try
{
Console.WriteLine($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")} 开始执行四楼待灭菌仓到灭菌线");
LoggerTimer.LogInformation($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")} 开始执行四楼待灭菌仓到灭菌线");
Dictionary putdic = new Dictionary();
putdic.Add("MJQ-FAN01", new string[] { "4楼上料输送西区", "上料工位1请求送盘" });
putdic.Add("MJQ-FAN02", new string[] { "4楼上料输送西区", "上料工位2请求送盘" });
putdic.Add("MJQ-FAN03", new string[] { "4楼上料输送西区", "上料工位3请求送盘" });
putdic.Add("MJQ-FAN04", new string[] { "4楼上料输送西区", "上料工位4请求送盘" });
//Dictionary putdic = new Dictionary();
//List endLocations = db_Floor4DMJ2MJX.Queryable().Where(r => r.wh_id == WmsWareHouseConst.WAREHOUSE_DMJC_ID
//&& r.is_type == ((int)EnumLocationType.分拣库位).ToString() && r.is_lock == 0).ToList();
//foreach (BasLocation endLocation in endLocations)
//{
// putdic.Add(endLocation, new string[] { "", "" });
//}
foreach (var key in putdic.Keys)
{
await db_Floor4DMJ2MJX.Ado.BeginTranAsync();
var strs = putdic.Where(p => p.Key == key).First().Value;
bool result = await GetBoolTag(strs[0], strs[1]);
if (result)
{
LoggerFloor4DMJ2MJX.LogInformation($"【四楼待灭菌仓到灭菌线】 上料点 {key} {strs[1]}采集到 {result}");
OutStockStrategyQuery outStockStrategyInput = new()
{
warehouse_id = WmsWareHouseConst.WAREHOUSE_DMJC_ID,
filter_carry_status = false,
Size = 1
};
List items = await _wareHouseService.OutStockStrategy(outStockStrategyInput);
if (items.Count < 1)
{
LoggerFloor4DMJ2MJX.LogWarning($"【四楼待灭菌仓到灭菌线】 没有可以出库的载具");
break;
}
BasLocation endlocation = await db_Floor4DMJ2MJX.Queryable().Where(r => r.location_code == key).FirstAsync();
WmsCarryH wmsCarryH = items[0];
if (wmsCarryH.carry_status == "0")
{
LoggerFloor4DMJ2MJX.LogWarning($"【四楼待灭菌仓到灭菌线】 载具{wmsCarryH.carry_code}状态为空闲，而当前业务中载具应该为占用状态，请检查数据");
break;
}
//锁定起点库位
await db_Floor4DMJ2MJX.Updateable().SetColumns(r => new BasLocation { is_lock = 1 }).Where(r => r.id == wmsCarryH.location_id).ExecuteCommandAsync();
//锁定终点库位
await db_Floor4DMJ2MJX.Updateable().SetColumns(r => new BasLocation { is_lock = 1 }).Where(r => r.id == endlocation.id).ExecuteCommandAsync();
bool result_createPretask = await createPretask(wmsCarryH.location_id, endlocation.id, wmsCarryH.id, wmsCarryH.carry_code, LoggerFloor4DMJ2MJX, db_Floor4DMJ2MJX, WmsWareHouseConst.BIZTYPE_YRPS_ID, "","", WmsWareHouseConst.WMS_PRETASK_OUTSTOCK_TYPE_ID);
if (!result_createPretask)
{
LoggerFloor4DMJ2MJX.LogWarning($"【四楼待灭菌仓到灭菌线】 {wmsCarryH.location_code} 到 {endlocation.location_code} 预任务生成失败");
throw new Exception($"【四楼待灭菌仓到灭菌线】 {wmsCarryH.location_code} 到 {endlocation.location_code} 预任务生成失败");
}
LoggerFloor4DMJ2MJX.LogInformation($"【四楼待灭菌仓到灭菌线】 {wmsCarryH.location_code} 到 {endlocation.location_code} 预任务生成成功");
}
await db_Floor4DMJ2MJX.Ado.CommitTranAsync();
}
_ = _wareHouseService.GenTaskExecute();
}
catch (ObjectDisposedException ex)
{
LoggerFloor4DMJ2MJX.LogError($"【四楼待灭菌仓到灭菌线】 数据库连接异常:{ex.Message}");
LoggerFloor4DMJ2MJX.LogError($"【四楼待灭菌仓到灭菌线】 数据库连接异常:{ex.StackTrace}");
if (ex.Source == "Npgsql")
db_Floor4DMJ2MJX = _repository.AsSugarClient().CopyNew();
}
catch (Exception ex)
{
Console.WriteLine("【四楼待灭菌仓到灭菌线】" + ex.Message);
LoggerFloor4DMJ2MJX.LogError($"【四楼待灭菌仓到灭菌线】 {ex.Message}");
LoggerFloor4DMJ2MJX.LogError($"【四楼待灭菌仓到灭菌线】 {ex.StackTrace}");
// 数据库连接断开时会报错
try { await db_Floor4DMJ2MJX.Ado.RollbackTranAsync(); } catch { };
}
finally
{
s_taskFloor4DMJ2MJXService.Release();
if (!db_Floor4DMJ2MJX.Ado.Transaction.IsNull())
try { await db_Floor4DMJ2MJX.Ado.CommitTranAsync(); } catch { };
_wareHouseService.GenTaskExecute();
stopwatch.Stop();
Console.WriteLine($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")} 结束四楼待灭菌仓到灭菌线 {stopwatch.ElapsedMilliseconds} ms");
LoggerTimer.LogInformation($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")} 结束四楼待灭菌仓到灭菌线 {stopwatch.ElapsedMilliseconds} ms");
}
}
///
/// 四楼灭菌线到解析仓
///
///
private async void Floor4MJX2MJC(object? args)
{
if (s_taskFloor4MJX2MJCService.CurrentCount == 0)
return;
await s_taskFloor4MJX2MJCService.WaitAsync();
Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();
try
{
Console.WriteLine($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")} 开始执行四楼灭菌线到解析仓");
LoggerTimer.LogInformation($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")} 开始执行四楼灭菌线到解析仓");
Dictionary getdic = new Dictionary();
getdic.Add("MJQ-QU01", new string[] { "4楼下料输送西区", "下料工位1请求取盘", "下料工位1条码" });
getdic.Add("MJQ-QU02", new string[] { "4楼下料输送西区", "下料工位2请求取盘", "下料工位2条码" });
foreach (var key in getdic.Keys)
{
var strs = getdic.Where(p => p.Key == key).First().Value;
bool result = await GetBoolTag(strs[0], strs[1]);
if (result)
{
SemaphoreSlim semaphoreSlim = null;
try
{
semaphoreSlim = _wareHouseService.GetSemaphore("instock", WmsWareHouseConst.WAREHOUSE_MJC_ID);
await semaphoreSlim.WaitAsync();
LoggerFloor4MJX2MJC.LogInformation($"【四楼灭菌线到解析仓】 下料点 {key} {strs[1]}采集到 {result}");
InStockStrategyQuery inStockStrategyInput = new()
{
warehouse_id = WmsWareHouseConst.WAREHOUSE_MJC_ID,
Size = 1
};
List items = await _wareHouseService.InStockStrategy(inStockStrategyInput);
if (items.Count < 1)
{
LoggerFloor4MJX2MJC.LogWarning($"【四楼灭菌线到解析仓】 没有可以入库的库位");
break;
}
var endlocation = items.First();
await db_Floor4MJX2MJC.Ado.BeginTranAsync();
BasLocation startlocation = await db_Floor4MJX2MJC.Queryable().Where(r => r.location_code == key).FirstAsync();
if (startlocation.is_lock == 1)
{
LoggerFloor4MJX2MJC.LogWarning($"【四楼灭菌线到解析仓】 起点库位{startlocation.location_code}已锁定");
continue;
}
string carry_code = (await GetStringTag(strs[0], strs[2])).Replace("\r", "").Replace(" ", "");
LoggerFloor4MJX2MJC.LogInformation($"【四楼灭菌线到解析仓】 下料点 {key} {strs[2]}采集到 {carry_code}");
LoggerFloor4MJX2MJC.LogInformation($"【四楼灭菌线到解析仓】 下料点 {key} {strs[2]}采集到长度 {carry_code.Length}");
WmsCarryH wmsCarryH = await db_Floor4MJX2MJC.Queryable().Where(r => r.carry_code == carry_code).FirstAsync();
if (wmsCarryH == null)
{
LoggerFloor4MJX2MJC.LogWarning($"【四楼灭菌线到解析仓】 托盘号{carry_code}在系统中不存在");
continue;
}
if (wmsCarryH.carry_status == "0")
{
LoggerFloor4DMJ2MJX.LogWarning($"【四楼灭菌线到解析仓】 载具{wmsCarryH.carry_code}状态为空闲，而当前业务中载具应该为占用状态，请检查数据");
break;
}
//锁定起点库位
await db_Floor4MJX2MJC.Updateable().SetColumns(r => new BasLocation { is_lock = 1 }).Where(r => r.id == startlocation.id).ExecuteCommandAsync();
//锁定终点库位
await db_Floor4MJX2MJC.Updateable().SetColumns(r => new BasLocation { is_lock = 1 }).Where(r => r.id == endlocation.id).ExecuteCommandAsync();
DateTime dateTime = DateTime.Now;
WmsSterilizationInstockH wmsSterilizationInstockH = new WmsSterilizationInstockH();
string code = await _billRullService.GetBillNumber("WmsSterilizationInstockH");
wmsSterilizationInstockH.bill_code = code;
wmsSterilizationInstockH.carry_id = wmsCarryH.id;
wmsSterilizationInstockH.carry_code = wmsCarryH.carry_code;
wmsSterilizationInstockH.location_id = endlocation.id;
wmsSterilizationInstockH.location_code = endlocation.location_code;
wmsSterilizationInstockH.create_id = WmsWareHouseConst.AdministratorUserId;
wmsSterilizationInstockH.create_time = dateTime;
wmsSterilizationInstockH.instock_time = dateTime;
wmsSterilizationInstockH.org_id = WmsWareHouseConst.AdministratorOrgId;
wmsSterilizationInstockH.xl_location_id = startlocation.id;
wmsSterilizationInstockH.xl_location_code = startlocation.location_code;
wmsSterilizationInstockH.status = WmsWareHouseConst.BILLSTATUS_ADD_ID;
wmsSterilizationInstockH.origin = "生产入库";
int row = await db_Floor4MJX2MJC.Insertable(wmsSterilizationInstockH).ExecuteCommandAsync();
if (row > 0)
LoggerFloor4MJX2MJC.LogInformation($"【四楼灭菌线到解析仓】 灭菌入库记录生成成功");
else
LoggerFloor4MJX2MJC.LogWarning($"【四楼灭菌线到解析仓】 灭菌入库记录生成失败");
bool result_createPretask = await createPretask(startlocation.id, endlocation.id, wmsCarryH.id, wmsCarryH.carry_code, LoggerFloor4MJX2MJC, db_Floor4MJX2MJC, WmsWareHouseConst.BIZTYPE_WMSSTERILIZATIONINSTOCKCH_ID, "", wmsSterilizationInstockH.id);
if (!result_createPretask)
{
LoggerFloor4MJX2MJC.LogWarning($"【四楼灭菌线到解析仓】 {startlocation.location_code} 到 {endlocation.location_code} 预任务生成失败");
throw new Exception($"【四楼灭菌线到解析仓】 {startlocation.location_code} 到 {endlocation.location_code} 预任务生成失败");
}
LoggerFloor4MJX2MJC.LogInformation($"【四楼灭菌线到解析仓】 {startlocation.location_code} 到 {endlocation.location_code} 预任务生成成功");
}
catch
{
throw;
}
finally
{
semaphoreSlim.Release();
}
}
await db_Floor4MJX2MJC.Ado.CommitTranAsync();
}
_ = _wareHouseService.GenTaskExecute();
}
catch (ObjectDisposedException ex)
{
LoggerFloor4MJX2MJC.LogError($"【四楼灭菌线到解析仓】 数据库连接异常:{ex.Message}");
LoggerFloor4MJX2MJC.LogError($"【四楼灭菌线到解析仓】 数据库连接异常:{ex.StackTrace}");
if (ex.Source == "Npgsql")
db_Floor4MJX2MJC = _repository.AsSugarClient().CopyNew();
}
catch (Exception ex)
{
Console.WriteLine("【四楼灭菌线到解析仓】" + ex.Message);
LoggerFloor4MJX2MJC.LogError($"【四楼灭菌线到解析仓】 {ex.Message}");
LoggerFloor4MJX2MJC.LogError($"【四楼灭菌线到解析仓】 {ex.StackTrace}");
// 数据库连接断开时会报错
try { await db_Floor4MJX2MJC.Ado.RollbackTranAsync(); } catch { };
}
finally
{
s_taskFloor4MJX2MJCService.Release();
if (!db_Floor4MJX2MJC.Ado.Transaction.IsNull())
try { await db_Floor4MJX2MJC.Ado.CommitTranAsync(); } catch { };
_wareHouseService.GenTaskExecute();
stopwatch.Stop();
Console.WriteLine($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")} 结束四楼灭菌线到解析仓 {stopwatch.ElapsedMilliseconds} ms");
LoggerTimer.LogInformation($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")} 结束四楼灭菌线到解析仓 {stopwatch.ElapsedMilliseconds} ms");
}
}
///
/// 四楼灭菌仓到成品库
///
///
private async void Floor4DMC2CPK(object? args)
{
if (s_taskFloor4DMC2CPKService.CurrentCount == 0)
return;
Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();
try
{
var Floor4DMC2CPK = await db_Floor4DMC2CPK.Queryable().Where(p => p.key == "Floor4DMC2CPK").FirstAsync();
// 0则不进行移转
if (Floor4DMC2CPK != null && Floor4DMC2CPK.value == "0")
{
return;
}
await s_taskFloor4DMC2CPKService.WaitAsync();
Console.WriteLine($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")} 开始执行四楼灭菌仓到成品库");
LoggerTimer.LogInformation($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")} 开始执行四楼灭菌仓到成品库");
var time = await db_Floor4DMC2CPK.Queryable().Where(p => p.key == "mjcstewingtime").FirstAsync();
if (time == null)
{
LoggerFloor4DMC2CPK.LogWarning($"【四楼灭菌仓到成品库】 未在静置仓配置中配置 静置时间(小时)");
return;
}
int hours = 168;
if (!int.TryParse(time.value, out hours))
{
LoggerFloor4DMC2CPK.LogWarning($"【四楼灭菌仓到成品库】 静置时间(小时) 配置有误，错误值为 {time}");
return;
}
DateTime now = DateTime.Now;
List wmsSterilizationInstockHs = db_Floor4DMC2CPK.Queryable()
.Where(r => (DateTime.Now - r.instock_time.Value).TotalHours > hours && r.status == WmsWareHouseConst.BILLSTATUS_ADD_ID && r.origin == "生产入库").ToList();
foreach (WmsSterilizationInstockH wmsSterilizationInstockH in wmsSterilizationInstockHs)
{
SemaphoreSlim semaphoreSlim_MJC = null;
SemaphoreSlim semaphoreSlim_CPK = null;
try
{
semaphoreSlim_MJC = _wareHouseService.GetSemaphore("outstock", WmsWareHouseConst.WAREHOUSE_MJC_ID);
await semaphoreSlim_MJC.WaitAsync();
semaphoreSlim_CPK = _wareHouseService.GetSemaphore("instock", WmsWareHouseConst.WAREHOUSE_CP_ID);
await semaphoreSlim_CPK.WaitAsync();
WmsCarryH wmsCarryH = await db_Floor4DMC2CPK.Queryable().Where(r => r.id == wmsSterilizationInstockH.carry_id).FirstAsync();
if (wmsCarryH.carry_status == "0")
{
LoggerFloor4DMJ2MJX.LogWarning($"【四楼灭菌仓到成品库】 载具{wmsCarryH.carry_code}状态为空闲，而当前业务中载具应该为占用状态，请检查数据");
break;
}
if (wmsCarryH.location_id != wmsSterilizationInstockH.location_id)
{
LoggerFloor4DMC2CPK.LogWarning($"【四楼灭菌仓到成品库】载具{wmsCarryH.carry_code}实际位置与灭菌入库记录位置不一致");
continue;
}
BasLocation startlocation = await db_Floor4DMC2CPK.Queryable().Where(r => r.id == wmsCarryH.location_id).FirstAsync();
if (startlocation.is_lock == 1)
{
LoggerFloor4DMC2CPK.LogWarning($"【四楼待灭菌线到灭菌仓】 起点库位{startlocation.location_code}已锁定");
continue;
}
await db_Floor4DMC2CPK.Ado.BeginTranAsync();
InStockStrategyQuery inStockStrategyInput = new()
{
warehouse_id = WmsWareHouseConst.WAREHOUSE_CP_ID,
Region_id = WmsWareHouseConst.REGION_CPOutstock_ID,
Size = 1
};
List items = await _wareHouseService.InStockStrategy(inStockStrategyInput);
if (items.Count < 1)
{
LoggerFloor4DMC2CPK.LogWarning($"【四楼灭菌仓到成品库】 没有可以入库的库位");
break;
}
BasLocation endlocation = items[0];
//锁定起点库位
await db_Floor4DMC2CPK.Updateable().SetColumns(r => new BasLocation { is_lock = 1 }).Where(r => r.id == startlocation.id).ExecuteCommandAsync();
//锁定终点库位
await db_Floor4DMC2CPK.Updateable().SetColumns(r => new BasLocation { is_lock = 1 }).Where(r => r.id == endlocation.id).ExecuteCommandAsync();
bool result_createPretask = await createPretask(startlocation.id, endlocation.id, wmsCarryH.id, wmsCarryH.carry_code,
LoggerFloor4DMC2CPK, db_Floor4DMC2CPK, WmsWareHouseConst.BIZTYPE_WMSSTERILIZATIONINSTOCKCH_ID, "", wmsSterilizationInstockH.id);
if (!result_createPretask)
{
LoggerFloor4DMC2CPK.LogWarning($"【四楼灭菌仓到成品库】 {startlocation.location_code} 到 {endlocation.location_code} 预任务生成失败");
throw new Exception($"【四楼灭菌仓到成品库】 {startlocation.location_code} 到 {endlocation.location_code} 预任务生成失败");
}
LoggerFloor4DMC2CPK.LogInformation($"【四楼灭菌仓到成品库】 {startlocation.location_code} 到 {endlocation.location_code} 预任务生成成功");
wmsSterilizationInstockH.status = WmsWareHouseConst.BILLSTATUS_ON_ID;
wmsSterilizationInstockH.cp_location_id = endlocation.id;
wmsSterilizationInstockH.cp_location_code = endlocation.location_code;
await db_Floor4DMC2CPK.Updateable(wmsSterilizationInstockH).UpdateColumns(r => new { r.status, r.cp_location_id, r.cp_location_code }).ExecuteCommandAsync();
await db_Floor4DMC2CPK.Ado.CommitTranAsync();
}
catch
{
throw;
}
finally
{
semaphoreSlim_MJC.Release();
semaphoreSlim_CPK.Release();
}
}
}
catch (ObjectDisposedException ex)
{
LoggerFloor4DMC2CPK.LogError($"【四楼灭菌仓到成品库】 数据库连接异常:{ex.Message}");
LoggerFloor4DMC2CPK.LogError($"【四楼灭菌仓到成品库】 数据库连接异常:{ex.StackTrace}");
if (ex.Source == "Npgsql")
db_Floor4DMC2CPK = _repository.AsSugarClient().CopyNew();
}
catch (Exception ex)
{
Console.WriteLine("【四楼灭菌仓到成品库】" + ex.Message);
LoggerFloor4DMC2CPK.LogError($"【四楼灭菌仓到成品库】 {ex.Message}");
LoggerFloor4DMC2CPK.LogError($"【四楼灭菌仓到成品库】 {ex.StackTrace}");
// 数据库连接断开时会报错
try { await db_Floor4DMC2CPK.Ado.RollbackTranAsync(); } catch { };
}
finally
{
s_taskFloor4DMC2CPKService.Release();
if (!db_Floor4DMC2CPK.Ado.Transaction.IsNull())
try { await db_Floor4DMC2CPK.Ado.CommitTranAsync(); } catch { };
_wareHouseService.GenTaskExecute();
stopwatch.Stop();
Console.WriteLine($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")} 结束四楼灭菌仓到成品库 {stopwatch.ElapsedMilliseconds} ms");
LoggerTimer.LogInformation($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")} 结束四楼灭菌仓到成品库 {stopwatch.ElapsedMilliseconds} ms");
}
}
///
/// 二楼空托盘自动补充到线边
///
///
private async void F2KTPsupplement(object? args)
{
if (s_taskF2KTPsupplement.CurrentCount == 0)
return;
await s_taskF2KTPsupplement.WaitAsync();
Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();
try
{
Console.WriteLine($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")} 开始执行二楼空托盘自动补充到线边");
LoggerTimer.LogInformation($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")} 开始执行二楼空托盘自动补充到线边");
Dictionary putdic = new Dictionary();
putdic.Add("ZZ-01-01", new string[] { "外包装箱码垛线", "WBZX_x1_AGV_fan" });
putdic.Add("ZZ-02-01", new string[] { "外包装箱码垛线", "WBZX_x2_AGV_fan" });
foreach (var key in putdic.Keys)
{
await db_F2KTPsupplement.Ado.BeginTranAsync();
var strs = putdic.Where(p => p.Key == key).First().Value;
bool result = await GetBoolTag(strs[0], strs[1]);
if (result)
{
LoggerF2KTPsupplement.LogInformation($"【二楼空托盘自动补充到线边】 上料点 {key} {strs[1]}采集到 {result}");
OutStockStrategyQuery outStockStrategyInput = new()
{
warehouse_id = WmsWareHouseConst.WAREHOUSE_F2KTQ_ID,
Size = 1
};
List items = await _wareHouseService.OutStockStrategy(outStockStrategyInput);
if (items.Count < 1)
{
LoggerF2KTPsupplement.LogWarning($"【二楼空托盘自动补充到线边】 没有可以出库的空载具");
break;
}
BasLocation endlocation = await db_F2KTPsupplement.Queryable().Where(r => r.location_code == key).FirstAsync();
if (endlocation.is_use == "1")
{
LoggerF2KTPsupplement.LogWarning($"【二楼空托盘自动补充到线边】 终点库位{endlocation.location_code}已占用");
continue;
}
if (endlocation.is_lock == 1)
{
LoggerF2KTPsupplement.LogWarning($"【二楼空托盘自动补充到线边】 终点库位{endlocation.location_code}已锁定");
continue;
}
WmsCarryH wmsCarryH = items[0];
//锁定起点库位
await db_F2KTPsupplement.Updateable().SetColumns(r => new BasLocation { is_lock = 1 }).Where(r => r.id == wmsCarryH.location_id).ExecuteCommandAsync();
//锁定终点库位
await db_F2KTPsupplement.Updateable().SetColumns(r => new BasLocation { is_lock = 1 }).Where(r => r.id == endlocation.id).ExecuteCommandAsync();
bool result_createPretask = await createPretask(wmsCarryH.location_id, endlocation.id, wmsCarryH.id, wmsCarryH.carry_code, LoggerF2KTPsupplement, db_F2KTPsupplement, WmsWareHouseConst.BIZTYPE_ZDBKT_ID, "", "", WmsWareHouseConst.WMS_PRETASK_OUTSTOCK_TYPE_ID);
if (!result_createPretask)
{
LoggerF2KTPsupplement.LogWarning($"【二楼空托盘自动补充到线边】 {wmsCarryH.location_code} 到 {endlocation.location_code} 预任务生成失败");
throw new Exception($"【二楼空托盘自动补充到线边】 {wmsCarryH.location_code} 到 {endlocation.location_code} 预任务生成失败");
}
LoggerF2KTPsupplement.LogInformation($"【二楼空托盘自动补充到线边】 {wmsCarryH.location_code} 到 {endlocation.location_code} 预任务生成成功");
}
await db_F2KTPsupplement.Ado.CommitTranAsync();
}
_ = _wareHouseService.GenTaskExecute();
}
catch (ObjectDisposedException ex)
{
LoggerF2KTPsupplement.LogError($"【二楼空托盘自动补充到线边】 数据库连接异常:{ex.Message}");
LoggerF2KTPsupplement.LogError($"【二楼空托盘自动补充到线边】 数据库连接异常:{ex.StackTrace}");
if (ex.Source == "Npgsql")
db_F2KTPsupplement = _repository.AsSugarClient().CopyNew();
}
catch (Exception ex)
{
Console.WriteLine("【二楼空托盘自动补充到线边】" + ex.Message);
LoggerF2KTPsupplement.LogError($"【二楼空托盘自动补充到线边】 {ex.Message}");
LoggerF2KTPsupplement.LogError($"【二楼空托盘自动补充到线边】 {ex.StackTrace}");
// 数据库连接断开时会报错
try { await db_F2KTPsupplement.Ado.RollbackTranAsync(); } catch { };
}
finally
{
s_taskF2KTPsupplement.Release();
if (!db_F2KTPsupplement.Ado.Transaction.IsNull())
try { await db_F2KTPsupplement.Ado.CommitTranAsync(); } catch { };
_wareHouseService.GenTaskExecute();
stopwatch.Stop();
Console.WriteLine($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")} 结束二楼空托盘自动补充到线边 {stopwatch.ElapsedMilliseconds} ms");
LoggerTimer.LogInformation($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")} 结束二楼空托盘自动补充到线边 {stopwatch.ElapsedMilliseconds} ms");
}
}
#endregion
// 物料齐套配送记录
private async void WmsMaterialkit(object? args)
{
if (s_taskWmsMaterialkit.CurrentCount == 0)
return;
await s_taskWmsMaterialkit.WaitAsync();
Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();
try
{
var WmsMaterialkit = await db_WmsMaterialkit.Queryable().Where(p => p.key == "WmsMaterialkit").FirstAsync();
// 0则不进行移转
if (WmsMaterialkit != null && WmsMaterialkit.value == "0")
{
return;
}
Console.WriteLine($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")} 开始执行生成物料齐套配送记录");
LoggerTimer.LogInformation($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")} 开始执行生成物料齐套配送记录");
List prdMoTasks = await db_WmsMaterialkit.Queryable().Where(r => r.mo_task_status == DictConst.InProgressEnCode
&& !string.IsNullOrEmpty(r.parent_id)).ToListAsync();
LoggerWmsMaterialkit.LogInformation($"*********************************************************************************");
LoggerWmsMaterialkit.LogInformation($"查找到进行中的任务单:{string.Join(',', prdMoTasks.Select(r => r.mo_task_code))}");
Dictionary workstaiondic = db_WmsMaterialkit.Queryable().ToDictionary(k => k.Id, v => v.EnCode);
foreach (PrdMoTask prdMoTask in prdMoTasks)
{
List rep_prdMoTasks = prdMoTasks.Where(r => r.workstation_id == prdMoTask.workstation_id && r.id != prdMoTask.id).ToList();
if (rep_prdMoTasks.Count() > 0)
{
LoggerWmsMaterialkit.LogWarning($"存在与任务单{prdMoTask.mo_task_code}相同工位的状态为进行中的任务单{string.Join(',', rep_prdMoTasks.Select(r => r.mo_task_code))}");
continue;
}
await db_WmsMaterialkit.Ado.BeginTranAsync();
WmsMaterialkitRecordH wmsMaterialkitRecordH = await db_WmsMaterialkit.Queryable().Where(r => (r.status == WmsWareHouseConst.BILLSTATUS_ADD_ID || r.status == WmsWareHouseConst.BILLSTATUS_ON_ID || r.status == WmsWareHouseConst.BILLSTATUS_COMPLETE_ID)
&& r.workstation_id == prdMoTask.workstation_id).FirstAsync();
LoggerWmsMaterialkit.LogInformation($"查找任务单{prdMoTask.mo_task_code}的物料配送记录:{JsonConvert.SerializeObject(wmsMaterialkitRecordH)}");
if (wmsMaterialkitRecordH == null || (wmsMaterialkitRecordH != null && prdMoTask.id != wmsMaterialkitRecordH.mo_task_id))
{
if (wmsMaterialkitRecordH != null && prdMoTask.id != wmsMaterialkitRecordH.mo_task_id)
{
LoggerWmsMaterialkit.LogInformation($"取消任务单{prdMoTask.mo_task_code}的旧物料配送记录:{wmsMaterialkitRecordH.bill_code}");
// 取消旧物料配送记录
await db_WmsMaterialkit.Updateable().SetColumns(r =>
new WmsMaterialkitRecordH { status = WmsWareHouseConst.BILLSTATUS_CANCEL_ID, remark = $"由于任务单切换取消 {wmsMaterialkitRecordH.mo_task_code} -> {prdMoTask.mo_task_code}" })
.Where(r => r.id == wmsMaterialkitRecordH.id).ExecuteCommandAsync();
}
// 生成物料配送记录
BasMaterial basMaterial = await db_WmsMaterialkit.Queryable().Where(r => r.id == prdMoTask.material_id).FirstAsync();
string Code = await _billRullService.GetBillNumber("WmsMaterialkitRecordH");
wmsMaterialkitRecordH = new WmsMaterialkitRecordH();
wmsMaterialkitRecordH.org_id = WmsWareHouseConst.AdministratorOrgId;
wmsMaterialkitRecordH.create_id = WmsWareHouseConst.AdministratorUserId;
wmsMaterialkitRecordH.create_time = DateTime.Now;
wmsMaterialkitRecordH.bill_code = Code;
wmsMaterialkitRecordH.mo_task_id = prdMoTask.id;
wmsMaterialkitRecordH.mo_task_code = prdMoTask.mo_task_code;
wmsMaterialkitRecordH.bom_id = prdMoTask.bom_id;
wmsMaterialkitRecordH.material_id = prdMoTask.material_id;
wmsMaterialkitRecordH.material_code = basMaterial.code;
wmsMaterialkitRecordH.material_name = basMaterial.name;
wmsMaterialkitRecordH.material_specification = basMaterial.material_specification;
wmsMaterialkitRecordH.unit_code = prdMoTask.unit_id;
wmsMaterialkitRecordH.qty = prdMoTask.scheduled_qty;
wmsMaterialkitRecordH.workstation_id = prdMoTask.workstation_id;
wmsMaterialkitRecordH.status = WmsWareHouseConst.BILLSTATUS_ADD_ID;
wmsMaterialkitRecordH.times = 0;
wmsMaterialkitRecordH.total_time = 0;
WmsStationBom wmsStationBom = await db_WmsMaterialkit.Queryable().Where(r => r.product_id == prdMoTask.material_id
&& r.station_id == prdMoTask.workstation_id).FirstAsync();
if (wmsStationBom == null)
{
LoggerWmsMaterialkit.LogWarning($"任务单{prdMoTask.mo_task_code}绑定的工位{workstaiondic[prdMoTask.workstation_id]}以及物料id{prdMoTask.material_id}找不到对应的工位Bom资料");
continue;
}
List wmsStationBomD = await db_WmsMaterialkit.Queryable().Where(r => r.p_id == wmsStationBom.id).ToListAsync();
List materials = await db_WmsMaterialkit.Queryable().Where(r => wmsStationBomD.Select(x => x.material_id).Contains(r.id)).ToListAsync();
LoggerWmsMaterialkit.LogWarning($"任务单{prdMoTask.mo_task_code}绑定的工位{workstaiondic[prdMoTask.workstation_id]}找到对应的工位Bom清单{string.Join(',', wmsStationBomD.Select(r => r.material_id))}");
List wmsMaterialkitRecordDs = new List();
foreach (WmsStationBomD input in wmsStationBomD)
{
BasMaterial material = materials.Where(r => r.id == input.material_id).First();
if (material == null)
{
LoggerWmsMaterialkit.LogWarning($"任务单{prdMoTask.mo_task_code}绑定的工位Bom 产品{wmsStationBom.product_code} 工位 {wmsStationBom.station_code} 下的明细物料id{input.material_id}在物料档案中不存在");
continue;
}
// 暂存仓库存
var zccinventory = await db_WmsMaterialkit.Queryable()
.InnerJoin((a, b) => a.location_id == b.id)
.InnerJoin((a, b, c) => a.id == c.carry_id)
.InnerJoin((a, b, c, d) => c.membercarry_id == d.carry_id)
.InnerJoin((a, b, c, d, e) => d.material_id == e.id)
.Where((a, b, c, d, e) => b.wh_id == WmsWareHouseConst.WAREHOUSE_ZCC_ID && e.id == material.id && a.work_station == workstaiondic[prdMoTask.workstation_id].ToString())
.Select((a, b, c, d, e) => new customInventoryEntity
{
material_id = e.id,
material_code = e.code,
material_name = e.name,
material_specification = e.material_specification,
codeqty = d.codeqty,
unit_code = d.unit_id
}).ToListAsync();
LoggerWmsMaterialkit.LogWarning($"物料齐套计划{wmsMaterialkitRecordH.bill_code} 绑定工位{workstaiondic[prdMoTask.workstation_id].ToString()}的料箱物料{material.code}在暂存仓库存为{zccinventory.Sum(r => r.codeqty)}");
// 输送线库存
var ssxinventory = await db_WmsMaterialkit.Queryable()
.InnerJoin((a, b) => a.location_id == b.id)
.InnerJoin((a, b, c) => a.id == c.carry_id)
.InnerJoin((a, b, c, d) => d.id == c.material_id)
.Where((a, b, c, d) => (b.id == WmsWareHouseConst.ZZCSSX121009 || b.id == WmsWareHouseConst.ZZCSSX121010) && d.id == material.id
&& a.work_station == workstaiondic[prdMoTask.workstation_id].ToString())
.Select((a, b, c, d) => new customInventoryEntity
{
material_id = d.id,
material_code = d.code,
material_name = d.name,
material_specification = d.material_specification,
codeqty = c.codeqty,
unit_code = c.unit_id
}).ToListAsync();
LoggerWmsMaterialkit.LogWarning($"物料齐套计划{wmsMaterialkitRecordH.bill_code} 绑定工位{workstaiondic[prdMoTask.workstation_id].ToString()}的料箱物料{material.code}在输送线库存为{ssxinventory.Sum(r => r.codeqty)}");
// 正在配送
var inroadinventory = await db_WmsMaterialkit.Queryable()
.InnerJoin((a, b) => a.carry_id == b.id)
.InnerJoin((a, b, c) => c.carry_id == b.id)
.InnerJoin((a, b, c, d) => d.id == c.material_id)
.InnerJoin((a, b, c, d, e) => a.id == e.pretask_id)
.InnerJoin((a, b, c, d, e, f) => e.mat_bill_id == f.id)
.Where((a, b, c, d, e, f) => a.status != WmsWareHouseConst.PRETASK_BILL_STATUS_COMPLE_ID && a.status != WmsWareHouseConst.PRETASK_BILL_STATUS_CANCEL_ID
&& (a.endlocation_id == WmsWareHouseConst.ZZCSSX121009 || a.endlocation_id == WmsWareHouseConst.ZZCSSX121010) && d.id == material.id && f.station_code == workstaiondic[prdMoTask.workstation_id].ToString())
.Select((a, b, c, d) => new customInventoryEntity
{
material_id = d.id,
material_code = d.code,
material_name = d.name,
material_specification = d.material_specification,
codeqty = c.codeqty,
unit_code = c.unit_id
}).ToListAsync();
LoggerWmsMaterialkit.LogWarning($"物料齐套计划{wmsMaterialkitRecordH.bill_code} 绑定工位{workstaiondic[prdMoTask.workstation_id].ToString()}的料箱物料{material.code}正在配送中的数量为{inroadinventory.Sum(r => r.codeqty)}");
List inventory = new List();
inventory.AddRange(zccinventory);
inventory.AddRange(ssxinventory);
inventory.AddRange(inroadinventory);
inventory.GroupBy(g => new { g.material_id, g.material_code, g.material_name, g.material_specification, g.unit_code }).Select(g =>
{
customInventoryEntity newinventory = new customInventoryEntity();
newinventory.material_id = g.Key.material_id;
newinventory.material_code = g.Key.material_code;
newinventory.material_name = g.Key.material_name;
newinventory.material_specification = g.Key.material_specification;
newinventory.unit_code = g.Key.unit_code;
newinventory.codeqty = inventory.Where(r => r.material_id == newinventory.material_id && r.unit_code == newinventory.unit_code).Sum(s => s.codeqty);
return newinventory;
});
// 查询已有库存 (多工单情况下要考虑库存是否被其它工单预留 暂定)
decimal? exists_qty = inventory.Sum(r => r.codeqty);
if (exists_qty < prdMoTask.scheduled_qty * input.denominator / input.molecule)
{
WmsMaterialkitRecordD wmsMaterialkitRecordD = new WmsMaterialkitRecordD();
wmsMaterialkitRecordD.create_id = WmsWareHouseConst.AdministratorUserId;
wmsMaterialkitRecordD.create_time = DateTime.Now;
wmsMaterialkitRecordD.bill_id = wmsMaterialkitRecordH.id;
wmsMaterialkitRecordD.material_id = material.id;
wmsMaterialkitRecordD.material_code = material.code;
wmsMaterialkitRecordD.material_name = material.name;
wmsMaterialkitRecordD.material_specification = material.material_specification;
wmsMaterialkitRecordD.unit_code = material.unit_id;
wmsMaterialkitRecordD.plan_qty = prdMoTask.scheduled_qty * input.denominator / input.molecule - exists_qty;
wmsMaterialkitRecordD.yxf_qty = 0;
wmsMaterialkitRecordD.molecule = input.molecule;
wmsMaterialkitRecordD.denominator = input.denominator;
wmsMaterialkitRecordD.status = WmsWareHouseConst.BILLSTATUS_ADD_ID;
wmsMaterialkitRecordD.times = 0;
wmsMaterialkitRecordD.total_time = 0;
wmsMaterialkitRecordDs.Add(wmsMaterialkitRecordD);
}
}
await db_WmsMaterialkit.Insertable(wmsMaterialkitRecordH).ExecuteCommandAsync();
await db_WmsMaterialkit.Insertable(wmsMaterialkitRecordDs).ExecuteCommandAsync();
LoggerWmsMaterialkit.LogInformation($"生成任务单{prdMoTask.mo_task_code}的新物料配送记录:{wmsMaterialkitRecordH.bill_code}");
}
await db_WmsMaterialkit.Ado.CommitTranAsync();
}
List wmsMaterialkitRecordHs = await db_WmsMaterialkit.Queryable().Where(r => (r.status == WmsWareHouseConst.BILLSTATUS_ADD_ID
|| r.status == WmsWareHouseConst.BILLSTATUS_ON_ID)).ToListAsync();
LoggerWmsMaterialkit.LogInformation($"查找到需要运算的物料配送记录:{JsonConvert.SerializeObject(string.Join(',', wmsMaterialkitRecordHs.Select(r => r.bill_code)))}");
if (wmsMaterialkitRecordHs.Count == 0)
return;
List wmsMaterialTransfers = await db_WmsMaterialkit.Queryable().Where(r => r.status != WmsWareHouseConst.BILLSTATUS_COMPLETE_ID
&& r.status != WmsWareHouseConst.BILLSTATUS_CANCEL_ID && r.type == WmsWareHouseConst.MATERIALTRANSFER_QTCRK_CODE).ToListAsync();
// 执行暂存仓库存检查与转库单下发
foreach (WmsMaterialkitRecordH wmsMaterialkitRecord in wmsMaterialkitRecordHs)
{
List wmsMaterialTransferDs = await db_WmsMaterialkit.Queryable()
.Where(r => wmsMaterialTransfers.Select(x => x.id).Contains(r.bill_id) && r.station_code == workstaiondic[wmsMaterialkitRecord.workstation_id].ToString()).OrderBy(r => r.id).ToListAsync();
List wmsMaterialkitRecordDs = await db_WmsMaterialkit.Queryable()
.Where(r => r.bill_id == wmsMaterialkitRecord.id && r.status != WmsWareHouseConst.BILLSTATUS_COMPLETE_ID && r.status != WmsWareHouseConst.BILLSTATUS_CANCEL_ID).ToListAsync();
List wmsMaterialkitRecordTs = new List();
foreach (WmsMaterialkitRecordD wmsMaterialkitRecordD in wmsMaterialkitRecordDs)
{
Stopwatch stopwatch2 = new Stopwatch();
stopwatch2.Start();
// 需要下发的数量
decimal? need_qty = wmsMaterialkitRecordD.plan_qty - wmsMaterialkitRecordD.yxf_qty;
// 查询转库单
List _wmsMaterialTransferDs = wmsMaterialTransferDs.Where(r => r.material_id == wmsMaterialkitRecordD.material_id).ToList();
await db_WmsMaterialkit.Ado.BeginTranAsync();
decimal? xf_qty = 0;
LoggerWmsMaterialkit.LogWarning($"物料齐套计划{wmsMaterialkitRecord.bill_code} 绑定工位{workstaiondic[wmsMaterialkitRecord.workstation_id].ToString()}的料箱物料{wmsMaterialkitRecordD.material_code} 可使用转库单明细为{string.Join(',', _wmsMaterialTransferDs.Select(r => r.id))}");
foreach (WmsMaterialTransferD _wmsMaterialTransferD in _wmsMaterialTransferDs)
{
if (need_qty <= 0)
break;
DateTime startTime = DateTime.Now;
// 转库单可以下发的数量
decimal? zkcan_qty = _wmsMaterialTransferD.qty - _wmsMaterialTransferD.yxfqty;
// 可以下发的数量
decimal? can_qty = 0;
// 多余数量切换到下一个转库单
can_qty = zkcan_qty < need_qty ? zkcan_qty : need_qty;
// 查询库存是否有可以下发数量的库存(同批次)
// 中储仓库存
OutStockStrategyZCC2Floor2Query OutStockStrategyInput = new()
{
warehouse_id = WmsWareHouseConst.WAREHOUSE_ZC_ID,
material_id = _wmsMaterialTransferD.material_id,
code_batch = _wmsMaterialTransferD.code_batch,
needOut = can_qty,
material_code = _wmsMaterialTransferD.material_code,
endlocations = new string[2] { WmsWareHouseConst.ZZCSSX121009, WmsWareHouseConst.ZZCSSX121010 }
};
List>? carrys = null;
try
{
carrys = await _wareHouseService.OutStockStrategyZCC2Floor2(OutStockStrategyInput);
}
catch(Exception ex)
{
LoggerWmsMaterialkit.LogWarning($"物料齐套计划{wmsMaterialkitRecord.bill_code} 绑定工位{workstaiondic[wmsMaterialkitRecord.workstation_id].ToString()}的料箱{ex.Message}");
continue;
}
List items = carrys.Select(r => r.Item1).ToList();
List wmsCarryCodes = await db_WmsMaterialkit.Queryable()
.Where(r => r.material_id == _wmsMaterialTransferD.material_id && r.code_batch == _wmsMaterialTransferD.code_batch
&& items.Select(x => x.id).Contains(r.carry_id)).ToListAsync();
decimal? inv_qty = carrys.Sum(r => r.Item2);
can_qty = inv_qty > can_qty ? can_qty : inv_qty;
WmsMaterialTransfer wmsMaterialTransfer = await db_WmsMaterialkit.Queryable().Where(r => r.id == _wmsMaterialTransferD.bill_id).FirstAsync();
LoggerWmsMaterialkit.LogWarning($"转库单{wmsMaterialTransfer.bill_code} 明细id{_wmsMaterialTransferD.id} 物料{_wmsMaterialTransferD.material_code} 批次{_wmsMaterialTransferD.code_batch} 中储仓出库时出库的物料数量为{carrys.Sum(r => r.Item2)}其中需要的数量为{inv_qty}");
if (can_qty <= 0)
{
LoggerWmsMaterialkit.LogWarning($"物料齐套计划{wmsMaterialkitRecord.bill_code} 绑定工位{workstaiondic[wmsMaterialkitRecord.workstation_id].ToString()}的料箱物料{_wmsMaterialTransferD.material_code} 可下发数量为0");
continue;
}
MaterialTransferDDistributeToZCCInput input = new MaterialTransferDDistributeToZCCInput();
input.source_id = _wmsMaterialTransferD.id;
input.xf_qty = can_qty;
WarehouseMgr.Entities.Dto.Outputs.Result result = await _wmsMaterialTransferService.DistributeDetailToZCC(input, db_WmsMaterialkit);
if (result.code.ToString() != "OK")
{
LoggerWmsMaterialkit.LogWarning($"转库单{wmsMaterialTransfer.bill_code} 明细id{_wmsMaterialTransferD.id} 物料{_wmsMaterialTransferD.material_code} 批次{_wmsMaterialTransferD.code_batch} 中储仓出库时数量不匹配！");
continue;
}
LoggerWmsMaterialkit.LogWarning($"转库单{wmsMaterialTransfer.bill_code} 明细id{_wmsMaterialTransferD.id} 物料{_wmsMaterialTransferD.material_code} 批次{_wmsMaterialTransferD.code_batch} 中储仓出库料箱为{string.Join(',', items.Select(x => x.carry_code))}");
DateTime endTime = DateTime.Now;
WmsMaterialkitRecordT wmsMaterialkitRecordT = new WmsMaterialkitRecordT();
wmsMaterialkitRecordT.create_id = WmsWareHouseConst.AdministratorUserId;
wmsMaterialkitRecordT.create_time = DateTime.Now;
wmsMaterialkitRecordT.bill_id = wmsMaterialkitRecord.id;
wmsMaterialkitRecordT.bill_d_id = _wmsMaterialTransferD.id;
wmsMaterialkitRecordT.materialtransfer_id = wmsMaterialTransfer.id;
wmsMaterialkitRecordT.materialtransfer_billcode = wmsMaterialTransfer.bill_code;
wmsMaterialkitRecordT.materialtransfer_d_id = _wmsMaterialTransferD.id;
wmsMaterialkitRecordT.oldqty = wmsMaterialkitRecordD.yxf_qty;
wmsMaterialkitRecordT.newqty = wmsMaterialkitRecordD.yxf_qty + can_qty;
wmsMaterialkitRecordT.material_id = _wmsMaterialTransferD.material_id;
wmsMaterialkitRecordT.material_code = _wmsMaterialTransferD.material_code;
wmsMaterialkitRecordT.material_name = _wmsMaterialTransferD.material_ex;
wmsMaterialkitRecordT.material_specification = _wmsMaterialTransferD.material_specification;
wmsMaterialkitRecordT.code_batch = _wmsMaterialTransferD.code_batch;
wmsMaterialkitRecordT.unit_code = _wmsMaterialTransferD.unit_code;
wmsMaterialkitRecordT.xf_qty = can_qty;
wmsMaterialkitRecordT.start_time = startTime;
wmsMaterialkitRecordT.end_time = endTime;
wmsMaterialkitRecordT.total_time = (int)(endTime - startTime).TotalMilliseconds;
wmsMaterialkitRecordTs.Add(wmsMaterialkitRecordT);
xf_qty += can_qty;
need_qty = need_qty - can_qty;
}
await db_WmsMaterialkit.Insertable(wmsMaterialkitRecordTs).ExecuteCommandAsync();
stopwatch2.Stop();
await db_WmsMaterialkit.Updateable().SetColumns(r => new WmsMaterialkitRecordD
{
yxf_qty = r.yxf_qty + xf_qty,
times = r.times + 1,
total_time = r.total_time + (int)stopwatch2.ElapsedMilliseconds,
status = wmsMaterialkitRecordD.yxf_qty + xf_qty >= r.plan_qty ? WmsWareHouseConst.BILLSTATUS_COMPLETE_ID : WmsWareHouseConst.BILLSTATUS_ON_ID
})
.Where(r => r.id == wmsMaterialkitRecordD.id).ExecuteCommandAsync();
await db_WmsMaterialkit.Updateable().SetColumns(r => new WmsMaterialkitRecordH
{
times = r.times + 1,
total_time = r.total_time + (int)stopwatch2.ElapsedMilliseconds
})
.Where(r => r.id == wmsMaterialkitRecordD.bill_id).ExecuteCommandAsync();
await db_WmsMaterialkit.Ado.CommitTranAsync();
LoggerWmsMaterialkit.LogInformation($"物料齐套配送明细id{wmsMaterialkitRecordD.id}已下发,耗时{stopwatch2.ElapsedMilliseconds} ms");
}
List WmsMaterialkitRecordDs = db_WmsMaterialkit.Queryable()
.Where(a => a.bill_id == wmsMaterialkitRecord.id && a.yxf_qty < a.plan_qty).ToList();
if (WmsMaterialkitRecordDs.Count == 0)
{
await db_WmsMaterialkit.Updateable().SetColumns(it => new WmsMaterialkitRecordH { status = WmsWareHouseConst.BILLSTATUS_COMPLETE_ID })
.Where(it => it.id == wmsMaterialkitRecord.id).ExecuteCommandHasChangeAsync();
}
LoggerWmsMaterialkit.LogInformation($"物料配送记录{wmsMaterialkitRecord.bill_code}已下发");
}
}
catch (ObjectDisposedException ex)
{
LoggerWmsMaterialkit.LogWarning($"【物料齐套配送】 数据库连接异常:{ex.Message}");
LoggerWmsMaterialkit.LogWarning($"【物料齐套配送】 数据库连接异常:{ex.StackTrace}");
if (ex.Source == "Npgsql")
db_WmsMaterialkit = _repository.AsSugarClient().CopyNew();
}
catch (Exception ex)
{
Console.WriteLine("【物料齐套配送】" + ex.Message);
LoggerWmsMaterialkit.LogWarning($"【物料齐套配送】 {ex.Message}");
LoggerWmsMaterialkit.LogWarning($"【物料齐套配送】 {ex.StackTrace}");
// 数据库连接断开时会报错
try { await db_WmsMaterialkit.Ado.RollbackTranAsync(); } catch { };
}
finally
{
s_taskWmsMaterialkit.Release();
if (!db_WmsMaterialkit.Ado.Transaction.IsNull())
try { await db_WmsMaterialkit.Ado.CommitTranAsync(); } catch { };
_wareHouseService.GenTaskExecute();
stopwatch.Stop();
Console.WriteLine($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")} 结束物料齐套配送记录 {stopwatch.ElapsedMilliseconds} ms");
LoggerTimer.LogInformation($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")} 结束物料齐套配送记录 {stopwatch.ElapsedMilliseconds} ms");
}
}
public Task StartAsync(CancellationToken cancellationToken)
{
CheckGettimer = new Timer(CheckGet, null, TimeSpan.Zero, TimeSpan.FromSeconds(10));
Scantimer = new Timer(ScanInStock, null, TimeSpan.Zero, TimeSpan.FromSeconds(30));
SSXcodetimer = new Timer(SSXcode, null, TimeSpan.Zero, TimeSpan.FromSeconds(5));
// 八工位缓存区补充空托盘
BGWCarrySupplementtimer = new Timer(BGWCarrySupplement, null, TimeSpan.Zero, TimeSpan.FromSeconds(30));
// 供料叠盘机空托盘自动入库
YCLGLDPJInstocktimer = new Timer(YCLGLDPJInstock, null, TimeSpan.FromSeconds(5), TimeSpan.FromSeconds(30));
// 外协叠盘机空托盘自动入库
YCLWXDPJInstocktimer = new Timer(YCLWXDPJInstock, null, TimeSpan.FromSeconds(10), TimeSpan.FromSeconds(30));
// 二楼上升降机
Floor2UpMachinecodetimer = new Timer(Floor2UpMachinecode, null, TimeSpan.Zero, TimeSpan.FromSeconds(5));
// 二楼料架配送
Floor2timer送空托到上升降区 = new Timer(送空托到上升降区, null, TimeSpan.Zero, TimeSpan.FromSeconds(30));
Floor2timer送满托到下升降区 = new Timer(送满托到下升降区, null, TimeSpan.FromSeconds(5), TimeSpan.FromSeconds(30));
Floor2timer移走上升降区未生成预任务且满托的料架 = new Timer(移走上升降区未生成预任务且满托的料架, null, TimeSpan.Zero, TimeSpan.FromSeconds(30));
Floor2timer移走下升降区未生成预任务且空托的料架 = new Timer(移走下升降区未生成预任务且空托的料架, null, TimeSpan.FromSeconds(5), TimeSpan.FromSeconds(30));
GenTaskExecutetimer = new Timer(GenTaskExecute, null, TimeSpan.Zero, TimeSpan.FromSeconds(30));
// 停用
//PackOutstockServicetimer = new Timer(PackOutstockService, null, TimeSpan.Zero, TimeSpan.FromSeconds(60));
Floor4DMJ2MJXtimer = new Timer(Floor4DMJ2MJX, null, TimeSpan.Zero, TimeSpan.FromSeconds(10));
Floor4MJX2MJCtimer = new Timer(Floor4MJX2MJC, null, TimeSpan.Zero, TimeSpan.FromSeconds(10));
Floor4DMC2CPKtimer = new Timer(Floor4DMC2CPK, null, TimeSpan.Zero, TimeSpan.FromSeconds(10));
F2KTPsupplementtimer = new Timer(F2KTPsupplement, null, TimeSpan.Zero, TimeSpan.FromSeconds(30));
YCLInternalTransfertimer = new Timer(YCLInternalTransfer, null, TimeSpan.FromSeconds(15), TimeSpan.FromSeconds(185));
elevatorTimer = new Timer(ElevatorTaskExceptionHandle, null, TimeSpan.FromSeconds(10), TimeSpan.FromSeconds(10));
agvelevatorTimer = new Timer(AgvelevatorTimerTaskExceptionHandle, null, TimeSpan.FromSeconds(10), TimeSpan.FromSeconds(10));
WmsMaterialkittimer = new Timer(WmsMaterialkit, null, TimeSpan.FromSeconds(5), TimeSpan.FromSeconds(300));
return Task.CompletedTask;
}
public Task StopAsync(CancellationToken cancellationToken)
{
return Task.CompletedTask;
}
public void Dispose()
{
Console.WriteLine("*****************Dispose*****************");
Log.Information("*****************Dispose*****************");
Readtimer?.Dispose();
CheckGettimer?.Dispose();
Scantimer?.Dispose();
SSXcodetimer?.Dispose();
Floor2UpMachinecodetimer?.Dispose();
Floor2timer送空托到上升降区?.Dispose();
Floor2timer送满托到下升降区?.Dispose();
Floor2timer移走上升降区未生成预任务且满托的料架?.Dispose();
Floor2timer移走下升降区未生成预任务且空托的料架?.Dispose();
BGWCarrySupplementtimer?.Dispose();
YCLGLDPJInstocktimer?.Dispose();
YCLWXDPJInstocktimer?.Dispose();
GenTaskExecutetimer?.Dispose();
PackOutstockServicetimer?.Dispose();
Floor4DMJ2MJXtimer?.Dispose();
Floor4MJX2MJCtimer?.Dispose();
Floor4DMC2CPKtimer?.Dispose();
F2KTPsupplementtimer?.Dispose();
YCLInternalTransfertimer?.Dispose();
elevatorTimer?.Dispose();
agvelevatorTimer?.Dispose();
WmsMaterialkittimer?.Dispose();
}
#region 日志
private static readonly Dictionary s_logLevelMap = new()
{
[LogLevel.Debug] = "DBG",
[LogLevel.Information] = "INF",
[LogLevel.Warning] = "WRN",
[LogLevel.Error] = "ERR",
};
protected string _LoggerElevatorTaskFileName = "";
protected ILogger _LoggerElevatorTask;
protected ILogger LoggerElevatorTask
{
get
{
string newFileName = $"{AppContext.BaseDirectory}/logs/{DateTime.Now:yyyyMMdd}/custom{DateTime.Now:yyyyMMdd}ElevatorTask.log";
if (_LoggerElevatorTaskFileName != newFileName)
{
ILoggerFactory loggerFactory = LoggerFactory.Create(builder => builder.AddFile(newFileName, cfgOpts =>
{
//cfgOpts.DateFormat = "yyyy-MM-dd HH:mm:ss.fff";
cfgOpts.MessageFormat = (logMsg) =>
{
var logLevel = s_logLevelMap[logMsg.LogLevel];
var sb = new StringBuilder();
_ = sb.Append($"[{logLevel}] ");
_ = sb.Append($"{logMsg.LogName} ");
_ = sb.Append($"{DateTime.Now:yyyy-MM-dd HH:mm:ss.fff} ");
_ = sb.Append($"#{logMsg.EventId.Id} ");
_ = sb.Append(logMsg.Message + " ");
_ = sb.Append(logMsg.Exception?.ToString());
return sb.ToString();
};
}));
_LoggerElevatorTask = loggerFactory.CreateLogger(this.GetType());
_LoggerElevatorTaskFileName = newFileName;
}
return _LoggerElevatorTask;
}
}
protected string _LoggerSSXFileName = "";
protected ILogger _LoggerSSX;
protected ILogger LoggerSSX
{
get
{
string newFileName = $"{AppContext.BaseDirectory}/logs/{DateTime.Now:yyyyMMdd}/中储仓/custom{DateTime.Now:yyyyMMdd}中储仓输送线.log";
if (_LoggerSSXFileName != newFileName)
{
ILoggerFactory loggerFactory = LoggerFactory.Create(builder => builder.AddFile(newFileName, cfgOpts =>
{
//cfgOpts.DateFormat = "yyyy-MM-dd HH:mm:ss.fff";
cfgOpts.MessageFormat = (logMsg) =>
{
var logLevel = s_logLevelMap[logMsg.LogLevel];
var sb = new StringBuilder();
_ = sb.Append($"[{logLevel}] ");
_ = sb.Append($"{logMsg.LogName} ");
_ = sb.Append($"{DateTime.Now:yyyy-MM-dd HH:mm:ss.fff} ");
_ = sb.Append($"#{logMsg.EventId.Id} ");
_ = sb.Append(logMsg.Message + " ");
_ = sb.Append(logMsg.Exception?.ToString());
return sb.ToString();
};
}));
_LoggerSSX = loggerFactory.CreateLogger(this.GetType());
_LoggerSSXFileName = newFileName;
}
return _LoggerSSX;
}
}
// 二楼上下升降机日志
protected string _LoggerFloor2UpDownMachineFileName = "";
protected ILogger _LoggerFloor2UpDownMachine;
protected ILogger LoggerFloor2UpDownMachine
{
get
{
string newFileName = $"{AppContext.BaseDirectory}/logs/{DateTime.Now:yyyyMMdd}/二楼暂存仓/custom{DateTime.Now:yyyyMMdd}二楼暂存仓机械手.log";
if (_LoggerFloor2UpDownMachineFileName != newFileName)
{
ILoggerFactory loggerFactory = LoggerFactory.Create(builder => builder.AddFile(newFileName, cfgOpts =>
{
//cfgOpts.DateFormat = "yyyy-MM-dd HH:mm:ss.fff";
cfgOpts.MessageFormat = (logMsg) =>
{
var logLevel = s_logLevelMap[logMsg.LogLevel];
var sb = new StringBuilder();
_ = sb.Append($"[{logLevel}] ");
_ = sb.Append($"{logMsg.LogName} ");
_ = sb.Append($"{DateTime.Now:yyyy-MM-dd HH:mm:ss.fff} ");
_ = sb.Append($"#{logMsg.EventId.Id} ");
_ = sb.Append(logMsg.Message + " ");
_ = sb.Append(logMsg.Exception?.ToString());
return sb.ToString();
};
}));
_LoggerFloor2UpDownMachine = loggerFactory.CreateLogger(this.GetType());
_LoggerFloor2UpDownMachineFileName = newFileName;
}
return _LoggerFloor2UpDownMachine;
}
}
// 二楼料架补充
protected string _LoggerFloor2RackDeliveryFileName = "";
protected ILogger _LoggerFloor2RackDelivery;
protected ILogger LoggerFloor2RackDelivery
{
get
{
string newFileName = $"{AppContext.BaseDirectory}/logs/{DateTime.Now:yyyyMMdd}/二楼暂存仓/custom{DateTime.Now:yyyyMMdd}二楼暂存仓配送任务.log";
if (_LoggerFloor2RackDeliveryFileName != newFileName)
{
ILoggerFactory loggerFactory = LoggerFactory.Create(builder => builder.AddFile(newFileName, cfgOpts =>
{
//cfgOpts.DateFormat = "yyyy-MM-dd HH:mm:ss.fff";
cfgOpts.MessageFormat = (logMsg) =>
{
var logLevel = s_logLevelMap[logMsg.LogLevel];
var sb = new StringBuilder();
_ = sb.Append($"[{logLevel}] ");
_ = sb.Append($"{logMsg.LogName} ");
_ = sb.Append($"{DateTime.Now:yyyy-MM-dd HH:mm:ss.fff} ");
_ = sb.Append($"#{logMsg.EventId.Id} ");
_ = sb.Append(logMsg.Message + " ");
_ = sb.Append(logMsg.Exception?.ToString());
return sb.ToString();
};
}));
_LoggerFloor2RackDelivery = loggerFactory.CreateLogger(this.GetType());
_LoggerFloor2RackDeliveryFileName = newFileName;
}
return _LoggerFloor2RackDelivery;
}
}
protected string _LoggerBGWCarrySupplementFileName = "";
protected ILogger _LoggerBGWCarrySupplement;
protected ILogger LoggerBGWCarrySupplement
{
get
{
string newFileName = $"{AppContext.BaseDirectory}/logs/{DateTime.Now:yyyyMMdd}/原材料仓/custom{DateTime.Now:yyyyMMdd}八工位入库/空托盘补充.log";
if (_LoggerBGWCarrySupplementFileName != newFileName)
{
ILoggerFactory loggerFactory = LoggerFactory.Create(builder => builder.AddFile(newFileName, cfgOpts =>
{
//cfgOpts.DateFormat = "yyyy-MM-dd HH:mm:ss.fff";
cfgOpts.MessageFormat = (logMsg) =>
{
var logLevel = s_logLevelMap[logMsg.LogLevel];
var sb = new StringBuilder();
_ = sb.Append($"[{logLevel}] ");
_ = sb.Append($"{logMsg.LogName} ");
_ = sb.Append($"{DateTime.Now:yyyy-MM-dd HH:mm:ss.fff} ");
_ = sb.Append($"#{logMsg.EventId.Id} ");
_ = sb.Append(logMsg.Message + " ");
_ = sb.Append(logMsg.Exception?.ToString());
return sb.ToString();
};
}));
_LoggerBGWCarrySupplement = loggerFactory.CreateLogger(this.GetType());
_LoggerBGWCarrySupplementFileName = newFileName;
}
return _LoggerBGWCarrySupplement;
}
}
protected string _LoggerYCLGLDPJInstockFileName = "";
protected ILogger _LoggerYCLGLDPJInstock;
protected ILogger LoggerYCLGLDPJInstock
{
get
{
string newFileName = $"{AppContext.BaseDirectory}/logs/{DateTime.Now:yyyyMMdd}/原材料仓/custom{DateTime.Now:yyyyMMdd}原材料供料叠盘机.log";
if (_LoggerYCLGLDPJInstockFileName != newFileName)
{
ILoggerFactory loggerFactory = LoggerFactory.Create(builder => builder.AddFile(newFileName, cfgOpts =>
{
//cfgOpts.DateFormat = "yyyy-MM-dd HH:mm:ss.fff";
cfgOpts.MessageFormat = (logMsg) =>
{
var logLevel = s_logLevelMap[logMsg.LogLevel];
var sb = new StringBuilder();
_ = sb.Append($"[{logLevel}] ");
_ = sb.Append($"{logMsg.LogName} ");
_ = sb.Append($"{DateTime.Now:yyyy-MM-dd HH:mm:ss.fff} ");
_ = sb.Append($"#{logMsg.EventId.Id} ");
_ = sb.Append(logMsg.Message + " ");
_ = sb.Append(logMsg.Exception?.ToString());
return sb.ToString();
};
}));
_LoggerYCLGLDPJInstock = loggerFactory.CreateLogger(this.GetType());
_LoggerYCLGLDPJInstockFileName = newFileName;
}
return _LoggerYCLGLDPJInstock;
}
}
protected string _LoggerTimerFileName = "";
protected ILogger _LoggerTimer;
protected ILogger LoggerTimer
{
get
{
string newFileName = $"{AppContext.BaseDirectory}/logs/{DateTime.Now:yyyyMMdd}/custom{DateTime.Now:yyyyMMdd}Timer.log";
if (_LoggerTimerFileName != newFileName)
{
ILoggerFactory loggerFactory = LoggerFactory.Create(builder => builder.AddFile(newFileName, cfgOpts =>
{
//cfgOpts.DateFormat = "yyyy-MM-dd HH:mm:ss.fff";
cfgOpts.MessageFormat = (logMsg) =>
{
var logLevel = s_logLevelMap[logMsg.LogLevel];
var sb = new StringBuilder();
_ = sb.Append($"[{logLevel}] ");
_ = sb.Append($"{logMsg.LogName} ");
_ = sb.Append($"{DateTime.Now:yyyy-MM-dd HH:mm:ss.fff} ");
_ = sb.Append($"#{logMsg.EventId.Id} ");
_ = sb.Append(logMsg.Message + " ");
_ = sb.Append(logMsg.Exception?.ToString());
return sb.ToString();
};
}));
_LoggerTimer = loggerFactory.CreateLogger(this.GetType());
_LoggerTimerFileName = newFileName;
}
return _LoggerTimer;
}
}
protected string _LoggerFloor4DMJ2MJXFileName = "";
protected ILogger _LoggerFloor4DMJ2MJX;
protected ILogger LoggerFloor4DMJ2MJX
{
get
{
string newFileName = $"{AppContext.BaseDirectory}/logs/{DateTime.Now:yyyyMMdd}/四楼灭菌/custom{DateTime.Now:yyyyMMdd}待灭菌到上料点.log";
if (_LoggerFloor4DMJ2MJXFileName != newFileName)
{
ILoggerFactory loggerFactory = LoggerFactory.Create(builder => builder.AddFile(newFileName, cfgOpts =>
{
//cfgOpts.DateFormat = "yyyy-MM-dd HH:mm:ss.fff";
cfgOpts.MessageFormat = (logMsg) =>
{
var logLevel = s_logLevelMap[logMsg.LogLevel];
var sb = new StringBuilder();
_ = sb.Append($"[{logLevel}] ");
_ = sb.Append($"{logMsg.LogName} ");
_ = sb.Append($"{DateTime.Now:yyyy-MM-dd HH:mm:ss.fff} ");
_ = sb.Append($"#{logMsg.EventId.Id} ");
_ = sb.Append(logMsg.Message + " ");
_ = sb.Append(logMsg.Exception?.ToString());
return sb.ToString();
};
}));
_LoggerFloor4DMJ2MJX = loggerFactory.CreateLogger(this.GetType());
_LoggerFloor4DMJ2MJXFileName = newFileName;
}
return _LoggerFloor4DMJ2MJX;
}
}
protected string _LoggerFloor4MJX2MJCFileName = "";
protected ILogger _LoggerFloor4MJX2MJC;
protected ILogger LoggerFloor4MJX2MJC
{
get
{
string newFileName = $"{AppContext.BaseDirectory}/logs/{DateTime.Now:yyyyMMdd}/四楼灭菌/custom{DateTime.Now:yyyyMMdd}下料点到灭菌区.log";
if (_LoggerFloor4MJX2MJCFileName != newFileName)
{
ILoggerFactory loggerFactory = LoggerFactory.Create(builder => builder.AddFile(newFileName, cfgOpts =>
{
//cfgOpts.DateFormat = "yyyy-MM-dd HH:mm:ss.fff";
cfgOpts.MessageFormat = (logMsg) =>
{
var logLevel = s_logLevelMap[logMsg.LogLevel];
var sb = new StringBuilder();
_ = sb.Append($"[{logLevel}] ");
_ = sb.Append($"{logMsg.LogName} ");
_ = sb.Append($"{DateTime.Now:yyyy-MM-dd HH:mm:ss.fff} ");
_ = sb.Append($"#{logMsg.EventId.Id} ");
_ = sb.Append(logMsg.Message + " ");
_ = sb.Append(logMsg.Exception?.ToString());
return sb.ToString();
};
}));
_LoggerFloor4MJX2MJC = loggerFactory.CreateLogger(this.GetType());
_LoggerFloor4MJX2MJCFileName = newFileName;
}
return _LoggerFloor4MJX2MJC;
}
}
protected string _LoggerFloor4DMC2CPKFileName = "";
protected ILogger _LoggerFloor4DMC2CPK;
protected ILogger LoggerFloor4DMC2CPK
{
get
{
string newFileName = $"{AppContext.BaseDirectory}/logs/{DateTime.Now:yyyyMMdd}/四楼灭菌/custom{DateTime.Now:yyyyMMdd}四楼灭菌线到解析仓.log";
if (_LoggerFloor4DMC2CPKFileName != newFileName)
{
ILoggerFactory loggerFactory = LoggerFactory.Create(builder => builder.AddFile(newFileName, cfgOpts =>
{
//cfgOpts.DateFormat = "yyyy-MM-dd HH:mm:ss.fff";
cfgOpts.MessageFormat = (logMsg) =>
{
var logLevel = s_logLevelMap[logMsg.LogLevel];
var sb = new StringBuilder();
_ = sb.Append($"[{logLevel}] ");
_ = sb.Append($"{logMsg.LogName} ");
_ = sb.Append($"{DateTime.Now:yyyy-MM-dd HH:mm:ss.fff} ");
_ = sb.Append($"#{logMsg.EventId.Id} ");
_ = sb.Append(logMsg.Message + " ");
_ = sb.Append(logMsg.Exception?.ToString());
return sb.ToString();
};
}));
_LoggerFloor4DMC2CPK = loggerFactory.CreateLogger(this.GetType());
_LoggerFloor4DMC2CPKFileName = newFileName;
}
return _LoggerFloor4DMC2CPK;
}
}
protected string _LoggerF2KTPsupplementFileName = "";
protected ILogger _LoggerF2KTPsupplement;
protected ILogger LoggerF2KTPsupplement
{
get
{
string newFileName = $"{AppContext.BaseDirectory}/logs/{DateTime.Now:yyyyMMdd}/二楼组装线/custom{DateTime.Now:yyyyMMdd}二楼空托盘补充.log";
if (_LoggerF2KTPsupplementFileName != newFileName)
{
ILoggerFactory loggerFactory = LoggerFactory.Create(builder => builder.AddFile(newFileName, cfgOpts =>
{
//cfgOpts.DateFormat = "yyyy-MM-dd HH:mm:ss.fff";
cfgOpts.MessageFormat = (logMsg) =>
{
var logLevel = s_logLevelMap[logMsg.LogLevel];
var sb = new StringBuilder();
_ = sb.Append($"[{logLevel}] ");
_ = sb.Append($"{logMsg.LogName} ");
_ = sb.Append($"{DateTime.Now:yyyy-MM-dd HH:mm:ss.fff} ");
_ = sb.Append($"#{logMsg.EventId.Id} ");
_ = sb.Append(logMsg.Message + " ");
_ = sb.Append(logMsg.Exception?.ToString());
return sb.ToString();
};
}));
_LoggerF2KTPsupplement = loggerFactory.CreateLogger(this.GetType());
_LoggerF2KTPsupplementFileName = newFileName;
}
return _LoggerF2KTPsupplement;
}
}
protected string _LoggerYCLInternalTransferFileName = "";
protected ILogger _LoggerYCLInternalTransfer;
protected ILogger LoggerYCLInternalTransfer
{
get
{
string newFileName = $"{AppContext.BaseDirectory}/logs/{DateTime.Now:yyyyMMdd}/原材料仓/custom{DateTime.Now:yyyyMMdd}原材料仓内转移.log";
if (_LoggerYCLInternalTransferFileName != newFileName)
{
ILoggerFactory loggerFactory = LoggerFactory.Create(builder => builder.AddFile(newFileName, cfgOpts =>
{
//cfgOpts.DateFormat = "yyyy-MM-dd HH:mm:ss.fff";
cfgOpts.MessageFormat = (logMsg) =>
{
var logLevel = s_logLevelMap[logMsg.LogLevel];
var sb = new StringBuilder();
_ = sb.Append($"[{logLevel}] ");
_ = sb.Append($"{logMsg.LogName} ");
_ = sb.Append($"{DateTime.Now:yyyy-MM-dd HH:mm:ss.fff} ");
_ = sb.Append($"#{logMsg.EventId.Id} ");
_ = sb.Append(logMsg.Message + " ");
_ = sb.Append(logMsg.Exception?.ToString());
return sb.ToString();
};
}));
_LoggerYCLInternalTransfer = loggerFactory.CreateLogger(this.GetType());
_LoggerYCLInternalTransferFileName = newFileName;
}
return _LoggerYCLInternalTransfer;
}
}
protected string _LoggerWmsMaterialkitFileName = "";
protected ILogger _LoggerWmsMaterialkit;
protected ILogger LoggerWmsMaterialkit
{
get
{
string newFileName = $"{AppContext.BaseDirectory}/logs/{DateTime.Now:yyyyMMdd}/齐套配送/custom{DateTime.Now:yyyyMMdd}齐套配送.log";
if (_LoggerWmsMaterialkitFileName != newFileName)
{
ILoggerFactory loggerFactory = LoggerFactory.Create(builder => builder.AddFile(newFileName, cfgOpts =>
{
//cfgOpts.DateFormat = "yyyy-MM-dd HH:mm:ss.fff";
cfgOpts.MessageFormat = (logMsg) =>
{
var logLevel = s_logLevelMap[logMsg.LogLevel];
var sb = new StringBuilder();
_ = sb.Append($"[{logLevel}] ");
_ = sb.Append($"{logMsg.LogName} ");
_ = sb.Append($"{DateTime.Now:yyyy-MM-dd HH:mm:ss.fff} ");
_ = sb.Append($"#{logMsg.EventId.Id} ");
_ = sb.Append(logMsg.Message + " ");
_ = sb.Append(logMsg.Exception?.ToString());
return sb.ToString();
};
}));
_LoggerWmsMaterialkit = loggerFactory.CreateLogger(this.GetType());
_LoggerWmsMaterialkitFileName = newFileName;
}
return _LoggerWmsMaterialkit;
}
}
#endregion
public class customInventoryEntity
{
public string material_id { get; set; }
public string material_code { get; set; }
public string material_name { get; set; }
public string material_specification { get; set; }
public decimal? codeqty { get; set; }
public string unit_code { get; set; }
}
public class carry_matEntity
{
public string carry_id { get; set; }
public string material_code { get; set; }
public string region_id { get; set; }
public string region_code { get; set; }
public string categorys { get; set; }
public string category { get; set; }
public List category_list { get; set; }
}
}
}