admin/JiShe.CollectBus
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 1 Wiki Activity

打开注释的订阅信息，优化电表信息未缓存不保存数据，仅保存日志

Browse Source
This commit is contained in:
zenghongyao 2025-05-19 08:51:10 +08:00
parent 070173af4f
commit ba92a3d604
3 changed files with 488 additions and 482 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
protocols/JiShe.CollectBus.Protocol.T37612012/AnalysisData/DataStorage.cs
View File

@ -311,7 +311,7 @@ namespace JiShe.CollectBus.Protocol.T37612012.AnalysisData
}
meterReadingTelemetryPacketInfos.Add(taskData);
//如果无字段名，则不保存数据,如saveData=false 也不保存数据
if (!string.IsNullOrWhiteSpace(item.FiledName))
if (!string.IsNullOrWhiteSpace(item.FiledName) && item.ProjectId>0)
{
treeModelSingleMeasuringEntities.Add(meter);
}
@ -342,6 +342,8 @@ namespace JiShe.CollectBus.Protocol.T37612012.AnalysisData
if (!data.TimeSpan.HasValue)
data.TimeSpan = analysisBaseDto.ReceivedTime;
// 类型(心跳，登录，上电，掉电)
if (data.ProjectId > 0)
{
long timestamps = DateTime.Now.GetDateTimeOffset().ToUnixTimeNanoseconds();
var treeData = new TreeModelSingleMeasuringEntity<T>()
{
@ -365,7 +367,6 @@ namespace JiShe.CollectBus.Protocol.T37612012.AnalysisData
Timestamps = timestamps,
SingleMeasuring = (ConcentratorStatusFieldConst.FrameData, analysisBaseDto.ReceivedHexMessage ?? string.Empty)
};
await _dbProvider.GetSessionPool(false).InsertAsync(treeFrameData);
// 时间
@ -379,7 +380,8 @@ namespace JiShe.CollectBus.Protocol.T37612012.AnalysisData
DataType = IOTDBDataTypeConst.Status,
SingleMeasuring = (ConcentratorStatusFieldConst.RecordingTime, data.TimeSpan.HasValue ? data.TimeSpan.Value : DateTime.Now)
};
await _dbProvider.GetSessionPool(true).InsertAsync(treeRecordingTimeData);
await _dbProvider.GetSessionPool(false).InsertAsync(treeRecordingTimeData);
}
// 新建
string taskMark = CommonHelper.GetTaskMark(analysisBaseDto.AFN, analysisBaseDto.Fn, analysisBaseDto.Pn, analysisBaseDto.MSA, analysisBaseDto.PSEQ);
@ -439,6 +441,8 @@ namespace JiShe.CollectBus.Protocol.T37612012.AnalysisData
if (!item.TimeSpan.HasValue)
item.TimeSpan = analysisBaseDto.ReceivedTime;
// 类型(心跳，登录，上电，掉电)
if (item.ProjectId > 0)
{
long timestamps = DateTime.Now.GetDateTimeOffset().ToUnixTimeNanoseconds();
var treeData = new TreeModelSingleMeasuringEntity<T>()
{
@ -476,6 +480,8 @@ namespace JiShe.CollectBus.Protocol.T37612012.AnalysisData
};
await _dbProvider.GetSessionPool(false).InsertAsync(treeRecordingTimeData);
}
// 新建
string taskMark = CommonHelper.GetTaskMark(analysisBaseDto.AFN, analysisBaseDto.Fn, analysisBaseDto.Pn, analysisBaseDto.MSA, analysisBaseDto.PSEQ);
var currentTime = DateTime.Now;

820
services/JiShe.CollectBus.Application/Subscribers/SubscriberAnalysisAppService.cs
View File

@ -42,458 +42,458 @@ namespace JiShe.CollectBus.Subscribers
_protocolService = protocolService;
}
///// <summary>
///// 解析AFN00H
///// </summary>
///// <param name="receivedMessage"></param>
///// <returns></returns>
//[KafkaSubscribe(ProtocolConst.SubscriberAFN00HReceivedEventNameTemp)]
//public async Task<ISubscribeAck> ReceivedAFN00Event(MessageProtocolAnalysis<TB3761> receivedMessage)
//{
// var protocolPlugin = await _protocolService.GetProtocolServiceAsync(receivedMessage.DeviceNo);
// if (protocolPlugin == null)
// {
// _logger.LogError("协议不存在！");
// }
// else
// {
// if (receivedMessage.Data==null)
// {
// Logger.LogError($"数据解析失败：{receivedMessage.Serialize()}");
// return SubscribeAck.Success();
// }
// if (receivedMessage.Data.DT == null || receivedMessage.Data.AFN_FC == null)
// {
// Logger.LogError($"数据解析失败：{receivedMessage.Serialize()}");
// return SubscribeAck.Success();
// }
// string serverName = $"AFN{receivedMessage.Data.AFN_FC.AFN}_F{receivedMessage.Data.DT.Fn}_Analysis";
// //var analysisStrategy = _serviceProvider.GetKeyedService<IAnalysisStrategy>($"AFN0_F1_Analysis");
/// <summary>
/// 解析AFN00H
/// </summary>
/// <param name="receivedMessage"></param>
/// <returns></returns>
[KafkaSubscribe(ProtocolConst.SubscriberAFN00HReceivedEventNameTemp)]
public async Task<ISubscribeAck> ReceivedAFN00Event(MessageProtocolAnalysis<TB3761> receivedMessage)
{
var protocolPlugin = await _protocolService.GetProtocolServiceAsync(receivedMessage.DeviceNo);
if (protocolPlugin == null)
{
_logger.LogError("协议不存在！");
}
else
{
if (receivedMessage.Data == null)
{
Logger.LogError($"数据解析失败：{receivedMessage.Serialize()}");
return SubscribeAck.Success();
}
if (receivedMessage.Data.DT == null || receivedMessage.Data.AFN_FC == null)
{
Logger.LogError($"数据解析失败：{receivedMessage.Serialize()}");
return SubscribeAck.Success();
}
string serverName = $"AFN{receivedMessage.Data.AFN_FC.AFN}_F{receivedMessage.Data.DT.Fn}_Analysis";
//var analysisStrategy = _serviceProvider.GetKeyedService<IAnalysisStrategy>($"AFN0_F1_Analysis");
// //var data = await analysisStrategy.ExecuteAsync<UnitDataDto<bool>>(tB3761);
// var executor = _serviceProvider.GetRequiredService<AnalysisStrategyContext>();
// await executor.ExecuteAsync<TB3761>(serverName, receivedMessage.Data);
// }
//var data = await analysisStrategy.ExecuteAsync<UnitDataDto<bool>>(tB3761);
var executor = _serviceProvider.GetRequiredService<AnalysisStrategyContext>();
await executor.ExecuteAsync<TB3761>(serverName, receivedMessage.Data);
}
// return SubscribeAck.Fail();
//}
return SubscribeAck.Fail();
}
///// <summary>
///// 解析AFN01H
///// </summary>
///// <param name="receivedMessage"></param>
///// <returns></returns>
//[KafkaSubscribe(ProtocolConst.SubscriberAFN01HReceivedEventNameTemp)]
//public async Task<ISubscribeAck> ReceivedAFN01Event(MessageProtocolAnalysis<TB3761> receivedMessage)
//{
// var protocolPlugin = await _protocolService.GetProtocolServiceAsync(receivedMessage.DeviceNo);
// if (protocolPlugin == null)
// {
// _logger.LogError("协议不存在！");
// }
// else
// {
// if (receivedMessage.Data == null)
// {
// Logger.LogError($"数据解析失败：{receivedMessage.Serialize()}");
// return SubscribeAck.Success();
// }
// if (receivedMessage.Data.DT == null || receivedMessage.Data.AFN_FC == null)
// {
// Logger.LogError($"数据解析失败：{receivedMessage.Serialize()}");
// return SubscribeAck.Success();
// }
// string serverName = $"AFN{receivedMessage.Data.AFN_FC.AFN}_F{receivedMessage.Data.DT.Fn}_Analysis";
// //var analysisStrategy = _serviceProvider.GetKeyedService<IAnalysisStrategy>($"AFN0_F1_Analysis");
/// <summary>
/// 解析AFN01H
/// </summary>
/// <param name="receivedMessage"></param>
/// <returns></returns>
[KafkaSubscribe(ProtocolConst.SubscriberAFN01HReceivedEventNameTemp)]
public async Task<ISubscribeAck> ReceivedAFN01Event(MessageProtocolAnalysis<TB3761> receivedMessage)
{
var protocolPlugin = await _protocolService.GetProtocolServiceAsync(receivedMessage.DeviceNo);
if (protocolPlugin == null)
{
_logger.LogError("协议不存在！");
}
else
{
if (receivedMessage.Data == null)
{
Logger.LogError($"数据解析失败：{receivedMessage.Serialize()}");
return SubscribeAck.Success();
}
if (receivedMessage.Data.DT == null || receivedMessage.Data.AFN_FC == null)
{
Logger.LogError($"数据解析失败：{receivedMessage.Serialize()}");
return SubscribeAck.Success();
}
string serverName = $"AFN{receivedMessage.Data.AFN_FC.AFN}_F{receivedMessage.Data.DT.Fn}_Analysis";
//var analysisStrategy = _serviceProvider.GetKeyedService<IAnalysisStrategy>($"AFN0_F1_Analysis");
// //var data = await analysisStrategy.ExecuteAsync<UnitDataDto<bool>>(tB3761);
// var executor = _serviceProvider.GetRequiredService<AnalysisStrategyContext>();
// await executor.ExecuteAsync<TB3761>(serverName, receivedMessage.Data);
// }
//var data = await analysisStrategy.ExecuteAsync<UnitDataDto<bool>>(tB3761);
var executor = _serviceProvider.GetRequiredService<AnalysisStrategyContext>();
await executor.ExecuteAsync<TB3761>(serverName, receivedMessage.Data);
}
// return SubscribeAck.Fail();
//}
return SubscribeAck.Fail();
}
///// <summary>
///// 解析AFN02H
///// </summary>
///// <param name="receivedMessage"></param>
///// <returns></returns>
//[KafkaSubscribe(ProtocolConst.SubscriberAFN02HReceivedEventNameTemp)]
//public async Task<ISubscribeAck> ReceivedAFN02Event(MessageProtocolAnalysis<TB3761> receivedMessage)
//{
// var protocolPlugin = await _protocolService.GetProtocolServiceAsync(receivedMessage.DeviceNo);
// if (protocolPlugin == null)
// {
// _logger.LogError("协议不存在！");
// }
// else
// {
// if (receivedMessage.Data == null)
// {
// Logger.LogError($"数据解析失败：{receivedMessage.Serialize()}");
// return SubscribeAck.Success();
// }
// if (receivedMessage.Data.DT == null || receivedMessage.Data.AFN_FC == null)
// {
// Logger.LogError($"数据解析失败：{receivedMessage.Serialize()}");
// return SubscribeAck.Success();
// }
// string serverName = $"AFN{receivedMessage.Data.AFN_FC.AFN}_F{receivedMessage.Data.DT.Fn}_Analysis";
// //var analysisStrategy = _serviceProvider.GetKeyedService<IAnalysisStrategy>($"AFN0_F1_Analysis");
/// <summary>
/// 解析AFN02H
/// </summary>
/// <param name="receivedMessage"></param>
/// <returns></returns>
[KafkaSubscribe(ProtocolConst.SubscriberAFN02HReceivedEventNameTemp)]
public async Task<ISubscribeAck> ReceivedAFN02Event(MessageProtocolAnalysis<TB3761> receivedMessage)
{
var protocolPlugin = await _protocolService.GetProtocolServiceAsync(receivedMessage.DeviceNo);
if (protocolPlugin == null)
{
_logger.LogError("协议不存在！");
}
else
{
if (receivedMessage.Data == null)
{
Logger.LogError($"数据解析失败：{receivedMessage.Serialize()}");
return SubscribeAck.Success();
}
if (receivedMessage.Data.DT == null || receivedMessage.Data.AFN_FC == null)
{
Logger.LogError($"数据解析失败：{receivedMessage.Serialize()}");
return SubscribeAck.Success();
}
string serverName = $"AFN{receivedMessage.Data.AFN_FC.AFN}_F{receivedMessage.Data.DT.Fn}_Analysis";
//var analysisStrategy = _serviceProvider.GetKeyedService<IAnalysisStrategy>($"AFN0_F1_Analysis");
// //var data = await analysisStrategy.ExecuteAsync<UnitDataDto<bool>>(tB3761);
// var executor = _serviceProvider.GetRequiredService<AnalysisStrategyContext>();
// await executor.ExecuteAsync<TB3761>(serverName, receivedMessage.Data, (result) =>
// {
// var ssss = (UnitDataAnalysis<AnalysisBaseDto<string>>)result;
// _logger.LogInformation($"解析AFN02H数据：{ssss.Serialize()}");
// });
// return SubscribeAck.Success();
// }
// return SubscribeAck.Fail();
//var data = await analysisStrategy.ExecuteAsync<UnitDataDto<bool>>(tB3761);
var executor = _serviceProvider.GetRequiredService<AnalysisStrategyContext>();
await executor.ExecuteAsync<TB3761>(serverName, receivedMessage.Data, (result) =>
{
var ssss = (UnitDataAnalysis<AnalysisBaseDto<string>>)result;
_logger.LogInformation($"解析AFN02H数据：{ssss.Serialize()}");
});
return SubscribeAck.Success();
}
return SubscribeAck.Fail();
//}
}
///// <summary>
///// 解析AFN03H
///// </summary>
///// <param name="receivedMessage"></param>
///// <returns></returns>
//[KafkaSubscribe(ProtocolConst.SubscriberAFN03HReceivedEventNameTemp)]
//public async Task<ISubscribeAck> ReceivedAFN03Event(MessageProtocolAnalysis<TB3761> receivedMessage)
//{
// var protocolPlugin = await _protocolService.GetProtocolServiceAsync(receivedMessage.DeviceNo);
// if (protocolPlugin == null)
// {
// _logger.LogError("协议不存在！");
// }
// else
// {
// if (receivedMessage.Data == null)
// {
// Logger.LogError($"数据解析失败：{receivedMessage.Serialize()}");
// return SubscribeAck.Success();
// }
// if (receivedMessage.Data.DT == null || receivedMessage.Data.AFN_FC == null)
// {
// Logger.LogError($"数据解析失败：{receivedMessage.Serialize()}");
// return SubscribeAck.Success();
// }
// string serverName = $"AFN{receivedMessage.Data.AFN_FC.AFN}_F{receivedMessage.Data.DT.Fn}_Analysis";
// //var analysisStrategy = _serviceProvider.GetKeyedService<IAnalysisStrategy>($"AFN0_F1_Analysis");
/// <summary>
/// 解析AFN03H
/// </summary>
/// <param name="receivedMessage"></param>
/// <returns></returns>
[KafkaSubscribe(ProtocolConst.SubscriberAFN03HReceivedEventNameTemp)]
public async Task<ISubscribeAck> ReceivedAFN03Event(MessageProtocolAnalysis<TB3761> receivedMessage)
{
var protocolPlugin = await _protocolService.GetProtocolServiceAsync(receivedMessage.DeviceNo);
if (protocolPlugin == null)
{
_logger.LogError("协议不存在！");
}
else
{
if (receivedMessage.Data == null)
{
Logger.LogError($"数据解析失败：{receivedMessage.Serialize()}");
return SubscribeAck.Success();
}
if (receivedMessage.Data.DT == null || receivedMessage.Data.AFN_FC == null)
{
Logger.LogError($"数据解析失败：{receivedMessage.Serialize()}");
return SubscribeAck.Success();
}
string serverName = $"AFN{receivedMessage.Data.AFN_FC.AFN}_F{receivedMessage.Data.DT.Fn}_Analysis";
//var analysisStrategy = _serviceProvider.GetKeyedService<IAnalysisStrategy>($"AFN0_F1_Analysis");
// //var data = await analysisStrategy.ExecuteAsync<UnitDataDto<bool>>(tB3761);
// var executor = _serviceProvider.GetRequiredService<AnalysisStrategyContext>();
// await executor.ExecuteAsync<TB3761>(serverName, receivedMessage.Data);
// return SubscribeAck.Success();
// }
//var data = await analysisStrategy.ExecuteAsync<UnitDataDto<bool>>(tB3761);
var executor = _serviceProvider.GetRequiredService<AnalysisStrategyContext>();
await executor.ExecuteAsync<TB3761>(serverName, receivedMessage.Data);
return SubscribeAck.Success();
}
// return SubscribeAck.Fail();
//}
return SubscribeAck.Fail();
}
///// <summary>
///// 解析AFN04H
///// </summary>
///// <param name="receivedMessage"></param>
///// <returns></returns>
//[KafkaSubscribe(ProtocolConst.SubscriberAFN04HReceivedEventNameTemp)]
//public async Task<ISubscribeAck> ReceivedAFN04Event(MessageProtocolAnalysis<TB3761> receivedMessage)
//{
// var protocolPlugin = await _protocolService.GetProtocolServiceAsync(receivedMessage.DeviceNo);
// if (protocolPlugin == null)
// {
// _logger.LogError("协议不存在！");
// }
// else
// {
// if (receivedMessage.Data == null)
// {
// Logger.LogError($"数据解析失败：{receivedMessage.Serialize()}");
// return SubscribeAck.Success();
// }
// if (receivedMessage.Data.DT == null || receivedMessage.Data.AFN_FC == null)
// {
// Logger.LogError($"数据解析失败：{receivedMessage.Serialize()}");
// return SubscribeAck.Success();
// }
// string serverName = $"AFN{receivedMessage.Data.AFN_FC.AFN}_F{receivedMessage.Data.DT.Fn}_Analysis";
// //var analysisStrategy = _serviceProvider.GetKeyedService<IAnalysisStrategy>($"AFN0_F1_Analysis");
/// <summary>
/// 解析AFN04H
/// </summary>
/// <param name="receivedMessage"></param>
/// <returns></returns>
[KafkaSubscribe(ProtocolConst.SubscriberAFN04HReceivedEventNameTemp)]
public async Task<ISubscribeAck> ReceivedAFN04Event(MessageProtocolAnalysis<TB3761> receivedMessage)
{
var protocolPlugin = await _protocolService.GetProtocolServiceAsync(receivedMessage.DeviceNo);
if (protocolPlugin == null)
{
_logger.LogError("协议不存在！");
}
else
{
if (receivedMessage.Data == null)
{
Logger.LogError($"数据解析失败：{receivedMessage.Serialize()}");
return SubscribeAck.Success();
}
if (receivedMessage.Data.DT == null || receivedMessage.Data.AFN_FC == null)
{
Logger.LogError($"数据解析失败：{receivedMessage.Serialize()}");
return SubscribeAck.Success();
}
string serverName = $"AFN{receivedMessage.Data.AFN_FC.AFN}_F{receivedMessage.Data.DT.Fn}_Analysis";
//var analysisStrategy = _serviceProvider.GetKeyedService<IAnalysisStrategy>($"AFN0_F1_Analysis");
// //var data = await analysisStrategy.ExecuteAsync<UnitDataDto<bool>>(tB3761);
// var executor = _serviceProvider.GetRequiredService<AnalysisStrategyContext>();
// await executor.ExecuteAsync<TB3761>(serverName, receivedMessage.Data);
// return SubscribeAck.Success();
// }
//var data = await analysisStrategy.ExecuteAsync<UnitDataDto<bool>>(tB3761);
var executor = _serviceProvider.GetRequiredService<AnalysisStrategyContext>();
await executor.ExecuteAsync<TB3761>(serverName, receivedMessage.Data);
return SubscribeAck.Success();
}
// return SubscribeAck.Fail();
//}
return SubscribeAck.Fail();
}
///// <summary>
///// 解析AFN05H
///// </summary>
///// <param name="receivedMessage"></param>
///// <returns></returns>
//[KafkaSubscribe(ProtocolConst.SubscriberAFN05HReceivedEventNameTemp)]
//public async Task<ISubscribeAck> ReceivedAFN05Event(MessageProtocolAnalysis<TB3761> receivedMessage)
//{
// var protocolPlugin = await _protocolService.GetProtocolServiceAsync(receivedMessage.DeviceNo);
// if (protocolPlugin == null)
// {
// _logger.LogError("协议不存在！");
// }
// else
// {
// if (receivedMessage.Data == null)
// {
// Logger.LogError($"数据解析失败：{receivedMessage.Serialize()}");
// return SubscribeAck.Success();
// }
// if (receivedMessage.Data.DT == null || receivedMessage.Data.AFN_FC == null)
// {
// Logger.LogError($"数据解析失败：{receivedMessage.Serialize()}");
// return SubscribeAck.Success();
// }
// string serverName = $"AFN{receivedMessage.Data.AFN_FC.AFN}_F{receivedMessage.Data.DT.Fn}_Analysis";
// //var analysisStrategy = _serviceProvider.GetKeyedService<IAnalysisStrategy>($"AFN0_F1_Analysis");
/// <summary>
/// 解析AFN05H
/// </summary>
/// <param name="receivedMessage"></param>
/// <returns></returns>
[KafkaSubscribe(ProtocolConst.SubscriberAFN05HReceivedEventNameTemp)]
public async Task<ISubscribeAck> ReceivedAFN05Event(MessageProtocolAnalysis<TB3761> receivedMessage)
{
var protocolPlugin = await _protocolService.GetProtocolServiceAsync(receivedMessage.DeviceNo);
if (protocolPlugin == null)
{
_logger.LogError("协议不存在！");
}
else
{
if (receivedMessage.Data == null)
{
Logger.LogError($"数据解析失败：{receivedMessage.Serialize()}");
return SubscribeAck.Success();
}
if (receivedMessage.Data.DT == null || receivedMessage.Data.AFN_FC == null)
{
Logger.LogError($"数据解析失败：{receivedMessage.Serialize()}");
return SubscribeAck.Success();
}
string serverName = $"AFN{receivedMessage.Data.AFN_FC.AFN}_F{receivedMessage.Data.DT.Fn}_Analysis";
//var analysisStrategy = _serviceProvider.GetKeyedService<IAnalysisStrategy>($"AFN0_F1_Analysis");
// //var data = await analysisStrategy.ExecuteAsync<UnitDataDto<bool>>(tB3761);
// var executor = _serviceProvider.GetRequiredService<AnalysisStrategyContext>();
// await executor.ExecuteAsync<TB3761>(serverName, receivedMessage.Data);
// return SubscribeAck.Success();
// }
//var data = await analysisStrategy.ExecuteAsync<UnitDataDto<bool>>(tB3761);
var executor = _serviceProvider.GetRequiredService<AnalysisStrategyContext>();
await executor.ExecuteAsync<TB3761>(serverName, receivedMessage.Data);
return SubscribeAck.Success();
}
// return SubscribeAck.Fail();
//}
return SubscribeAck.Fail();
}
///// <summary>
///// 解析AFN09H
///// </summary>
///// <param name="receivedMessage"></param>
///// <returns></returns>
//[KafkaSubscribe(ProtocolConst.SubscriberAFN09HReceivedEventNameTemp)]
//public async Task<ISubscribeAck> ReceivedAFN09Event(MessageProtocolAnalysis<TB3761> receivedMessage)
//{
// var protocolPlugin = await _protocolService.GetProtocolServiceAsync(receivedMessage.DeviceNo);
// if (protocolPlugin == null)
// {
// _logger.LogError("协议不存在！");
// }
// else
// {
// if (receivedMessage.Data == null)
// {
// Logger.LogError($"数据解析失败：{receivedMessage.Serialize()}");
// return SubscribeAck.Success();
// }
// if (receivedMessage.Data.DT == null || receivedMessage.Data.AFN_FC == null)
// {
// Logger.LogError($"数据解析失败：{receivedMessage.Serialize()}");
// return SubscribeAck.Success();
// }
// string serverName = $"AFN{receivedMessage.Data.AFN_FC.AFN}_F{receivedMessage.Data.DT.Fn}_Analysis";
// //var analysisStrategy = _serviceProvider.GetKeyedService<IAnalysisStrategy>($"AFN0_F1_Analysis");
/// <summary>
/// 解析AFN09H
/// </summary>
/// <param name="receivedMessage"></param>
/// <returns></returns>
[KafkaSubscribe(ProtocolConst.SubscriberAFN09HReceivedEventNameTemp)]
public async Task<ISubscribeAck> ReceivedAFN09Event(MessageProtocolAnalysis<TB3761> receivedMessage)
{
var protocolPlugin = await _protocolService.GetProtocolServiceAsync(receivedMessage.DeviceNo);
if (protocolPlugin == null)
{
_logger.LogError("协议不存在！");
}
else
{
if (receivedMessage.Data == null)
{
Logger.LogError($"数据解析失败：{receivedMessage.Serialize()}");
return SubscribeAck.Success();
}
if (receivedMessage.Data.DT == null || receivedMessage.Data.AFN_FC == null)
{
Logger.LogError($"数据解析失败：{receivedMessage.Serialize()}");
return SubscribeAck.Success();
}
string serverName = $"AFN{receivedMessage.Data.AFN_FC.AFN}_F{receivedMessage.Data.DT.Fn}_Analysis";
//var analysisStrategy = _serviceProvider.GetKeyedService<IAnalysisStrategy>($"AFN0_F1_Analysis");
// //var data = await analysisStrategy.ExecuteAsync<UnitDataDto<bool>>(tB3761);
// var executor = _serviceProvider.GetRequiredService<AnalysisStrategyContext>();
// await executor.ExecuteAsync<TB3761>(serverName, receivedMessage.Data);
// return SubscribeAck.Success();
// }
//var data = await analysisStrategy.ExecuteAsync<UnitDataDto<bool>>(tB3761);
var executor = _serviceProvider.GetRequiredService<AnalysisStrategyContext>();
await executor.ExecuteAsync<TB3761>(serverName, receivedMessage.Data);
return SubscribeAck.Success();
}
// return SubscribeAck.Fail();
//}
return SubscribeAck.Fail();
}
///// <summary>
///// 解析AFN0AH
///// </summary>
///// <param name="receivedMessage"></param>
///// <returns></returns>
//[KafkaSubscribe(ProtocolConst.SubscriberAFN0AHReceivedEventNameTemp)]
//public async Task<ISubscribeAck> ReceivedAFN0AEvent(MessageProtocolAnalysis<TB3761> receivedMessage)
//{
// var protocolPlugin = await _protocolService.GetProtocolServiceAsync(receivedMessage.DeviceNo);
// if (protocolPlugin == null)
// {
// _logger.LogError("协议不存在！");
// }
// else
// {
// if (receivedMessage.Data == null)
// {
// Logger.LogError($"数据解析失败：{receivedMessage.Serialize()}");
// return SubscribeAck.Success();
// }
// if (receivedMessage.Data.DT == null || receivedMessage.Data.AFN_FC == null)
// {
// Logger.LogError($"数据解析失败：{receivedMessage.Serialize()}");
// return SubscribeAck.Success();
// }
// string serverName = $"AFN{receivedMessage.Data.AFN_FC.AFN}_F{receivedMessage.Data.DT.Fn}_Analysis";
// //var analysisStrategy = _serviceProvider.GetKeyedService<IAnalysisStrategy>($"AFN0_F1_Analysis");
/// <summary>
/// 解析AFN0AH
/// </summary>
/// <param name="receivedMessage"></param>
/// <returns></returns>
[KafkaSubscribe(ProtocolConst.SubscriberAFN0AHReceivedEventNameTemp)]
public async Task<ISubscribeAck> ReceivedAFN0AEvent(MessageProtocolAnalysis<TB3761> receivedMessage)
{
var protocolPlugin = await _protocolService.GetProtocolServiceAsync(receivedMessage.DeviceNo);
if (protocolPlugin == null)
{
_logger.LogError("协议不存在！");
}
else
{
if (receivedMessage.Data == null)
{
Logger.LogError($"数据解析失败：{receivedMessage.Serialize()}");
return SubscribeAck.Success();
}
if (receivedMessage.Data.DT == null || receivedMessage.Data.AFN_FC == null)
{
Logger.LogError($"数据解析失败：{receivedMessage.Serialize()}");
return SubscribeAck.Success();
}
string serverName = $"AFN{receivedMessage.Data.AFN_FC.AFN}_F{receivedMessage.Data.DT.Fn}_Analysis";
//var analysisStrategy = _serviceProvider.GetKeyedService<IAnalysisStrategy>($"AFN0_F1_Analysis");
// //var data = await analysisStrategy.ExecuteAsync<UnitDataDto<bool>>(tB3761);
// var executor = _serviceProvider.GetRequiredService<AnalysisStrategyContext>();
// await executor.ExecuteAsync<TB3761>(serverName, receivedMessage.Data);
// return SubscribeAck.Success();
// }
//var data = await analysisStrategy.ExecuteAsync<UnitDataDto<bool>>(tB3761);
var executor = _serviceProvider.GetRequiredService<AnalysisStrategyContext>();
await executor.ExecuteAsync<TB3761>(serverName, receivedMessage.Data);
return SubscribeAck.Success();
}
// return SubscribeAck.Fail();
//}
return SubscribeAck.Fail();
}
///// <summary>
///// 解析AFN0BH
///// </summary>
///// <param name="receivedMessage"></param>
///// <returns></returns>
//[KafkaSubscribe(ProtocolConst.SubscriberAFN0BHReceivedEventNameTemp)]
//public async Task<ISubscribeAck> ReceivedAFN0BEvent(MessageProtocolAnalysis<TB3761> receivedMessage)
//{
// var protocolPlugin = await _protocolService.GetProtocolServiceAsync(receivedMessage.DeviceNo);
// if (protocolPlugin == null)
// {
// _logger.LogError("协议不存在！");
// }
// else
// {
// if (receivedMessage.Data == null)
// {
// Logger.LogError($"数据解析失败：{receivedMessage.Serialize()}");
// return SubscribeAck.Success();
// }
// if (receivedMessage.Data.DT == null || receivedMessage.Data.AFN_FC == null)
// {
// Logger.LogError($"数据解析失败：{receivedMessage.Serialize()}");
// return SubscribeAck.Success();
// }
// string serverName = $"AFN{receivedMessage.Data.AFN_FC.AFN}_F{receivedMessage.Data.DT.Fn}_Analysis";
// //var analysisStrategy = _serviceProvider.GetKeyedService<IAnalysisStrategy>($"AFN0_F1_Analysis");
/// <summary>
/// 解析AFN0BH
/// </summary>
/// <param name="receivedMessage"></param>
/// <returns></returns>
[KafkaSubscribe(ProtocolConst.SubscriberAFN0BHReceivedEventNameTemp)]
public async Task<ISubscribeAck> ReceivedAFN0BEvent(MessageProtocolAnalysis<TB3761> receivedMessage)
{
var protocolPlugin = await _protocolService.GetProtocolServiceAsync(receivedMessage.DeviceNo);
if (protocolPlugin == null)
{
_logger.LogError("协议不存在！");
}
else
{
if (receivedMessage.Data == null)
{
Logger.LogError($"数据解析失败：{receivedMessage.Serialize()}");
return SubscribeAck.Success();
}
if (receivedMessage.Data.DT == null || receivedMessage.Data.AFN_FC == null)
{
Logger.LogError($"数据解析失败：{receivedMessage.Serialize()}");
return SubscribeAck.Success();
}
string serverName = $"AFN{receivedMessage.Data.AFN_FC.AFN}_F{receivedMessage.Data.DT.Fn}_Analysis";
//var analysisStrategy = _serviceProvider.GetKeyedService<IAnalysisStrategy>($"AFN0_F1_Analysis");
// //var data = await analysisStrategy.ExecuteAsync<UnitDataDto<bool>>(tB3761);
// var executor = _serviceProvider.GetRequiredService<AnalysisStrategyContext>();
// await executor.ExecuteAsync<TB3761>(serverName, receivedMessage.Data);
// return SubscribeAck.Success();
// }
//var data = await analysisStrategy.ExecuteAsync<UnitDataDto<bool>>(tB3761);
var executor = _serviceProvider.GetRequiredService<AnalysisStrategyContext>();
await executor.ExecuteAsync<TB3761>(serverName, receivedMessage.Data);
return SubscribeAck.Success();
}
// return SubscribeAck.Fail();
//}
return SubscribeAck.Fail();
}
///// <summary>
///// 解析AFN0CH
///// </summary>
///// <param name="receivedMessage"></param>
///// <returns></returns>
//[KafkaSubscribe(ProtocolConst.SubscriberAFN0CHReceivedEventNameTemp)]
//public async Task<ISubscribeAck> ReceivedAFN0CEvent(MessageProtocolAnalysis<TB3761> receivedMessage)
//{
// var protocolPlugin = await _protocolService.GetProtocolServiceAsync(receivedMessage.DeviceNo);
// if (protocolPlugin == null)
// {
// _logger.LogError("协议不存在！");
// }
// else
// {
// if (receivedMessage.Data == null)
// {
// Logger.LogError($"数据解析失败：{receivedMessage.Serialize()}");
// return SubscribeAck.Success();
// }
// if (receivedMessage.Data.DT == null || receivedMessage.Data.AFN_FC == null)
// {
// Logger.LogError($"数据解析失败：{receivedMessage.Serialize()}");
// return SubscribeAck.Success();
// }
// string serverName = $"AFN{receivedMessage.Data.AFN_FC.AFN}_F{receivedMessage.Data.DT.Fn}_Analysis";
// //var analysisStrategy = _serviceProvider.GetKeyedService<IAnalysisStrategy>($"AFN0_F1_Analysis");
/// <summary>
/// 解析AFN0CH
/// </summary>
/// <param name="receivedMessage"></param>
/// <returns></returns>
[KafkaSubscribe(ProtocolConst.SubscriberAFN0CHReceivedEventNameTemp)]
public async Task<ISubscribeAck> ReceivedAFN0CEvent(MessageProtocolAnalysis<TB3761> receivedMessage)
{
var protocolPlugin = await _protocolService.GetProtocolServiceAsync(receivedMessage.DeviceNo);
if (protocolPlugin == null)
{
_logger.LogError("协议不存在！");
}
else
{
if (receivedMessage.Data == null)
{
Logger.LogError($"数据解析失败：{receivedMessage.Serialize()}");
return SubscribeAck.Success();
}
if (receivedMessage.Data.DT == null || receivedMessage.Data.AFN_FC == null)
{
Logger.LogError($"数据解析失败：{receivedMessage.Serialize()}");
return SubscribeAck.Success();
}
string serverName = $"AFN{receivedMessage.Data.AFN_FC.AFN}_F{receivedMessage.Data.DT.Fn}_Analysis";
//var analysisStrategy = _serviceProvider.GetKeyedService<IAnalysisStrategy>($"AFN0_F1_Analysis");
// //var data = await analysisStrategy.ExecuteAsync<UnitDataDto<bool>>(tB3761);
// var executor = _serviceProvider.GetRequiredService<AnalysisStrategyContext>();
// await executor.ExecuteAsync<TB3761>(serverName, receivedMessage.Data);
// return SubscribeAck.Success();
// }
//var data = await analysisStrategy.ExecuteAsync<UnitDataDto<bool>>(tB3761);
var executor = _serviceProvider.GetRequiredService<AnalysisStrategyContext>();
await executor.ExecuteAsync<TB3761>(serverName, receivedMessage.Data);
return SubscribeAck.Success();
}
// return SubscribeAck.Fail();
//}
return SubscribeAck.Fail();
}
///// <summary>
///// 解析AFN0DH
///// </summary>
///// <param name="receivedMessage"></param>
///// <returns></returns>
//[KafkaSubscribe(ProtocolConst.SubscriberAFN0DHReceivedEventNameTemp)]
//public async Task<ISubscribeAck> ReceivedAFN0DEvent(MessageProtocolAnalysis<TB3761> receivedMessage)
//{
// var protocolPlugin = await _protocolService.GetProtocolServiceAsync(receivedMessage.DeviceNo);
// if (protocolPlugin == null)
// {
// _logger.LogError("协议不存在！");
// }
// else
// {
// if (receivedMessage.Data == null)
// {
// Logger.LogError($"数据解析失败：{receivedMessage.Serialize()}");
// return SubscribeAck.Success();
// }
// if (receivedMessage.Data.DT == null || receivedMessage.Data.AFN_FC == null)
// {
// Logger.LogError($"数据解析失败：{receivedMessage.Serialize()}");
// return SubscribeAck.Success();
// }
// string serverName = $"AFN{receivedMessage.Data.AFN_FC.AFN}_F{receivedMessage.Data.DT.Fn}_Analysis";
// //var analysisStrategy = _serviceProvider.GetKeyedService<IAnalysisStrategy>($"AFN0_F1_Analysis");
/// <summary>
/// 解析AFN0DH
/// </summary>
/// <param name="receivedMessage"></param>
/// <returns></returns>
[KafkaSubscribe(ProtocolConst.SubscriberAFN0DHReceivedEventNameTemp)]
public async Task<ISubscribeAck> ReceivedAFN0DEvent(MessageProtocolAnalysis<TB3761> receivedMessage)
{
var protocolPlugin = await _protocolService.GetProtocolServiceAsync(receivedMessage.DeviceNo);
if (protocolPlugin == null)
{
_logger.LogError("协议不存在！");
}
else
{
if (receivedMessage.Data == null)
{
Logger.LogError($"数据解析失败：{receivedMessage.Serialize()}");
return SubscribeAck.Success();
}
if (receivedMessage.Data.DT == null || receivedMessage.Data.AFN_FC == null)
{
Logger.LogError($"数据解析失败：{receivedMessage.Serialize()}");
return SubscribeAck.Success();
}
string serverName = $"AFN{receivedMessage.Data.AFN_FC.AFN}_F{receivedMessage.Data.DT.Fn}_Analysis";
//var analysisStrategy = _serviceProvider.GetKeyedService<IAnalysisStrategy>($"AFN0_F1_Analysis");
// //var data = await analysisStrategy.ExecuteAsync<UnitDataDto<bool>>(tB3761);
// var executor = _serviceProvider.GetRequiredService<AnalysisStrategyContext>();
// await executor.ExecuteAsync<TB3761>(serverName, receivedMessage.Data);
// return SubscribeAck.Success();
// }
//var data = await analysisStrategy.ExecuteAsync<UnitDataDto<bool>>(tB3761);
var executor = _serviceProvider.GetRequiredService<AnalysisStrategyContext>();
await executor.ExecuteAsync<TB3761>(serverName, receivedMessage.Data);
return SubscribeAck.Success();
}
// return SubscribeAck.Fail();
//}
return SubscribeAck.Fail();
}
///// <summary>
///// 解析AFN0EH
///// </summary>
///// <param name="receivedMessage"></param>
///// <returns></returns>
//[KafkaSubscribe(ProtocolConst.SubscriberAFN0EHReceivedEventNameTemp)]
//public async Task<ISubscribeAck> ReceivedAFN0EEvent(MessageProtocolAnalysis<TB3761> receivedMessage)
//{
// var protocolPlugin = await _protocolService.GetProtocolServiceAsync(receivedMessage.DeviceNo);
// if (protocolPlugin == null)
// {
// _logger.LogError("协议不存在！");
// }
// else
// {
// if (receivedMessage.Data == null)
// {
// Logger.LogError($"数据解析失败：{receivedMessage.Serialize()}");
// return SubscribeAck.Success();
// }
// if (receivedMessage.Data.DT == null || receivedMessage.Data.AFN_FC == null)
// {
// Logger.LogError($"数据解析失败：{receivedMessage.Serialize()}");
// return SubscribeAck.Success();
// }
// string serverName = $"AFN{receivedMessage.Data.AFN_FC.AFN}_F{receivedMessage.Data.DT.Fn}_Analysis";
// //var analysisStrategy = _serviceProvider.GetKeyedService<IAnalysisStrategy>($"AFN0_F1_Analysis");
/// <summary>
/// 解析AFN0EH
/// </summary>
/// <param name="receivedMessage"></param>
/// <returns></returns>
[KafkaSubscribe(ProtocolConst.SubscriberAFN0EHReceivedEventNameTemp)]
public async Task<ISubscribeAck> ReceivedAFN0EEvent(MessageProtocolAnalysis<TB3761> receivedMessage)
{
var protocolPlugin = await _protocolService.GetProtocolServiceAsync(receivedMessage.DeviceNo);
if (protocolPlugin == null)
{
_logger.LogError("协议不存在！");
}
else
{
if (receivedMessage.Data == null)
{
Logger.LogError($"数据解析失败：{receivedMessage.Serialize()}");
return SubscribeAck.Success();
}
if (receivedMessage.Data.DT == null || receivedMessage.Data.AFN_FC == null)
{
Logger.LogError($"数据解析失败：{receivedMessage.Serialize()}");
return SubscribeAck.Success();
}
string serverName = $"AFN{receivedMessage.Data.AFN_FC.AFN}_F{receivedMessage.Data.DT.Fn}_Analysis";
//var analysisStrategy = _serviceProvider.GetKeyedService<IAnalysisStrategy>($"AFN0_F1_Analysis");
// //var data = await analysisStrategy.ExecuteAsync<UnitDataDto<bool>>(tB3761);
// var executor = _serviceProvider.GetRequiredService<AnalysisStrategyContext>();
// await executor.ExecuteAsync<TB3761>(serverName, receivedMessage.Data);
// return SubscribeAck.Success();
// }
//var data = await analysisStrategy.ExecuteAsync<UnitDataDto<bool>>(tB3761);
var executor = _serviceProvider.GetRequiredService<AnalysisStrategyContext>();
await executor.ExecuteAsync<TB3761>(serverName, receivedMessage.Data);
return SubscribeAck.Success();
}
// return SubscribeAck.Fail();
//}
return SubscribeAck.Fail();
}
/// <summary>

2
web/JiShe.CollectBus.Host/appsettings.json
View File

@ -141,7 +141,7 @@
}
},
"ServerApplicationOptions": {
"ServerTagName": "JiSheCollectBus8",
"ServerTagName": "JiSheCollectBus99",
"SystemType": "Energy",
"FirstCollectionTime": "2025-04-28 15:07:00",
"AutomaticVerificationTime": "16:07:00",