using Admin.Core.Common.Config;
using Admin.Core.Common;
using Admin.Core.IService;
using Admin.Core.Model;
using Admin.Core.Service;
using log4net;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.Extensions.DependencyInjection;
using Aucma.Core.Scanner;
using static Aucma.Core.Scanner.ScannerService;
using Admin.Core.Model.Model_New;
using Quartz;
using StackExchange.Profiling.Internal;
using Aucma.Core.HwPLc;
using System.Windows.Documents;
using System.Timers;
using NetTaste;
using Org.BouncyCastle.Asn1.Tsp;
using System.Printing;
namespace Aucma.Core.BoxFoam.Business
{
public class InStoreBusiness
{
#region 单例实现
private static readonly InStoreBusiness lazy = new InStoreBusiness();
public static InStoreBusiness Instance
{
get
{
return lazy;
}
}
#endregion
/// <summary>
/// 已下传的任务信息
/// </summary>
private List<RealTaskInfo> TaskInfos = new List<RealTaskInfo>();
private Dictionary<string, int> KeyValuePairs = new Dictionary<string, int>();
#region 事件
/// <summary>
/// 扫码信息刷新
/// </summary>
/// <param name="materialBarCode">条码</param>
/// <param name="materialCode">编码</param>
/// <param name="materialName">名称</param>
/// <param name="spaceName">货到名称</param>
public delegate Task RefreshDataGridDelegate();
public static event RefreshDataGridDelegate RefreshDataGridDelegateEvent;
/// <summary>
/// 扫码信息刷新
/// </summary>
/// <param name="materialBarCode">条码</param>
/// <param name="materialCode">编码</param>
/// <param name="materialName">名称</param>
/// <param name="spaceName">货到名称</param>
public delegate void RefreshScanMateriaCode(string materialBarCode, string materialCode, string materialName, string spaceName, string msg);
public static event RefreshScanMateriaCode RefreshScanMateriaCodeEvent;
/// <summary>
/// 初始化入库任务
/// </summary>
/// <param name="message"></param>
public delegate void RefreshInStoreTask(RealTaskInfo taskInfos);
public static event RefreshInStoreTask RefreshInStoreTaskEvent;
/// <summary>
/// 日志信息刷新
/// </summary>
/// <param name="message"></param>
public delegate void RefreshLogMessage(string message);
public static event RefreshLogMessage RefreshLogMessageEvent;
/// <summary>
/// 入库日志事件
/// </summary>
/// <param name="msg"></param>
public delegate void LogDelegate(string msg);
public static event LogDelegate LogDelegateEvent;
#endregion
private static readonly log4net.ILog logHelper = LogManager.GetLogger(typeof(InStoreBusiness));
private readonly IBaseSpaceInfoServices? _baseSpaceInfoServices = App.ServiceProvider.GetService<IBaseSpaceInfoServices>();
private readonly IRealTaskInfoServices? _realTaskInfoService = App.ServiceProvider.GetService<IRealTaskInfoServices>();
private readonly IProductPlanInfoServices? _productPlanInfoServices = App.ServiceProvider.GetService<IProductPlanInfoServices>();
private readonly IRecordInStoreServices? _recordInstoreServices = App.ServiceProvider.GetService<IRecordInStoreServices>();
private readonly IBaseStoreInfoServices? _baseStoreInfoServices = App.ServiceProvider.GetService<IBaseStoreInfoServices>();
private readonly IBaseSpaceDetailServices? _baseSpaceDetailServices = App.ServiceProvider.GetService<IBaseSpaceDetailServices>();
// 过点数据表，物料完成记录MaterialCompletion
private readonly IMaterialCompletionServices? _iMaterialCompletionServices = App.ServiceProvider.GetService<IMaterialCompletionServices>();
private readonly IPrintBarCodeServices? _printBarCodeServices = App.ServiceProvider.GetService<IPrintBarCodeServices>();
private PlcSpaceConfig spaceConfig = PlcSpaceConfig.Instance;
private readonly IBaseMaterialInfoServices? _baseMaterialInfoServices = App.ServiceProvider.GetService<IBaseMaterialInfoServices>();
private SemaphoreSlim semaphore = new SemaphoreSlim(0);
private string storeCode = Appsettings.app("StoreInfo", "BeforeStoreCode");//泡前库code
private List<BaseSpaceInfo> allSpaces = null;
private List<SpaceAddress> spaceAddresses = new List<SpaceAddress>();
private SemaphoreSlim _lock = new SemaphoreSlim(1);
public void init()
{
allSpaces = _baseSpaceInfoServices.Query(x => x.StoreCode == storeCode);
foreach (var space in allSpaces)
{
spaceAddresses.Add(spaceConfig.GetSpaceAddress(storeCode, space.SpaceCode));
}
// 模拟入库
//Task.Run(() =>
//{
// Thread.Sleep(2000);
// InStore("B24010181060282920011");
//});
//实时监测入库任务下发和入库任务完成
StartPassDownAndRealInstoreFinish();
}
/// <summary>
/// 定时器实时监测入库出库完成信号
/// </summary>
/// <returns></returns>
public void RealInstoreFinish()
{
var obj = PlcHelper.siemensList.FirstOrDefault(d => d.EquipName.Equals("泡前库Plc"));
if (obj != null && obj.plc.IsConnected)
{
foreach (SpaceAddress spaceAddress in spaceAddresses)
{
// 入库完成信号
if (obj.plc.ReadInt16(spaceAddress.inStoreFinish) == 1)
{
obj.plc.WriteInt16(spaceAddress.inStoreFinish, "0");
InStoreFinish(spaceAddress.spaceCode);
}
// 出库完成信号，
if (obj.plc.ReadInt16(spaceAddress.outStoreFinish) == 1)
{
obj.plc.WriteInt16(spaceAddress.outStoreFinish, "0");
// 系统不控制出库，暂时未使用出库完成信号
}
}
}
}
/// <summary>
///实时监测入库任务下发和入库任务完成
/// </summary>
public async void StartPassDownAndRealInstoreFinish()
{
Task.Run(() =>
{
Thread.Sleep(3000);
while (true)
{
PassDown();
Thread.Sleep(1000);
}
});
Task.Run(() =>
{
Thread.Sleep(3000);
while (true)
{
RealInstoreFinish();
Thread.Sleep(1000);
}
});
}
/// <summary>
/// 获取入库任务下发plc
/// </summary>
/// <param name="context"></param>
/// <returns></returns>
public void PassDown()
{
try
{
RealTaskInfo taskInfo = GetAwaitSendTask(storeCode);
if (taskInfo != null)
{
logHelper.Info($"下发泡前入库任务：{taskInfo.TaskCode}；仓库{taskInfo.StoreCode}；货道：{taskInfo.SpaceCode}");
LogDelegateEvent?.Invoke($"下发泡前入库任务：{taskInfo.TaskCode}；仓库{taskInfo.StoreCode}；货道：{taskInfo.SpaceCode},等待plc反馈");
if (SendFoamTask_InStore(taskInfo))
{
logHelper.Info($"泡前入库任务：{taskInfo.TaskCode}；下发成功，等待PLC执行反馈");
semaphore.Wait(); //一直堵塞直到信号量释放
logHelper.Info($"箱壳入库任务：{taskInfo.TaskCode}；开始执行");
LogDelegateEvent?.Invoke($"箱壳入库任务：{taskInfo.TaskCode}；开始执行");
taskInfo.TaskStatus = 2;
_realTaskInfoService.UpdateAsync(taskInfo);
#region 更新在途数
BaseSpaceInfo spaceInfo = _baseSpaceInfoServices.Query(x => x.StoreCode == taskInfo.StoreCode && x.SpaceCode == taskInfo.SpaceCode).FirstOrDefault();
spaceInfo.OnRouteAmount += 1;
_baseSpaceInfoServices.UpdateSpaceInfo(spaceInfo);
#endregion
RefreshDataGridDelegateEvent?.Invoke();//刷新datagrid 列表
// logHelper.Info($"泡后入库任务：{taskInfo.TaskCode}；执行完成");
// 刷新入库任务列表
}
else
{
logHelper.Info($"泡后入库任务：{taskInfo.TaskCode}；下发失败，请排除PLC连接");
}
}
else
{
logHelper.Info("未获取到需要下发的泡后入库任务");
}
}
catch (Exception ex)
{
logHelper.Info("下发任务异常");
}
}
/// <summary>
/// 获取待执行的入库任务
/// </summary>
/// <param name="storeCode"></param>
/// <returns></returns>
private RealTaskInfo GetAwaitSendTask(string storeCode)
{
RealTaskInfo taskInfo = null;
try
{
taskInfo = _realTaskInfoService.Query(x => x.StoreCode == storeCode && x.TaskType == 1 && x.TaskStatus == 1).OrderBy(x => x.CreateTime).FirstOrDefault();
}
catch (Exception ex)
{
logHelper.Info("获取待执行的入库任务异常", ex);
}
return taskInfo;
}
#region 入库
/// <summary>
/// 入库,扫码器委托触发
/// </summary>
/// <param name="storeCode">仓库编号</param>
/// <param name="materialCode">物料条码</param>
public async Task InStore(string materialBarCode)
{
try
{
logHelper.Info($"扫码成功，物料条码：{materialBarCode}");
LogDelegateEvent?.Invoke($"扫码成功，物料条码：{materialBarCode}");
var taskList = await _realTaskInfoService.QueryAsync(d => d.MaterialCode.Equals(materialBarCode) && d.StoreCode == storeCode);
if (taskList.Count() > 0)
{
LogDelegateEvent?.Invoke($"物料条码[{materialBarCode}],任务创建失败,该物料入库任务已存在！");
return;
}
string materialType = SubString(materialBarCode);//截取中间物料条码
BaseSpaceInfo spaceInfo = await GetSpaceInfoByMaterialType(storeCode, materialType);
if (spaceInfo != null)
{
logHelper.Info($"匹配货道：{spaceInfo.ToJson()}");
LogDelegateEvent?.Invoke($"匹配货道：{spaceInfo.ToJson()}");
string message = $"箱体码[{materialBarCode}], 入{spaceInfo.SpaceName},入库中....";
PrintBarCode print = await _printBarCodeServices.FirstAsync(x => x.MaterialBarcode == materialBarCode);
RefreshScanMateriaCodeEvent?.Invoke(materialBarCode, materialType, print.MaterialName, spaceInfo.SpaceName, message); //刷新界面扫码信息
var result = await CreateInStoreTask(spaceInfo, materialBarCode); //创建入库任务
if (result)
{
#region 更新过点数据
//MaterialCompletion completion = new MaterialCompletion();
//completion.OrderCode = print.OrderCode;
//completion.MaterialBarcode = materialBarCode;
//completion.MaterialCode = print.MaterialCode;
//completion.MaterialName = print.MaterialName;
//completion.StationName = "1003";
//completion.CompleteDate = DateTime.Now;
//await _iMaterialCompletionServices.AddAsync(completion);
#endregion
RefreshDataGridDelegateEvent?.Invoke();
await _baseSpaceInfoServices.UpdateSpaceInfo(spaceInfo);
}
}
else
{
//报警停线
}
}
catch (Exception ex)
{
logHelper.Error($"入库业务异常:{ex}");
}
}
#region 创建入库任务
/// <summary>
/// 创建入库任务
/// </summary>
/// <param name="spaceInfo"></param>
private async Task<bool> CreateInStoreTask(BaseSpaceInfo spaceInfo, string materialCode)
{
bool result = false;
try
{
//生成入库任务依次下发至PLC
RealTaskInfo realTaskInfo = new RealTaskInfo();
realTaskInfo.TaskType = 1;
realTaskInfo.TaskCode = System.Guid.NewGuid().ToString("N").Substring(0, 6);
realTaskInfo.SpaceName = spaceInfo.SpaceName;
realTaskInfo.StoreCode = spaceInfo.StoreCode;
realTaskInfo.SpaceCode = spaceInfo.SpaceCode;
realTaskInfo.MaterialType = spaceInfo.MaterialType;
realTaskInfo.MaterialCode = materialCode;
realTaskInfo.PlanAmount = 1;
realTaskInfo.TaskStatus = 1; //任务状态：1 - 待执行；2 - 执行中；3 - 完成
realTaskInfo.CreateTime = DateTime.Now;
int flag = await _realTaskInfoService.AddAsync(realTaskInfo);
if (flag > 0)
{
logHelper.Info("入库任务创建成功");
LogDelegateEvent?.Invoke($"[{materialCode}]入库任务创建成功");
RefreshInStoreTaskEvent?.Invoke(realTaskInfo);//刷新datagrid 列表
result = true;
}
else
{
logHelper.Info("入库任务创建失败");
LogDelegateEvent?.Invoke($"[{materialCode}]入库任务创建失败");
result = false;
}
}
catch (Exception ex)
{
logHelper.Info($"入库任务创建异常：{ex.Message}");
result = false;
}
return result;
}
#endregion
/// 筛选货道
/// </summary>
/// <param name="storeCode"></param>
/// <param name="materialType"></param>
/// <returns></returns>
private async Task<BaseSpaceInfo> GetSpaceInfoByMaterialType(string storeCode, string materialType)
{
BaseSpaceInfo result = null;
try
{
// List<BaseSpaceInfo> info = _spaceInfoService.GetBaseSpaceInfosByMaterialType(storeCode, materialType);
List<BaseSpaceInfo> info = await _baseSpaceInfoServices.InStoreGetSpaceInfoByMaterialType(storeCode, materialType);
if (info != null)
{
if (info.Count > 0)
{
foreach (BaseSpaceInfo item in info)
{
var spaceInfo = ReadSpaceInfoByPlc(item);
item.SpaceStock = spaceInfo.SpaceStock;
// item.OnRouteAmount = spaceInfo.OnRouteAmount;
// item.SpaceStatus = spaceInfo.SpaceStatus;
}
info = info.Where(x => x.SpaceStatus == 1 && x.SpaceCapacity > (x.SpaceStock + x.OnRouteAmount)).ToList();
if(info.Count > 0)
{
result = info.OrderByDescending(x => x.SpaceStock).OrderBy(x => x.SpaceCode).First();
}
}
}
}
catch (Exception ex)
{
logHelper.Info("货道信息读取异常", ex);
}
return result;
}
/// <summary>
/// 通过PLC获取货道信息
/// </summary>
/// <param name="spaceInfo"></param>
/// <returns></returns>
public BaseSpaceInfo ReadSpaceInfoByPlc(BaseSpaceInfo spaceInfo)
{
var obj = PlcHelper.siemensList.FirstOrDefault(d => d.EquipName.Equals("泡前库Plc"));
if (obj != null && obj.plc.IsConnected)
{
SpaceAddress spaceAddress = spaceConfig.GetSpaceAddress(spaceInfo.StoreCode, spaceInfo.SpaceCode);
spaceInfo.SpaceStock = obj.plc.ReadInt16(spaceAddress.onStore);
// spaceInfo.OnRouteAmount = obj.plc.ReadInt32(spaceAddress.onRoute);
// spaceInfo.SpaceStatus = obj.plc.ReadInt32(spaceAddress.spaceStatus);
}
return spaceInfo;
}
#endregion
#region 截取物料编码
public string SubString(string barCode)
{
string result = string.Empty;
if (!string.IsNullOrEmpty(barCode))
{
result = barCode.Substring(7, 10);
}
return result;
}
#endregion
#region 泡前入库任务下发处理
public bool SendFoamTask_InStore(RealTaskInfo taskInfo)
{
bool result = false;
try
{
SpaceAddress spaceAddress = spaceConfig.GetSpaceAddress(storeCode, taskInfo.SpaceCode);
var obj = PlcHelper.siemensList.FirstOrDefault(d => d.EquipName.Equals("泡前库Plc"));
if (obj != null && obj.plc.IsConnected)
{
//写入应答字
obj.plc.WriteInt16("DB200.2", "1");
//写入货道物料类型
obj.plc.WriteString(spaceAddress.materialType, taskInfo.MaterialType);
//写入货道号
obj.plc.WriteInt16("DB200.0", taskInfo.SpaceCode.Substring(7,1));
//写入完成后读取反馈号进行复位
ReadShellAnswer_InStore(taskInfo);
result = true;
}
else
{
logHelper.Info($"仓库{taskInfo.StoreCode}；PLC未连接");
}
}
catch (Exception ex)
{
logHelper.Error("泡后入库任务下发异常", ex);
}
return result;
}
/// <summary>
/// 读取泡前入库应答
/// </summary>
private void ReadShellAnswer_InStore(RealTaskInfo taskInfo)
{
lock (string.Empty)
{
bool isFlag = true;
var obj = PlcHelper.siemensList.FirstOrDefault(d => d.EquipName.Equals("泡前库Plc"));
try
{
Task.Run(() =>
{
if (obj != null && obj.plc.IsConnected)
{
do
{
//读取PLC反馈号，上位机清空写入的入库内容
if (obj.plc.ReadInt16("DB200.86") == 2)
{
obj.plc.WriteInt16("DB200.86", "0");
//-------------plc清
//写入货道号
obj.plc.WriteInt16("DB200.0", "0");
// 写入应答字
obj.plc.WriteInt16("DB200.2", "0");
//写入货道物料类型
// obj.plc.WriteInt16(spaceAddress.materialType, taskInfo.MaterialType);
//----------------------
isFlag = false;
InStoreAnswer(taskInfo.TaskCode);
// TaskInfos.Add(taskInfo);
// ReadShellFinish_InStore(taskCode);
}
Thread.Sleep(500);
} while (isFlag);
}
else
{
logHelper.Info("PLC未连接");
}
});
}
catch (Exception ex)
{
logHelper.Error("读取泡后入库应答字异常", ex);
}
}
}
/// <summary>
/// 泡前库执行反馈
/// </summary>
private void InStoreAnswer(string taskCode)
{
LogDelegateEvent?.Invoke($"泡前库应答成功，自动释放信号量，进行下发新任务");
logHelper.Info("泡前库应答成功，自动释放信号量，进行下发新任务");
// InStoreFinish(taskCode);
semaphore.Release();
}
#endregion
/// <summary>
/// 入库完成
/// </summary>
/// <param name="storeCode"></param>
/// <param name="spaceCode"></param>
/// <param name="materialType"></param>
private async void InStoreFinish(string spaceCode)
{
try
{
List<RealTaskInfo> tasks = await _realTaskInfoService.QueryAsync(x => x.StoreCode == storeCode && x.SpaceCode == spaceCode && x.TaskStatus == 2);
RealTaskInfo taskInfo = tasks.OrderBy(x => x.CreateTime).FirstOrDefault();
if (taskInfo != null)
{
BaseSpaceInfo spaceInfo = await _baseSpaceInfoServices.GetSpaceInfoBySpaceCode(taskInfo.StoreCode, taskInfo.SpaceCode);
if (spaceInfo != null)
{
spaceInfo.MaterialType = taskInfo.MaterialType;
//读取PLC获取货道信息：存放数量、在途数量,
#region Add By wenjy 2023-10-30 13:44:00 通过PLC获取货道信息
var item = ReadSpaceInfoByPlc(spaceInfo);
spaceInfo.SpaceStock = item.SpaceStock;
// 入库完成，在途减1
spaceInfo.OnRouteAmount -= 1;
#endregion
await _baseSpaceInfoServices.UpdateSpaceInfo(spaceInfo);
#region 添加货道明细 不控制出库，暂时未添加明细
BaseSpaceDetail spaceDetail = new BaseSpaceDetail();
spaceDetail.MaterialType = taskInfo.MaterialType;
spaceDetail.MaterialCode = taskInfo.MaterialCode;
spaceDetail.MaterialName = await GetMaterialName(taskInfo.MaterialType);
spaceDetail.StoreCode = spaceInfo.StoreCode;
spaceDetail.SpaceCode = spaceInfo.SpaceCode;
spaceDetail.MaterialAmount = 1;
//await _baseSpaceDetailServices.InsertSpaceDetail(spaceDetail);
#endregion
#region 添加入库记录
RecordInStore recordInstore = new RecordInStore();
recordInstore.StoreCode = taskInfo.StoreCode;
recordInstore.SpaceCode = taskInfo.SpaceCode;
recordInstore.MaterialCode = taskInfo.MaterialCode;
recordInstore.MaterialType = taskInfo.MaterialType;
recordInstore.MaterialName = await GetMaterialName(taskInfo.MaterialType);
recordInstore.InStoreAmount = 1;
recordInstore.InStoreTime = DateTime.Now;
recordInstore.BarCodeCode = taskInfo.MaterialCode;
#endregion
bool result = await _recordInstoreServices.SaveRecordToDb(recordInstore, taskInfo, spaceInfo, spaceDetail);
if (result)
{
LogDelegateEvent?.Invoke($"入库完成，更新数据库成功");
}
else
{
LogDelegateEvent?.Invoke($"更新数据库异常");
}
}
////清除任务信息
//await _realTaskInfoService.DeleteTaskInfo(taskCode, storeCode);
}
}
catch (Exception ex)
{
logHelper.Info("入库完成逻辑处理异常", ex);
}
}
/// <summary>
///获取物料名称
/// </summary>
/// <param name="materialType"></param>
/// <returns></returns>
public async Task<string> GetMaterialName(string materialType)
{
string materialName = string.Empty;
BaseMaterialInfo info = await _baseMaterialInfoServices.FirstAsync(x => x.MaterialType == materialType);
if (info != null)
{
materialName = info.MaterialName;
}
return materialName;
}
#region PLC 任务处理表
/// <summary>
/// PLC 任务处理表
/// </summary>
/// <param name="storeCode">仓库编码</param>
/// <param name="materialBarCode">物料编码</param>
/// <returns></returns>
public async Task MaterialEnterStore(string storeCode, string materialBarCode = "B20231082080029650001")
{
//扫描入库信号,入库完成
try
{
var taskList = await _realTaskInfoService.QueryAsync(d => d.MaterialType.Equals(materialBarCode) && d.StoreCode == storeCode);
if (taskList.Count() == 0) return;
var obj = taskList.FirstOrDefault();
var mCode = materialBarCode.Substring(7, 10);//物料条码
//删除任务表、更新货道、添加入库明细、添加入库记录
var planInfoList = await _productPlanInfoServices.QueryAsync(d => d.MaterialCode.Equals(mCode));//计划
if (planInfoList.Count() == 0)
{
logHelper.Error($"物料计划信息为空！");
return;
}
var baseStoreInfolist = await _baseStoreInfoServices.QueryAsync(d => d.StoreCode.Equals(obj.StoreCode));//仓库
if (baseStoreInfolist.Count() == 0)
{
logHelper.Error($"仓库信息为空！");
return;
}
var baseSpacelist = await _baseSpaceInfoServices.QueryAsync(d => d.SpaceCode.Equals(obj.SpaceCode));
if (taskList.Count() == 0)
{
LogDelegateEvent?.Invoke($"物料[{materialBarCode}],入库记录条码重复异常！");
logHelper.Error($"货道信息为空！");
return;
}
var baseSpaceDetailList = await _baseSpaceDetailServices.QueryAsync(d => d.MaterialCode.Equals(obj.MaterialCode));//货到详情
if (baseSpaceDetailList.Count() != 0)
{
logHelper.Error($"货到信息存在重复物料！");
return;
}
var baseSpace = baseSpacelist.FirstOrDefault();
var planInfo = planInfoList.FirstOrDefault();
var baseStoreInfo = baseStoreInfolist.FirstOrDefault();
baseSpace.SpaceStock = baseSpace.SpaceStock + 1;
baseSpace.OnRouteAmount = 0;
//入库记录表
RecordInStore recordInstore = new RecordInStore();
recordInstore.StoreCode = storeCode;
recordInstore.StoreArea = baseStoreInfo.StoreArea;
recordInstore.SpaceCode = baseSpace.SpaceCode;
recordInstore.MaterialType = baseSpace.MaterialType;
recordInstore.MaterialCode = mCode;
recordInstore.InStoreTime = DateTime.Now;
recordInstore.BarCodeCode = materialBarCode;
recordInstore.MaterialName = planInfo.MaterialName;
recordInstore.EntryPattern = 0;
recordInstore.IsFlag = 0;
recordInstore.CreatedTime = DateTime.Now;
//入库详情表
BaseSpaceDetail baseDetail = new BaseSpaceDetail();
baseDetail.StoreCode = storeCode;
baseDetail.SpaceCode = baseSpace.SpaceCode;
baseDetail.MaterialCode = materialBarCode;
baseDetail.MaterialName = planInfo.MaterialName;
baseDetail.MaterialAmount = 1;
baseDetail.CreatedTime = DateTime.Now;
bool result = await _recordInstoreServices.SaveRecordToDb(recordInstore, obj, baseSpace, baseDetail);
if (result)
{
string message = $"物料[{planInfo.MaterialName}], 入{baseSpace.SpaceName},入库成功！";
RefreshScanMateriaCodeEvent?.Invoke(obj.MaterialCode, materialBarCode, planInfo.MaterialName, baseSpace.SpaceName, message); //刷新界面扫码信息
LogDelegateEvent?.Invoke($"物料[{planInfo.MaterialName}], 入库[{baseSpace.SpaceName}]成功！");
RefreshDataGridDelegateEvent?.Invoke();
}
else
{
LogDelegateEvent?.Invoke($"物料[{planInfo.MaterialName}], 入库[{baseSpace.SpaceName}]失败，任务回滚！");
logHelper.Error($"物料[{planInfo.MaterialName}], 入库[{baseSpace.SpaceName}]失败，任务回滚！");
}
}
catch (Exception ex)
{
logHelper.Error($"入库数据处理异常:{ex.Message}");
}
}
#endregion
}
}