代码暂存

2025-04-27 15:44:54 +08:00 · 2025-04-27 15:44:54 +08:00 · 2ee205d00b
commit 2ee205d00b
parent 63acc1c263
7 changed files with 459 additions and 5 deletions
--- a/protocols/JiShe.CollectBus.Protocol.T37612012/AnalysisData/DataStorage.cs
+++ b/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);
--- a/protocols/JiShe.CollectBus.Protocol.T37612012/T37612012ProtocolPlugin.cs
+++ b/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
--- a/services/JiShe.CollectBus.Application/Subscribers/SubscriberAnalysisAppService.cs
+++ b/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();
+        }
    }
 }
--- a/services/JiShe.CollectBus.Application/Subscribers/WorkerSubscriberAppService.cs
+++ b/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();
--- a/services/JiShe.CollectBus.Domain/IotSystems/MeterReadingRecords/MeterReadingTelemetryPacketInfo.cs
+++ b/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>
--- a/web/JiShe.CollectBus.Host/Pages/Monitor.cshtml
+++ b/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>
--- a/web/JiShe.CollectBus.Host/appsettings.json
+++ b/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,