代码暂存

protocols/JiShe.CollectBus.Protocol.T37612012/AnalysisData/DataStorage.cs

@@ -134,7 +134,7 @@ namespace JiShe.CollectBus.Protocol.T37612012.AnalysisData
 
             await _dbProvider.InsertAsync(taskData);
             //如果无字段名，则不保存数据
-            if (string.IsNullOrWhiteSpace(data.FiledName))
+            if (!string.IsNullOrWhiteSpace(data.FiledName))
             {
                 _runtimeContext.UseTableSessionPool = false; // 使树模型池
                 await _dbProvider.InsertAsync(meter);
@@ -233,7 +233,7 @@ namespace JiShe.CollectBus.Protocol.T37612012.AnalysisData
 
                 await _dbProvider.InsertAsync(taskData);
                 //如果无字段名，则不保存数据
-                if (string.IsNullOrWhiteSpace(item.FiledName))
+                if (!string.IsNullOrWhiteSpace(item.FiledName))
                 {
                     _runtimeContext.UseTableSessionPool = false; // 使树模型池
                     await _dbProvider.InsertAsync(meter);

protocols/JiShe.CollectBus.Protocol.T37612012/T37612012ProtocolPlugin.cs

@@ -534,7 +534,7 @@ namespace JiShe.CollectBus.Protocol.T37612012
             AFN_FC aFN_FC = new AFN_FC();
             try
             {
-                if (hexStringList.Count == 0)
+                if (hexStringList.Count != 0)
                 {
 
                     BaseHexMessage baseHexMessage = new BaseHexMessage

services/JiShe.CollectBus.Application/Subscribers/SubscriberAnalysisAppService.cs

@@ -76,5 +76,444 @@ namespace JiShe.CollectBus.Subscribers
             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");
+
+                //var data = await analysisStrategy.ExecuteAsync<UnitDataDto<bool>>(tB3761);
+                var executor = _serviceProvider.GetRequiredService<AnalysisStrategyContext>();
+                await executor.ExecuteAsync<TB3761, object>(serverName, receivedMessage.Data);
+            }
+
+            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");
+
+                //var data = await analysisStrategy.ExecuteAsync<UnitDataDto<bool>>(tB3761);
+                var executor = _serviceProvider.GetRequiredService<AnalysisStrategyContext>();
+                await executor.ExecuteAsync<TB3761, object>(serverName, receivedMessage.Data);
+            }
+
+            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");
+
+                //var data = await analysisStrategy.ExecuteAsync<UnitDataDto<bool>>(tB3761);
+                var executor = _serviceProvider.GetRequiredService<AnalysisStrategyContext>();
+                await executor.ExecuteAsync<TB3761, object>(serverName, receivedMessage.Data);
+            }
+
+            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");
+
+                //var data = await analysisStrategy.ExecuteAsync<UnitDataDto<bool>>(tB3761);
+                var executor = _serviceProvider.GetRequiredService<AnalysisStrategyContext>();
+                await executor.ExecuteAsync<TB3761, object>(serverName, receivedMessage.Data);
+            }
+
+            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");
+
+                //var data = await analysisStrategy.ExecuteAsync<UnitDataDto<bool>>(tB3761);
+                var executor = _serviceProvider.GetRequiredService<AnalysisStrategyContext>();
+                await executor.ExecuteAsync<TB3761, object>(serverName, receivedMessage.Data);
+            }
+
+            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");
+
+                //var data = await analysisStrategy.ExecuteAsync<UnitDataDto<bool>>(tB3761);
+                var executor = _serviceProvider.GetRequiredService<AnalysisStrategyContext>();
+                await executor.ExecuteAsync<TB3761, object>(serverName, receivedMessage.Data);
+            }
+
+            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");
+
+                //var data = await analysisStrategy.ExecuteAsync<UnitDataDto<bool>>(tB3761);
+                var executor = _serviceProvider.GetRequiredService<AnalysisStrategyContext>();
+                await executor.ExecuteAsync<TB3761, object>(serverName, receivedMessage.Data);
+            }
+
+            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");
+
+                //var data = await analysisStrategy.ExecuteAsync<UnitDataDto<bool>>(tB3761);
+                var executor = _serviceProvider.GetRequiredService<AnalysisStrategyContext>();
+                await executor.ExecuteAsync<TB3761, object>(serverName, receivedMessage.Data);
+            }
+
+            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");
+
+                //var data = await analysisStrategy.ExecuteAsync<UnitDataDto<bool>>(tB3761);
+                var executor = _serviceProvider.GetRequiredService<AnalysisStrategyContext>();
+                await executor.ExecuteAsync<TB3761, object>(serverName, receivedMessage.Data);
+            }
+
+            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");
+
+                //var data = await analysisStrategy.ExecuteAsync<UnitDataDto<bool>>(tB3761);
+                var executor = _serviceProvider.GetRequiredService<AnalysisStrategyContext>();
+                await executor.ExecuteAsync<TB3761, object>(serverName, receivedMessage.Data);
+            }
+
+            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");
+
+                //var data = await analysisStrategy.ExecuteAsync<UnitDataDto<bool>>(tB3761);
+                var executor = _serviceProvider.GetRequiredService<AnalysisStrategyContext>();
+                await executor.ExecuteAsync<TB3761, object>(serverName, receivedMessage.Data);
+            }
+
+            return SubscribeAck.Fail();
+        }
+
+
+        /// <summary>
+        /// 解析AFN0HH
+        /// </summary>
+        /// <param name="receivedMessage"></param>
+        /// <returns></returns>
+        [KafkaSubscribe(ProtocolConst.SubscriberAFN10HReceivedEventNameTemp)]
+        public async Task<ISubscribeAck> ReceivedAFN0HEvent(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, object>(serverName, receivedMessage.Data);
+            }
+
+            return SubscribeAck.Fail();
+        }
     }
 }

services/JiShe.CollectBus.Application/Subscribers/WorkerSubscriberAppService.cs

@@ -117,6 +117,8 @@ namespace JiShe.CollectBus.Subscribers
                     await _tcpService.SendAsync(receivedMessage.FocusAddress, Convert.FromHexString(receivedMessage.IssuedMessageHexString));
 
                     receivedMessage.IsSend = true;
+                    receivedMessage.SendNum += 1;
+                    receivedMessage.NextSendTime = DateTime.Now.AddMinutes(5);
                     await _dbProvider.InsertAsync(receivedMessage);
 
                     return SubscribeAck.Success();

services/JiShe.CollectBus.Domain/IotSystems/MeterReadingRecords/MeterReadingTelemetryPacketInfo.cs

@@ -128,6 +128,18 @@ namespace JiShe.CollectBus.IotSystems.MeterReadingRecords
         [FIELDColumn]
         public bool IsSend { get; set; }
 
+        /// <summary>
+        /// 发送次数
+        /// </summary>
+        [FIELDColumn]
+        public int SendNum { get; set; }
+
+        /// <summary>
+        /// 下次发送时间
+        /// </summary>
+        [FIELDColumn]
+        public DateTime? NextSendTime { get; set; }
+
         /// <summary>
         /// 创建时间
         /// </summary>
@@ -174,7 +186,7 @@ namespace JiShe.CollectBus.IotSystems.MeterReadingRecords
         /// 是否已上报
         /// </summary>
         [FIELDColumn]
-        public bool IsReceived { get; set; } 
+        public bool IsReceived { get; set; }
 
     }
 }

web/JiShe.CollectBus.Host/Pages/Monitor.cshtml

@@ -16,6 +16,7 @@
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <link href="libs/bootstrap/css/bootstrap.min.css" rel="stylesheet" />
     <title>后端服务</title>
+
 </head>
 
 <body>

web/JiShe.CollectBus.Host/appsettings.json

@@ -141,7 +141,7 @@
       "DefaultIdempotence": true
     }
   },
-  "PlugInFolder": "C:\\Users\\Dai Zan\\Desktop\\Plugins",
+  "PlugInFolder": "",
   "ServerApplicationOptions": {
     "ServerTagName": "JiSheCollectBus100",
     "SystemType": null,