J1147
/
HealthMonitor
Segui 1
Vota 0
Forka 0
Codice Problemi 0 Pull Requests 0 Rilasci 0 Wiki Attività
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
175 Commit
8 Rami (Branch)
4.8MB
Albero (Tree): cb1506b318
Rami (Branch) Tag
${ item.name }
Crea branch ${ searchTerm }
da 'cb1506b318'
${ noResults }
HealthMonitor/HealthMonitor.WebApi/Worker.cs

1003 lines
67KB
Originale Blame Cronologia 

  1. using dotnet_etcd;

  2. using Etcdserverpb;

  3. using Google.Protobuf.WellKnownTypes;

  4. using HealthMonitor.Common;

  5. using HealthMonitor.Common.helper;

  6. using HealthMonitor.Core.Common.Extensions;

  7. using HealthMonitor.Core.Pipeline;

  8. using HealthMonitor.Model.Config;

  9. using HealthMonitor.Model.Service;

  10. using HealthMonitor.Model.Service.Mapper;

  11. using HealthMonitor.Service.Biz;

  12. using HealthMonitor.Service.Biz.db;

  13. using HealthMonitor.Service.Cache;

  14. using HealthMonitor.Service.Etcd;

  15. using HealthMonitor.Service.MessageQueue;

  16. using HealthMonitor.Service.Sub;

  17. using Microsoft.AspNetCore.Mvc.RazorPages;

  18. using Microsoft.EntityFrameworkCore.Metadata.Internal;

  19. using Microsoft.Extensions.Options;

  20. using Newtonsoft.Json;

  21. using Newtonsoft.Json.Linq;

  22. using System;

  23. using System.Reflection;

  24. using System.Threading.Channels;

  25. using TDengineDriver;

  26. using TDengineTMQ;

  27. using TelpoDataService.Util.Clients;

  28. using TelpoDataService.Util.Entities.GpsCard;

  29. using TelpoDataService.Util.Entities.GpsLocationHistory;

  30. using TelpoDataService.Util.Models;

  31. using TelpoDataService.Util.QueryObjects;

  32. 

  33. namespace HealthMonitor.WebApi

  34. {

  35.     public class Worker : BackgroundService

  36.     {

  37.         private readonly ILogger<Worker> _logger;

  38.         private readonly IServiceProvider _services;

  39.         private readonly TDengineDataSubcribe _tdEngineDataSubcribe;

  40.         private readonly PackageProcess _processor;

  41.         private readonly TDengineService _serviceTDengine;

  42.         private readonly EtcdService _serviceEtcd;

  43.         private readonly HttpHelper _httpHelper = default!;

  44.         private readonly IotApiService _serviceIotApi;

  45.         private readonly BoodPressResolverConfig _configBoodPressResolver;

  46.         private readonly BloodPressReferenceValueCacheManager _bpRefValCacheManager;

  47.         private readonly PersonCacheManager _personCacheMgr;

  48.         private readonly DeviceCacheManager _deviceCacheMgr;

  49.         private readonly FetalMovementNormalValueRangeCacheManager _mgrFetalMovementNormalValueRangeCache;

  50. 

  51.         private readonly GpsLocationHistoryAccessorClient<HisGpsFetalHeartRate> _hisFetalHeartApiClient;

  52.         private readonly GpsLocationHistoryAccessorClient<HisGpsFetalMovement> _hisFetalMovementApiClient;

  53. 

  54.         private readonly MqProcessLogic _serviceMqProcess;

  55. 

  56.         private CancellationTokenSource _tokenSource = default!;

  57. 

  58.         public Worker(ILogger<Worker> logger, IServiceProvider services, PersonCacheManager personCacheMgr, 

  59.             BloodPressReferenceValueCacheManager bpRefValCacheManager, IotApiService IotApiService, 

  60.             IOptions<BoodPressResolverConfig> optionBoodPressResolver, PackageProcess processor, 

  61.             TDengineDataSubcribe tdEngineDataSubcribe, TDengineService serviceDengine,

  62.             GpsLocationHistoryAccessorClient<HisGpsFetalHeartRate> hisFetalHeartApiClient,

  63.             GpsLocationHistoryAccessorClient<HisGpsFetalMovement> hisFetalMovementApiClient,

  64.             FetalMovementNormalValueRangeCacheManager fetalMovementNormalValueRangeCacheMgr, MqProcessLogic serviceMqProcess,

  65.             HttpHelper httpHelper, EtcdService serviceEtcd, DeviceCacheManager deviceCacheMgr)

  66.         {

  67.             _logger = logger;

  68.             _tdEngineDataSubcribe = tdEngineDataSubcribe;

  69.             _services = services;

  70.             _serviceIotApi = IotApiService;

  71.             _processor = processor;

  72.             _serviceEtcd = serviceEtcd;

  73.             _serviceTDengine = serviceDengine;

  74.             _httpHelper = httpHelper;

  75.             _configBoodPressResolver = optionBoodPressResolver.Value;

  76.             _bpRefValCacheManager = bpRefValCacheManager;

  77.             _personCacheMgr = personCacheMgr;

  78.             _deviceCacheMgr = deviceCacheMgr;

  79.             _hisFetalHeartApiClient = hisFetalHeartApiClient;

  80.             _hisFetalMovementApiClient = hisFetalMovementApiClient;

  81.             _serviceMqProcess = serviceMqProcess;

  82.             _mgrFetalMovementNormalValueRangeCache = fetalMovementNormalValueRangeCacheMgr;

  83.         }

  84. 

  85.         public override Task StartAsync(CancellationToken cancellationToken)

  86.         {

  87.             //_logger.LogInformation("------StartAsync");

  88.             _tokenSource = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);

  89.             return base.StartAsync(cancellationToken);

  90.         }

  91. 

  92.         public override Task StopAsync(CancellationToken cancellationToken)

  93.         {

  94.             //_logger.LogInformation("------StopAsync");

  95.             _tokenSource.Cancel();  //停止工作线程

  96.             return base.StopAsync(cancellationToken);

  97.         }

  98.         protected override async Task ExecuteAsync(CancellationToken stoppingToken)

  99.         {

  100.             var tasks = new[]

  101.             {

  102.                 Task.Run(async () =>

  103.                 {

  104.                     _logger.LogInformation("解析器启动");

  105.                     while (!stoppingToken.IsCancellationRequested)

  106.                     {

  107.                         await _processor.ResolveAsync().ConfigureAwait(false);

  108.                     }

  109.                 }, stoppingToken),

  110. 

  111.                 Task.Run(() =>

  112.                 {

  113.                     _logger.LogInformation("TDengine 订阅启动");

  114.                     while (!stoppingToken.IsCancellationRequested)

  115.                     {

  116.                         _tdEngineDataSubcribe.BeginListen(stoppingToken);

  117.                     }

  118.                 }, stoppingToken),

  119. 

  120.                 Task.Run(() =>

  121.                     _serviceEtcd.WacthKeysWithPrefixResponseAsync("health_monitor/schedule_push", WatchEvents),

  122.                     stoppingToken)

  123.             };

  124. 

  125.             await Task.WhenAll(tasks);

  126.         }

  127. 

  128.         private void WatchEvents(WatchResponse response)

  129.         {

  130. 

  131.             response.Events.ToList<Mvccpb.Event>().ForEach(async e =>

  132.             {

  133.                 try

  134.                 {

  135.                     switch (e.Type.ToString())

  136.                     {

  137.                         case "Put":

  138.                             // 获取时间点计算TTL

  139.                             Console.BackgroundColor = ConsoleColor.Blue;

  140.                             Console.WriteLine($"--- {e.Type}--{e.Kv.Key.ToStringUtf8()}--{e.Kv.Value.ToStringUtf8()}---{DateTime.Now}");

  141.                             Console.BackgroundColor = ConsoleColor.Black;

  142.                             break;

  143. 

  144.                         case "Delete":

  145.                             // TTL到了重新计算TTL，下发

  146.                             //Console.BackgroundColor = ConsoleColor.Green;

  147.                             //Console.WriteLine($"--- {e.Type}--{e.Kv.Key.ToStringUtf8()}--{e.Kv.Value.ToStringUtf8()}---{DateTime.Now}");

  148. 

  149.                             // var key = $"health_monitor/schedule_push/imei/{bp.Serialno}";

  150.                             var key = e.Kv.Key.ToStringUtf8();

  151.                             var imeiDel = key.Split('/')[^1];

  152.                             var schedule_push = await _serviceEtcd.GetValAsync(key).ConfigureAwait(false);

  153.                             if (string.IsNullOrWhiteSpace(schedule_push))

  154.                             {

  155.                                 if (key.Contains("pregnancy_heart_rate"))

  156.                                 {

  157.                                     var watchConfig = await _deviceCacheMgr.GetGpsDeviceWatchConfigCacheObjectBySerialNoAsync(imeiDel, "0067");

  158.                                     var isFetalHeartEnable = watchConfig != null && (int)watchConfig["enabled"]! == 1;

  159. 

  160.                                     if (isFetalHeartEnable)

  161.                                     {

  162.                                         // 高频心率采样间隔 highFreqSampleInterval = highFreqSampleInterval+5,增加5秒兼容

  163.                                         var highFreqSampleInterval = (int)watchConfig!["highFreqSampleInterval"]! + 5;

  164. 

  165.                                         // 处理孕妇业务，计算一般心率并下发

  166.                                         var commonPHR = await _serviceTDengine.InitPregnancyCommonHeartRateModeAsync(imeiDel, highFreqSampleInterval: highFreqSampleInterval);

  167.                                         if (commonPHR == null)

  168.                                         {

  169.                                             // 建模中

  170.                                             var flag = await _serviceIotApi.SetFetalConfig(imeiDel);

  171.                                             _logger.LogInformation($"{imeiDel} 建模建模中");

  172.                                         }

  173.                                         else

  174.                                         {

  175.                                             // 建模完成

  176.                                             var flag = await _serviceIotApi.SetFetalConfig(imeiDel, 1, commonPHR.MaxValue, commonPHR.MinValue);

  177.                                             _logger.LogInformation($"{imeiDel} 建模完成");

  178.                                             // 保存到TDengine数据库

  179.                                             await _serviceTDengine.InsertAsync<PregnancyCommonHeartRateModel>("hm_pchr", commonPHR);

  180.                                             _logger.LogInformation($"保存TDengine完成");

  181. 

  182.                                             //

  183.                                         }

  184.                                     }

  185. 

  186. 

  187.                                    

  188. 

  189.                                     #region 注册定时下发

  190.                                     var startTime = DateTime.Now;

  191.                                     // 注册下次下推

  192.                                     var endTime = DateTime.Now;

  193. 

  194. #if DEBUG

  195. 

  196. 

  197.                                     //long ttl = (long)((60 * 1000-(endTime-startTime).TotalMilliseconds)/1000);

  198.                                     //await _serviceEtcd.PutValAsync(key, imeiDel,ttl, false).ConfigureAwait(false);

  199. 

  200.                                     var interval = 0;

  201.                                     // 获取当前时间

  202.                                     DateTime now = DateTime.Now;

  203. 

  204.                                     // 计算距离下一个$interval天后的8点的时间间隔

  205.                                     DateTime nextRunTime = new DateTime(now.Year, now.Month, now.Day, now.Hour, now.Minute + 2, 0).AddDays(interval);

  206.                                     TimeSpan timeUntilNextRun = nextRunTime - now;

  207. 

  208.                                     // 如果当前时间已经超过了8点，将等待到明天后的8点

  209.                                     if (timeUntilNextRun < TimeSpan.Zero)

  210.                                     {

  211.                                         timeUntilNextRun = timeUntilNextRun.Add(TimeSpan.FromMinutes(1));

  212.                                         nextRunTime += timeUntilNextRun;

  213.                                     }

  214. 

  215.                                      //long ttl = timeUntilNextRun.Milliseconds/1000;

  216.                                     long ttl = (long)((timeUntilNextRun.TotalMilliseconds - (endTime - startTime).TotalMilliseconds) / 1000);

  217.                                     var data = new

  218.                                     {

  219.                                         imei = imeiDel,

  220.                                         create_time = now.ToString("yyyy-MM-dd HH:mm:ss"),

  221.                                         ttl,

  222.                                         next_run_time = nextRunTime.ToString("yyyy-MM-dd HH:mm:ss")

  223.                                     };

  224.                                     var result = JsonConvert.SerializeObject(data);

  225. 

  226.                                     await _serviceEtcd.PutValAsync(key, result, ttl, false).ConfigureAwait(false);

  227. 

  228. 

  229. #else

  230.                                         // 每$interval天,晚上8点

  231.                                         var interval = 1;

  232.                                         // 获取当前时间

  233.                                         DateTime now = DateTime.Now;

  234.                                         var rand = new Random();

  235. 

  236.                                         var pushSec = rand.Next(59);

  237.                                         int pushMin = int.TryParse(imeiDel.AsSpan(imeiDel.Length - 1), out pushMin) ? pushMin : 10;

  238.                                         // 计算距离下一个$interval天后的0点的时间间隔

  239.                                          DateTime nextRunTime = new DateTime(now.Year, now.Month, now.Day, 6, pushMin, pushSec).AddDays(interval);

  240.                                         TimeSpan timeUntilNextRun = nextRunTime - now;

  241. 

  242.                                         // 如果当前时间已经超过了8点，将等待到明天后的8点

  243.                                         if (timeUntilNextRun < TimeSpan.Zero)

  244.                                         {

  245.                                             timeUntilNextRun = timeUntilNextRun.Add(TimeSpan.FromDays(1));

  246.                                             nextRunTime += timeUntilNextRun;

  247.                                         }

  248. 

  249.                                         // var ttl = timeUntilNextRun.TotalMilliseconds;

  250.                                         long ttl = (long)((timeUntilNextRun.TotalMilliseconds-(endTime-startTime).TotalMilliseconds)/1000);

  251.                                         var data = new

  252.                                         {

  253.                                             imei = imeiDel,

  254.                                             create_time = now.ToString("yyyy-MM-dd HH:mm:ss"),

  255.                                             ttl,

  256.                                             next_run_time = nextRunTime.ToString("yyyy-MM-dd HH:mm:ss")

  257.                                         };

  258.                                         var result = JsonConvert.SerializeObject(data);

  259.                                         await _serviceEtcd.PutValAsync(key, result, ttl, false).ConfigureAwait(false);

  260. #endif

  261.                                     #endregion

  262.                                 }

  263.                                 // health_monitor/schedule_push/cal_fetal_heart_rate/imei/

  264.                                 else if (key.Contains("health_monitor/schedule_push/cal_fetal_heart_rate/imei/"))

  265.                                 {

  266.                                     /**

  267.                                      var watchConfig = await _deviceCacheMgr.GetGpsDeviceWatchConfigCacheObjectBySerialNoAsync(imeiDel, "0067");

  268.                                      var isFetalHeartEnable = watchConfig != null && (int)watchConfig["enabled"]! == 1;

  269.                                      

  270.                                      if (isFetalHeartEnable)

  271.                                      {

  272.                                          // 处理胎心计算业务，计算一般心率获取胎心系数

  273.                                          var commonPHR = await _serviceTDengine.InitPregnancyCommonHeartRateModeAsync(imeiDel);

  274.                                          if (commonPHR != null)

  275.                                          {

  276.                                              # region 计算上刻钟的胎心数据

  277.                                              // 告警上限阀值

  278.                                              var upperAlarmThreshold = (int)watchConfig!["upperAlarmThreshold"]!;

  279.                                              // 告警下限阀值

  280.                                              var lowerAlarmThreshold = (int)watchConfig["lowerAlarmThreshold"]!;

  281. 

  282.                                              //var lastPhr = await _serviceTDengine.GetLastAsync<PregnancyHeartRateModel>();

  283.                                              // 计算胎心=孕妇心率*系数

  284.                                              //var fetalHeartRate = SafeType.SafeInt(lastPhr.PregnancyHeartRate * commonPHR?.StatModeAvgFprCoefficient!);

  285. 

  286.                                              // 上15分钟的数据

  287.                                              // 获取当前时间

  288.                                              DateTime now = DateTime.Now;

  289. 

  290.                                              // 计算当前时间到上一刻钟的分钟数

  291.                                              int minutesToSubtract = now.Minute % 15;

  292. 

  293.                                              // 计算上一刻钟的时间

  294.                                              DateTime previousQuarter = now.AddMinutes(-minutesToSubtract).AddSeconds(-now.Second).AddMilliseconds(-now.Millisecond);

  295. 

  296.                                              var lastQuarterPhr = await _serviceTDengine.GetBySerialNoAsync<PregnancyHeartRateModel>(imeiDel, 1);

  297. 

  298.                                              var filteredPhr = lastQuarterPhr

  299.                                                  .Where(i => i.LastUpdate <= previousQuarter && i.LastUpdate >= previousQuarter.AddMinutes(-15))

  300.                                                  .ToList();

  301. 

  302.                                              var lastQuarterPhrValue = filteredPhr.Count == 1

  303.                                                  ? filteredPhr.First().PregnancyHeartRate

  304.                                                  : filteredPhr.Average(i => i.PregnancyHeartRate);

  305. 

  306.                                              var fetalHeartRate = SafeType.SafeInt(lastQuarterPhrValue * commonPHR?.StatModeAvgFprCoefficient!);

  307.                                              var sampleTime = DateTimeUtil.ConvertToTimeStamp(DateTime.Now).ToString();

  308.                                              

  309.                                              var isAbnormal = fetalHeartRate > upperAlarmThreshold ? 1 : (fetalHeartRate < lowerAlarmThreshold ? 2 : 0);

  310. 

  311.                                              HisGpsFetalHeartRate gpsFetalHeartRate = new()

  312.                                              {

  313.                                                  FetalHeartRateId = Guid.NewGuid().ToString("D"),

  314.                                                  PersonId = commonPHR!.PersonId,

  315.                                                  Serialno = imeiDel,

  316.                                                  HeartRate = fetalHeartRate,

  317.                                                  SampleTime = sampleTime,

  318.                                                  IsAbnormal = isAbnormal,

  319.                                                  StatStartTime = filteredPhr.OrderByDescending(i=>i.LastUpdate).First().LastUpdate,

  320.                                                  StatEndTime = filteredPhr.OrderByDescending(i => i.LastUpdate).Last().LastUpdate,

  321.                                                  CreateTime = DateTime.Now,

  322.                                                  Method = 1,

  323.                                                  IsDisplay = 1,

  324.                                                  DeviceKey = commonPHR!.DeviceKey

  325.                                              };

  326.                                              // 保存到 数据服务 MySQL 数据库

  327.                                              await _hisFetalHeartApiClient.AddAsync(gpsFetalHeartRate).ConfigureAwait(false);

  328. 

  329.                                              // 推送到api/v1/open/OpenIot/SetFetalHeartRateConfig

  330.                                              await _serviceIotApi.SetFetalHeartRateConfig(imeiDel, fetalHeartRate, sampleTime, isAbnormal);

  331.                                              #endregion

  332.                                              

  333.                                              #region  注册定时计算胎心数据触发器 {interval} 秒后

  334.                                              //await SetIntervalTriggerAsync(key, imeiDel, 60 * 15);

  335.                                              #endregion

  336.                                          }

  337.                                      }

  338.                                     */

  339. 

  340.                                 }

  341. 

  342.                                 //health_monitor/schedule_push/cal_fetal_movement/imei/

  343.                                 else if (key.Contains("health_monitor/schedule_push/cal_fetal_movement/imei/"))

  344.                                 {

  345.                                     //// 计算胎动数据

  346.                                     //var watchConfig = await _deviceCacheMgr.GetGpsDeviceWatchConfigCacheObjectBySerialNoAsync(imeiDel, "0067");

  347.                                     //var isFetalHeartEnable = watchConfig != null && (int)watchConfig["enabled"]! == 1;

  348.                                     //if (isFetalHeartEnable)

  349.                                     //{

  350.                                     //    // 检查胎心建模

  351.                                     //    var fchr = await _serviceTDengine.GetLastAsync<PregnancyCommonHeartRateModel>(imeiDel);

  352.                                     //    if (fchr != null)

  353.                                     //    {

  354.                                     //        // 获取孕妇心率数据接近最近2小时的数据

  355.                                     //        var phr = await _serviceTDengine.GetBySerialNoAsync<PregnancyHeartRateModel>(imeiDel, 7);

  356.                                     //        var now = DateTime.Now;

  357.                                     //        var ago2hrs = now.AddHours(-2);

  358.                                     //        var phrRange = phr.Where(i => i.LastUpdate >= ago2hrs)

  359.                                     //        .OrderByDescending(i => i.LastUpdate)

  360.                                     //        .Select(i => i.LastUpdate)

  361.                                     //        .ToList();

  362. 

  363.                                     //        if (phrRange.Count >= 2)

  364.                                     //        {

  365.                                     //            var duringMins = (phrRange.First() - phrRange.Last()).TotalMinutes;

  366.                                     //            //在餐后时间段（8:00~10:00，12:00~14:00，18:00~20:00，22:00~24:00）取中间值。其他时间段取正常起始值

  367.                                     //            bool isInTimeRanges = IsNowInTimeRanges();

  368. 

  369.                                     //            //long.TryParse(watchConfig!["EDOC"]!.ToString(), out long edoc);

  370.                                     //            var edoc = DateTimeUtil.ToDateTime(watchConfig!["EDOC"]!.ToString());

  371. 

  372.                                     //            int pregnancyWeeks = (DateTime.Now -edoc.AddDays(-280)).Days / 7;

  373.                                     //            if (pregnancyWeeks >= 12 && pregnancyWeeks <= 50)

  374.                                     //            {

  375.                                     //                var fetalMovementMap = _mgrFetalMovementNormalValueRangeCache.GetFetalMovements();

  376. 

  377.                                     //                var fetalMovementMapValue = isInTimeRanges? fetalMovementMap

  378.                                     //                        .Where(i =>

  379.                                     //                        i.PregnancyPeriod![0] <= pregnancyWeeks &&

  380.                                     //                        i.PregnancyPeriod[1] >= pregnancyWeeks)

  381.                                     //                        .Select(i=>i.MedianMovement)

  382.                                     //                        .FirstOrDefault()

  383.                                     //                        :

  384.                                     //                        fetalMovementMap

  385.                                     //                        .Where(i =>

  386.                                     //                        i.PregnancyPeriod![0] <= pregnancyWeeks &&

  387.                                     //                        i.PregnancyPeriod[1] >= pregnancyWeeks)

  388.                                     //                        .Select(i => i.InitialMovement)

  389.                                     //                        .FirstOrDefault()

  390.                                     //                ;

  391. 

  392.                                     //                var fetalMovementValue = fetalMovementMapValue * duringMins * 2 / 120;

  393.                                     //                // 四舍五入

  394.                                     //                var fetalMovement= (int)Math.Round(fetalMovementValue, 0, MidpointRounding.AwayFromZero);

  395. 

  396.                                     //                var sampleTime = DateTimeUtil.ConvertToTimeStamp(DateTime.Now).ToString();

  397.                                     //                // 告警上限阀值

  398.                                     //                var upperAlarmThreshold = (int)watchConfig["upperAlarmThreshold"]!;

  399.                                     //                // 告警下限阀值

  400.                                     //                var lowerAlarmThreshold = (int)watchConfig["lowerAlarmThreshold"]!;

  401. 

  402.                                     //                GeneralParam param = new()

  403.                                     //                {

  404.                                     //                    Filters = new List<QueryFilterCondition>

  405.                                     //                    {

  406.                                     //                        new ()

  407.                                     //                        {

  408.                                     //                            Key=nameof(HisGpsFetalimeiDel),

  409.                                     //                            Value=imeiDel,

  410.                                     //                            ValueType=QueryValueTypeEnum.String,

  411.                                     //                            Operator=QueryOperatorEnum.Equal

  412.                                     //                        }

  413.                                     //                    },

  414.                                     //                    OrderBys = new List<OrderByCondition>

  415.                                     //                    {

  416.                                     //                        new() {

  417.                                     //                           IsDesc=true,

  418.                                     //                           Key=nameof(HisGpsFetalHeartRate.CreateTime)

  419.                                     //                        }

  420.                                     //                     }

  421.                                     //                };

  422.                                     //                var frh = await _hisFetalHeartApiClient.GetFirstAsync(param, imeiDel.Substring(imeiDel.Length - 2), null, new RequestHeader { RequestId = Guid.NewGuid().ToString("D") }).ConfigureAwait(false);

  423.                                     //                if (frh != null)

  424.                                     //                {

  425.                                     //                    var fetalHeartRate = frh.HeartRate;

  426.                                     //                    var isAbnormal = fetalHeartRate > upperAlarmThreshold ? 1 : (fetalHeartRate < lowerAlarmThreshold ? 2 : 0);

  427.                                     //                    // 推送到api/v1/open/OpenIot/SetFetalMovementConfig

  428.                                     //                    await _serviceIotApi.SetFetalMovementConfig(imeiDel, fetalMovement, sampleTime, isAbnormal);

  429.                                     //                    // 保存到MySQL数据库

  430.                                     //                }

  431.                                     //            }

  432. 

  433.                                     //        }

  434. 

  435.                                     //    }

  436. 

  437.                                     //    #region 定时计算胎动数据触发器 2小时后

  438.                                     //    await SetIntervalTriggerAsync(key, imeiDel, 60 * 60 * 2);

  439.                                     //    #endregion

  440.                                     //}

  441. 

  442.                                     #region 胎动延时计算

  443.                                     var watchConfig = await _deviceCacheMgr.GetGpsDeviceWatchConfigCacheObjectBySerialNoAsync(imeiDel, "0067");

  444.                                     var isFetalHeartEnable = watchConfig != null && (int)watchConfig["enabled"]! == 1;

  445.                                     if (isFetalHeartEnable) 

  446.                                     {

  447.                                       

  448. 

  449.                                         var edoc = DateTimeUtil.ToDateTime(watchConfig!["EDOC"]!.ToString());

  450.                                         // 已经建模

  451.                                         var commonPHR = await _serviceTDengine.GetLastAsync<PregnancyCommonHeartRateModel>(imeiDel);

  452.                                         if (commonPHR != null)

  453.                                         {

  454.                                             var phr = await _serviceTDengine.GetBySerialNoAsync<PregnancyHeartRateModel>(imeiDel, 7);

  455.                                             _logger.LogInformation($"{imeiDel} 计算胎动数据 ");

  456. 

  457.                                             var fmNow = DateTime.Now;

  458.                                             // 两小时前

  459.                                             var fmNowSubtract = fmNow.AddMinutes(-fmNow.Minute).AddSeconds(-fmNow.Second).AddMilliseconds(-fmNow.Millisecond);

  460.                                             

  461.                                             var fetalMovementSampleTime = DateTimeUtil.ConvertToTimeStamp(fmNowSubtract).ToString()[..10];

  462. 

  463.                                             // 统计开始时间

  464.                                             var statStartTime = fmNowSubtract.AddHours(-2);

  465.                                             // 统计结束时间

  466.                                             var statEndTime = fmNowSubtract;

  467. 

  468.                                             var isFetalMovementExisted = await _deviceCacheMgr.FetalMovementIsExistedAsync(imeiDel, fetalMovementSampleTime);

  469.                                             _logger.LogInformation($"{imeiDel} 胎动记录{isFetalMovementExisted},数据采样时间:{fetalMovementSampleTime}|{fmNowSubtract.ToString("yyyy-MM-dd HH:mm:ss")}, 周期:{statStartTime}-{statEndTime} 开始");

  470. 

  471.                                             if (!isFetalMovementExisted)

  472.                                             {

  473.                                                 /// 开始计算

  474.                                                 var phrRange = phr.Where(i => i.LastUpdate >= statStartTime && i.LastUpdate <= statEndTime)

  475.                                                 .OrderByDescending(i => i.LastUpdate)

  476.                                                 .Select(i => i.LastUpdate)

  477.                                                 .ToList();

  478.                                                 // 判断是否有持续佩戴

  479.                                                 if (phrRange.Count >= 2)

  480.                                                 {

  481.                                                     var duringMins = Math.Abs((phrRange.First() - statStartTime).TotalMinutes);

  482.                                                     //在餐后时间段（8:00~10:00，12:00~14:00，18:00~20:00，22:00~24:00）取中间值。其他时间段取正常起始值

  483.                                                     bool isInTimeRanges = IsLastUpdateInTimeRanges(phrRange.First());

  484. 

  485.                                                     int pregnancyWeeks = (DateTime.Now - edoc.AddDays(-280)).Days / 7;

  486.                                                     if (pregnancyWeeks >= 12 && pregnancyWeeks <= 50)

  487.                                                     {

  488.                                                         var fetalMovementMap = _mgrFetalMovementNormalValueRangeCache.GetFetalMovements();

  489. 

  490.                                                         var fetalMovementMapValue = isInTimeRanges ? fetalMovementMap

  491.                                                                 .Where(i =>

  492.                                                                 i.PregnancyPeriod![0] <= pregnancyWeeks &&

  493.                                                                 i.PregnancyPeriod[1] >= pregnancyWeeks)

  494.                                                                 .Select(i => i.MedianMovement)

  495.                                                                 .FirstOrDefault()

  496.                                                                 :

  497.                                                                 fetalMovementMap

  498.                                                                 .Where(i =>

  499.                                                                 i.PregnancyPeriod![0] <= pregnancyWeeks &&

  500.                                                                 i.PregnancyPeriod[1] >= pregnancyWeeks)

  501.                                                                 .Select(i => i.InitialMovement)

  502.                                                                 .FirstOrDefault()

  503.                                                         ;

  504. 

  505.                                                         var fetalMovementValue = (fetalMovementMapValue * duringMins * 2) / 120;

  506.                                                         // 四舍五入

  507.                                                         var fetalMovement = (int)Math.Round(fetalMovementValue, 0, MidpointRounding.AwayFromZero);

  508.                                                         // _logger.LogInformation($"{imeiDel} segmentCountFMIndex: {i} -- fetalMovementSampleTime:{fetalMovementSampleTime}|{midNight.AddHours(2 * i).ToString("yyyy-MM-dd HH:mm:ss")} -- statStartTime: {statStartTime} -- statEndTime: {statEndTime}-- isFetalMovementExisted: {isFetalMovementExisted} ");

  509. 

  510.                                                         _logger.LogInformation($"{imeiDel} 孕周：{pregnancyWeeks}，胎动数据采样时间:{fetalMovementSampleTime}|{fmNowSubtract.ToString("yyyy-MM-dd HH:mm:ss")}, 采样周期:{statStartTime}-{statEndTime}, 原始胎动值:{fetalMovementMapValue}, 佩戴时间 :{duringMins}|{statStartTime}-{phrRange.First()}, 胎动计算值:{fetalMovementValue}, 胎动最终值:{fetalMovement} 已完成.");

  511. 

  512.                                                         // 读取胎心数据

  513.                                                         GeneralParam param = new()

  514.                                                         {

  515.                                                             Filters = new List<QueryFilterCondition>

  516.                                                             {

  517.                                                                 new ()

  518.                                                                 {

  519.                                                                     Key=nameof(HisGpsFetalHeartRate.Serialno),

  520.                                                                     Value=imeiDel,

  521.                                                                     ValueType=QueryValueTypeEnum.String,

  522.                                                                     Operator=QueryOperatorEnum.Equal

  523.                                                                 },

  524.                                                                 //new ()

  525.                                                                 //{

  526.                                                                 //    Key=nameof(HisGpsFetalHeartRate.SampleTime),

  527.                                                                 //    Value=sampleTime,

  528.                                                                 //    ValueType=QueryValueTypeEnum.String,

  529.                                                                 //    Operator=QueryOperatorEnum.GreaterEqual

  530.                                                                 //},

  531.                                                             },

  532.                                                             OrderBys=new List<OrderByCondition>

  533.                                                             { 

  534.                                                                 new (){ 

  535.                                                                    IsDesc=true,

  536.                                                                    Key=nameof(HisGpsFetalHeartRate.SampleTime)

  537.                                                                 }

  538.                                                             }

  539.                                                         };

  540.                                                         var fetalHeartRateIsAbnormal = 0;

  541.                                                         var fhr = await _hisFetalHeartApiClient.GetFirstAsync(param, imeiDel[^2..], null, new RequestHeader { RequestId = Guid.NewGuid().ToString("D") });

  542.                                                         // 获取胎心数据状态与胎动数据状态一致

  543.                                                         var feltalMovementIsAbnormal = fetalHeartRateIsAbnormal;

  544.                                                         //var feltalMovementIsAbnormal = 0;

  545.                                                         // 推送到api/v1/open/OpenIot/SetFetalMovementConfig

  546. 

  547.                                                         await _serviceIotApi.SetFetalMovementConfig(imeiDel, fetalMovement, fetalMovementSampleTime, feltalMovementIsAbnormal);

  548. 

  549.                                                         // 保存到MySQL数据库

  550.                                                         HisGpsFetalMovement fm = new()

  551.                                                         {

  552.                                                             FetalMovementId = Guid.NewGuid().ToString("D"),

  553.                                                             PersonId = commonPHR!.PersonId,

  554.                                                             Serialno = imeiDel,

  555.                                                             CreateTime = DateTime.Now,

  556.                                                             IsAbnormal = feltalMovementIsAbnormal,

  557.                                                             FetalMovementValue = fetalMovement,

  558.                                                             SampleTime = fetalMovementSampleTime,

  559.                                                             Method = 1,

  560.                                                             IsDisplay = 1,

  561.                                                             DeviceKey = commonPHR!.DeviceKey

  562.                                                         };

  563.                                                         await _hisFetalMovementApiClient.AddAsync(fm).ConfigureAwait(false);

  564. 

  565.                                                         // 发送到微信

  566.                                                         if (feltalMovementIsAbnormal != 0)

  567.                                                         {

  568.                                                             var device = await _deviceCacheMgr.GetDeviceBySerialNoAsync(imeiDel).ConfigureAwait(false);

  569.                                                             var fmMsgId = $"{imeiDel}-{fetalMovementSampleTime}-{Guid.NewGuid().ToString("D")[^3..]}";

  570.                                                             var topic = "topic.push.wx";

  571.                                                             var fmMsg = new

  572.                                                             {

  573.                                                                 messageId = Guid.NewGuid().ToString("D"),

  574.                                                                 topic = topic,

  575.                                                                 time = DateTimeUtil.GetDateTimeFromUnixTimeMilliseconds(long.Parse(fetalMovementSampleTime.Length < 13 ? fetalMovementSampleTime.PadRight(13, '0') : fetalMovementSampleTime)).ToString("yyyy-MM-dd HH:mm:ss"),

  576.                                                                 data = new

  577.                                                                 {

  578.                                                                     deviceId = device?.DeviceId,

  579.                                                                     imei = imeiDel,

  580.                                                                     alarmTypeId = 12,

  581.                                                                     alarmDeviceName = imeiDel,

  582.                                                                     alarmRemarks = JsonConvert.SerializeObject(new { fetalMovementValue = fetalMovement, isAbnormal = feltalMovementIsAbnormal }),

  583.                                                                     address = string.Empty,

  584.                                                                     deviceKey = device?.DeviceId

  585.                                                                 }

  586.                                                             };

  587.                                                             await _serviceMqProcess.ProcessIMEIEventMessageAsync(fmMsgId, topic, fmMsg).ConfigureAwait(false);

  588.                                                         }

  589.                                                         // 设置入库缓存记录

  590.                                                         await _deviceCacheMgr.SetFetalMovementAsync(imeiDel, fetalMovementSampleTime, fm);

  591. 

  592.                                                     }

  593.                                                     else

  594.                                                     {

  595.                                                         _logger.LogWarning($"{imeiDel} 孕周 {pregnancyWeeks},超出胎动计算范围");

  596.                                                     }

  597.                                                 }

  598.                                                 else

  599.                                                 {

  600.                                                     _logger.LogInformation($"{imeiDel} 胎动记录{isFetalMovementExisted},数据采样时间:{fetalMovementSampleTime}|{fmNowSubtract.ToString("yyyy-MM-dd HH:mm:ss")}, 周期:{statStartTime}-{statEndTime} 不足两条,不能判断是否持续佩戴");

  601. 

  602.                                                 }

  603.                                             }

  604.                                             else

  605.                                             {

  606.                                                 _logger.LogInformation($"{imeiDel} 胎动记录{isFetalMovementExisted},数据采样时间:{fetalMovementSampleTime}|{fmNowSubtract.ToString("yyyy-MM-dd HH:mm:ss")}, 周期:{statStartTime}-{statEndTime} 已处理");

  607.                                             }

  608.                                         }

  609. 

  610.                                         

  611.                                     }

  612.                                     #endregion

  613.                                 }

  614.                                 else

  615.                                 {

  616.                                     // 处理血压业务

  617.                                     int systolicInc;

  618.                                     int diastolicInc;

  619. 

  620.                                     int systolicRefValue;

  621.                                     int diastolicRefValue;

  622. 

  623.                                     decimal systolicAvg;

  624.                                     decimal diastolicAvg;

  625. 

  626.                                     int systolicMax = 0;

  627.                                     int diastolicMax = 0;

  628. 

  629.                                     // 统计时间

  630.                                     //DateTime endTime = DateTime.Now; //测试

  631.                                     DateTime statStartTime = DateTime.Now;

  632. 

  633. 

  634.                                     // 最小值

  635.                                     int systolicMin = 0;

  636.                                     int diastolicMin = 0;

  637. 

  638.                                     // 偏移参数

  639.                                     var avgOffset = 0.25M;

  640.                                     var systolicAvgOffset = avgOffset;

  641.                                     var diastolicAvgOffset = avgOffset;

  642. 

  643.                                     // 最后一次下发值

  644.                                     int lastPushSystolicInc = 0;

  645.                                     int lastPushDiastolicInc = 0;

  646. 

  647. 

  648.                                     var startTime = DateTime.Now;

  649.                                     // 下发增量值

  650.                                     #region 统计定时下发增量值

  651.                                     //var last = await _serviceTDengine.GetLastAsync("stb_hm_bloodpress_stats_inc", $"serialno='{imeiDel}' order by last_update desc");

  652.                                     //var ts = last?[0];

  653. 

  654.                                     // 最后一条血压数据

  655.                                     var condition = $"serialno='{imeiDel}' order by last_update desc";

  656.                                     var field = "last_row(*)";

  657.                                     var lastHmBpResponse = await _serviceTDengine.ExecuteSelectRestResponseAsync("stb_hm_bloodpress", condition, field);

  658.                                     var lastHmBpParser = JsonConvert.DeserializeObject<ParseTDengineRestResponse<BloodPressureModel>>(lastHmBpResponse!);

  659.                                     var lastHmBp = lastHmBpParser?.Select().FirstOrDefault();

  660.                                     //if (lastHmBpParser?.Select()?.ToList().Count < 2)

  661.                                     //{

  662.                                     //    _logger.LogInformation($"{imeiDel} -- {nameof(Worker)} --{nameof(WatchEvents)} -- 血压数据条目不足");

  663.                                     //    break;

  664.                                     //}

  665. 

  666.                                     // 7 天有效数据

  667.                                     if (lastHmBp?.Timestamp.AddDays(7) > DateTime.Now)

  668.                                     {

  669.                                         // 计算增量值

  670.                                         condition = $"serialno='{imeiDel}' order by ts desc";

  671.                                         var lastPushResponse = await _serviceTDengine.ExecuteSelectRestResponseAsync("stb_hm_bp_push_ref_inc_value", condition, field);

  672.                                         if (lastPushResponse == null)

  673.                                         {

  674.                                             _logger.LogInformation($"{imeiDel}--没有下发记录");

  675.                                             break;

  676.                                         }

  677.                                         var lastPushParser = JsonConvert.DeserializeObject<ParseTDengineRestResponse<BloodPressurePushRefIncModel>>(lastPushResponse);

  678.                                         var lastPush = lastPushParser!.Select().FirstOrDefault();

  679.                                         // 有下推记录

  680.                                         if (lastPush != null)

  681.                                         {

  682.                                             systolicRefValue = lastPush!.SystolicRefValue;

  683.                                             diastolicRefValue = lastPush!.DiastolicRefValue;

  684.                                             lastPushSystolicInc = lastPush!.SystolicIncValue;

  685.                                             lastPushDiastolicInc = lastPush!.DiastolicIncValue;

  686.                                             condition = $"ts between '{lastPush?.Timestamp:yyyy-MM-dd HH:mm:ss.fff}' and '{startTime:yyyy-MM-dd HH:mm:ss.fff}' " +

  687.                                             $"and serialno='{imeiDel}' " +

  688.                                             $"and is_display = true";

  689.                                             // 使用最近一次的下推时间作为统计的开始时间

  690.                                             statStartTime = lastPush!.Timestamp;

  691.                                         }

  692.                                         // 没有下推记录(历史遗留数据),没有初始的测量值产生的平均值（测量值=平均值）

  693.                                         else

  694.                                         {

  695.                                             #region 获取个人信息

  696. 

  697.                                             var person = await _personCacheMgr.GetDeviceGpsPersonCacheBySerialNoAsync(Guid.NewGuid().ToString(), imeiDel).ConfigureAwait(false);

  698.                                             //验证这个信息是否存在

  699.                                             if (person == null || person?.Person.BornDate == null)

  700.                                             {

  701.                                                 _logger.LogWarning($"{nameof(Worker)}--{imeiDel} 验证个人信息，找不到个人信息，跳过此消息");

  702.                                                 break;

  703.                                             }

  704.                                             // 验证年龄是否在范围 （2 - 120）

  705.                                             var age = SafeType.SafeInt(DateTime.Today.Year - person?.Person.BornDate!.Value.Year!);

  706.                                             if (age < 2 || age > 120)

  707.                                             {

  708.                                                 _logger.LogWarning($"{nameof(Worker)}--{imeiDel} 验证年龄，不在范围 （2 - 120）岁，跳过此消息");

  709.                                                 break;

  710.                                             }

  711. 

  712.                                             var gender = person?.Person.Gender == true ? 1 : 2;

  713.                                             var isHypertension = SafeType.SafeBool(person?.Person.Ishypertension!);

  714.                                             var height = SafeType.SafeDouble(person?.Person.Height!);

  715.                                             var weight = SafeType.SafeDouble(person?.Person.Weight!);

  716. 

  717.                                             #endregion

  718. 

  719.                                             #region 初始化常规血压标定值标定值

  720.                                             var bpRef = await _bpRefValCacheManager.GetBloodPressReferenceValueAsync(age, gender, isHypertension);

  721.                                             //systolicRefValue = bpRef!.Systolic;//?

  722.                                             //diastolicRefValue = bpRef!.Diastolic;//?

  723.                                             #endregion

  724. 

  725.                                             systolicRefValue = bpRef!.Systolic;

  726.                                             diastolicRefValue = bpRef!.Diastolic;

  727.                                             lastPushSystolicInc = 0;

  728.                                             lastPushDiastolicInc = 0;

  729.                                             condition = $"ts <= '{startTime:yyyy-MM-dd HH:mm:ss.fff}' " +

  730.                                             $"and serialno='{imeiDel}' " +

  731.                                             $"and is_display = true";

  732.                                         }

  733. 

  734. 

  735. 

  736.                                         var hmBpResponse = await _serviceTDengine.ExecuteSelectRestResponseAsync("stb_hm_bloodpress", condition);

  737.                                         var hmBpParser = JsonConvert.DeserializeObject<ParseTDengineRestResponse<BloodPressureModel>>(hmBpResponse!);

  738.                                         var hmBp = hmBpParser?.Select();

  739.                                         //if (hmBp?.ToList().Count < 2)

  740.                                         // 1. 判断数据样本数量

  741.                                         if (hmBpParser!.Rows < 5)

  742.                                         {

  743.                                             _logger.LogInformation($"{imeiDel} -- {nameof(Worker)} --{nameof(WatchEvents)} -- 统计定时下发，计算增量值的数据条目不足:{hmBpParser!.Rows} < 5");

  744.                                             _logger.LogInformation($"{imeiDel} -- {nameof(Worker)} --{nameof(WatchEvents)} 没有足够的数据样本，不会定时下发");

  745.                                             break;

  746.                                         }

  747.                                         // 没有下推记录重新计算统计时间

  748.                                         if (lastPush == null)

  749.                                         {

  750.                                             var firstHmBp = hmBpParser?.Select(i => i).OrderBy(i => i.Timestamp).FirstOrDefault();

  751.                                             statStartTime = firstHmBp!.Timestamp;

  752.                                         }

  753. 

  754.                                         // NewMethod(systolicRefValue, hmBpParser);

  755. 

  756.                                         // 最大值

  757.                                         //systolicMax = (int)hmBpParser?.Select(i => i.SystolicValue).Max()!;

  758.                                         //diastolicMax = (int)hmBpParser?.Select(i => i.DiastolicValue).Max()!;

  759.                                         //// 最小值

  760.                                         //systolicMin = (int)hmBpParser?.Select(i => i.SystolicValue).Min()!;

  761.                                         //diastolicMin = (int)hmBpParser?.Select(i => i.DiastolicValue).Min()!;

  762. 

  763.                                         //systolicAvg = (int)(hmBpParser?.AverageAfterRemovingOneMinMaxRef(i => i.SystolicValue, SafeType.SafeInt(systolicRefValue!)))!;

  764.                                         //diastolicAvg = (int)(hmBpParser?.AverageAfterRemovingOneMinMaxRef(i => i.DiastolicValue, SafeType.SafeInt(diastolicRefValue!)))!;

  765. 

  766.                                         var avgs = _serviceTDengine.AverageAfterRemovingOneMinMaxRef(hmBpParser!);

  767.                                         systolicAvg = avgs[0];

  768.                                         diastolicAvg = avgs[1];

  769. 

  770. 

  771.                                         // 2. 判断能否计算增量值

  772.                                         if (systolicAvg.Equals(0))

  773.                                         {

  774.                                             _logger.LogInformation($"{imeiDel}--{nameof(Worker)}--计算平均值" +

  775.                                             $"\n currentSystolicAvg:{systolicAvg}  -- lastPushSystolicInc:{lastPushSystolicInc}" +

  776.                                             $"\n currentDiastolicInc:{diastolicAvg}  -- lastPushDiastolicInc:{lastPushDiastolicInc}");

  777.                                             _logger.LogInformation($"{imeiDel}--{nameof(Worker)} 没有足够的数据样本计算平均值，不会定时下发");

  778.                                             break;

  779.                                         }

  780.                                         // 除最大值和最小值后的平均值与标定值差值少于4后（当天计算出该结果则也不产生增量调整），就不再进行增量值调整了。

  781.                                         if (systolicRefValue - systolicAvg < 4)

  782.                                         {

  783.                                             _logger.LogInformation($"diastolic 舒张压 {imeiDel}除最大值和最小值后的平均值:{diastolicAvg}与标定值:{diastolicRefValue}\n systolic 收缩压 {imeiDel}除最大值和最小值后的平均值:{systolicAvg}与标定值:{systolicRefValue}的差值(标定值-平均值)少于4后，systolic 收缩压 不再进行增量值调整");

  784.                                             break;

  785.                                         }

  786. 

  787.                                         if (diastolicRefValue - diastolicAvg < 4)

  788.                                         {

  789.                                             _logger.LogInformation($"systolic 收缩压 {imeiDel}除最大值和最小值后的平均值:{systolicAvg}与标定值:{systolicRefValue}\n diastolic 舒张压 {imeiDel}除最大值和最小值后的平均值:{diastolicAvg}与标定值:{diastolicRefValue}的差值(标定值-平均值)少于4后，diastolic 舒张压 不再进行增量值调整");

  790.                                             break;

  791.                                         }

  792. 

  793.                                         // 增量值=（标定值-平均值）* 0.25

  794.                                         var currentSystolicInc = (int)((systolicRefValue - systolicAvg) * systolicAvgOffset)!;

  795.                                         var currentDiastolicInc = (int)((diastolicRefValue - diastolicAvg) * diastolicAvgOffset)!;

  796. 

  797. 

  798.                                         // 累计增量

  799.                                         systolicInc = currentSystolicInc + lastPushSystolicInc;

  800.                                         diastolicInc = currentDiastolicInc + lastPushDiastolicInc;

  801. 

  802.                                         _logger.LogInformation($"{imeiDel}--{nameof(Worker)}--计算增量值" +

  803.                                                 $"\n {imeiDel} -- systolicAvg:{systolicAvg}-- systolicInc:{systolicInc}-- currentSystolicInc:{currentSystolicInc} -- lastPushSystolicInc:{lastPushSystolicInc}" +

  804.                                                 $"\n {imeiDel} -- diastolicAvg:{diastolicAvg}-- diastolicInc:{diastolicInc} --currentDiastolicInc:{currentDiastolicInc} -- lastPushDiastolicInc:{lastPushDiastolicInc}");

  805.                                         _logger.LogInformation($"{imeiDel}--{nameof(Worker)}-- 定时校准,发给设备的绝对增量值=（上次绝对增量值+新数据的增量值）");

  806. 

  807. 

  808.                                         _logger.LogInformation($"{nameof(Worker)} 开启血压标定值下发: {_configBoodPressResolver.EnableBPRefPush}");

  809.                                         if (_configBoodPressResolver.EnableBPRefPush)

  810.                                         // if (false) // 临时关闭

  811.                                         {

  812.                                             BloodPressCalibrationConfigModel bpIncData = new()

  813.                                             {

  814. 

  815.                                                 Imei = imeiDel,

  816.                                                 SystolicRefValue = SafeType.SafeInt(((int)systolicRefValue!)),  //收缩压标定值，值为0 表示不生效

  817.                                                 DiastolicRefValue = SafeType.SafeInt(((int)diastolicRefValue!)), //舒张压标定值，值为0表示不生效

  818.                                                 SystolicIncValue = SafeType.SafeInt(((int)systolicInc!)), //收缩压显示增量，值为0 表示不生效

  819.                                                 DiastolicIncValue = SafeType.SafeInt(((int)diastolicInc!))   //舒张压显示增量，值为0 表示不生效

  820.                                             };

  821.                                             //var pushedBP = await _serviceIotApi.SetBloodPressCalibrationConfigAsync(bpIncData).ConfigureAwait(false);

  822.                                             var response = await _serviceIotApi.SetBloodPressCalibrationConfig2Async(bpIncData).ConfigureAwait(false);

  823.                                             var pushedBP = response.Flag;

  824.                                             if (pushedBP)

  825.                                             {

  826.                                                 #region 保存下推记录 stb_hm_bp_push_ref_inc_value

  827.                                                 var sql = $"INSERT INTO health_monitor.hm_bp_push_ref_inc_value_{imeiDel.Substring(imeiDel.Length - 2)} " +

  828.                                                         $"USING health_monitor.stb_hm_bp_push_ref_inc_value " +

  829.                                                         $"TAGS ('{imeiDel.Substring(imeiDel.Length - 2)}')  " +

  830.                                                         $"VALUES(" +

  831.                                                             $"'{startTime:yyyy-MM-dd HH:mm:ss.fff}'," +

  832.                                                             $"'{imeiDel}'," +

  833.                                                             $"{bpIncData.SystolicRefValue}," +

  834.                                                             $"{bpIncData.DiastolicRefValue}," +

  835.                                                             $"{bpIncData.SystolicIncValue}," +

  836.                                                             $"{bpIncData.DiastolicIncValue}," +

  837.                                                             $"{false}," +

  838.                                                             $"{systolicAvg}," +

  839.                                                             $"{diastolicAvg}," +

  840.                                                             $"{systolicAvgOffset}," +

  841.                                                             $"{diastolicAvgOffset}," +

  842.                                                             $"'{statStartTime:yyyy-MM-dd HH:mm:ss.fff}'," +

  843.                                                             $"'{startTime:yyyy-MM-dd HH:mm:ss.fff}'" +

  844.                                                             $")";

  845.                                                 _serviceTDengine.ExecuteInsertSQL(sql);

  846.                                                 #endregion

  847. 

  848.                                                 #region 注册定时下发

  849.                                                 // 注册下次下推

  850.                                                 var endTime = DateTime.Now;

  851. 

  852. #if DEBUG

  853. 

  854. 

  855.                                                 //long ttl = (long)((60 * 1000-(endTime-startTime).TotalMilliseconds)/1000);

  856.                                                 //await _serviceEtcd.PutValAsync(key, imeiDel,ttl, false).ConfigureAwait(false);

  857. 

  858.                                                 var interval = 0;

  859.                                                 // 获取当前时间

  860.                                                 DateTime now = DateTime.Now;

  861. 

  862.                                                 // 计算距离下一个$interval天后的8点的时间间隔

  863.                                                 DateTime nextRunTime = new DateTime(now.Year, now.Month, now.Day, now.Hour, now.Minute + 2, 0).AddDays(interval);

  864.                                                 TimeSpan timeUntilNextRun = nextRunTime - now;

  865. 

  866.                                                 // 如果当前时间已经超过了8点，将等待到明天后的8点

  867.                                                 if (timeUntilNextRun < TimeSpan.Zero)

  868.                                                 {

  869.                                                     timeUntilNextRun = timeUntilNextRun.Add(TimeSpan.FromMinutes(1));

  870.                                                     nextRunTime += timeUntilNextRun;

  871.                                                 }

  872. 

  873.                                                 // var ttl = timeUntilNextRun.TotalMilliseconds;

  874.                                                 long ttl = (long)((timeUntilNextRun.TotalMilliseconds - (endTime - startTime).TotalMilliseconds) / 1000);

  875.                                                 var data = new

  876.                                                 {

  877.                                                     imei = imeiDel,

  878.                                                     create_time = now.ToString("yyyy-MM-dd HH:mm:ss"),

  879.                                                     ttl,

  880.                                                     next_run_time = nextRunTime.ToString("yyyy-MM-dd HH:mm:ss")

  881.                                                 };

  882.                                                 var result = JsonConvert.SerializeObject(data);

  883. 

  884.                                                 await _serviceEtcd.PutValAsync(key, result, ttl, false).ConfigureAwait(false);

  885. 

  886. 

  887. #else

  888.                                         // 每$interval天,晚上8点

  889.                                         var interval = 1;

  890.                                         // 获取当前时间

  891.                                         DateTime now = DateTime.Now;

  892. 

  893.                                         // 计算距离下一个$interval天后的8点的时间间隔

  894.                                         DateTime nextRunTime = new DateTime(now.Year, now.Month, now.Day, 20, 0, 0).AddDays(interval);

  895.                                         TimeSpan timeUntilNextRun = nextRunTime - now;

  896. 

  897.                                         // 如果当前时间已经超过了8点，将等待到明天后的8点

  898.                                         if (timeUntilNextRun < TimeSpan.Zero)

  899.                                         {

  900.                                             timeUntilNextRun = timeUntilNextRun.Add(TimeSpan.FromDays(1));

  901.                                             nextRunTime += timeUntilNextRun;

  902.                                         }

  903. 

  904.                                         // var ttl = timeUntilNextRun.TotalMilliseconds;

  905.                                         long ttl = (long)((timeUntilNextRun.TotalMilliseconds-(endTime-startTime).TotalMilliseconds)/1000);

  906.                                         var data = new

  907.                                         {

  908.                                             imei = imeiDel,

  909.                                             create_time = now.ToString("yyyy-MM-dd HH:mm:ss"),

  910.                                             ttl,

  911.                                             next_run_time = nextRunTime.ToString("yyyy-MM-dd HH:mm:ss")

  912.                                         };

  913.                                         var result = JsonConvert.SerializeObject(data);

  914.                                         await _serviceEtcd.PutValAsync(key, result, ttl, false).ConfigureAwait(false);

  915. #endif

  916.                                                 #endregion

  917. 

  918.                                             }

  919.                                             else

  920.                                             {

  921.                                                 _logger.LogInformation($"错误响应，没有下推数据:{response.Message}");

  922.                                             }

  923.                                         }

  924.                                     }

  925.                                     else

  926.                                     {

  927.                                         _logger.LogInformation($"向{imeiDel}统计数据已经失效");

  928.                                     }

  929.                                     #endregion

  930. 

  931.                                 }

  932. 

  933.                             }

  934.                             break;

  935.                     }

  936.                 }

  937.                 catch (Exception ex)

  938.                 {

  939.                     _logger.LogInformation($"{nameof(WatchEvents)},出错: |{ex.Message}|{ex.StackTrace}");

  940.                 }

  941. 

  942. 

  943.             });

  944. 

  945.         }

  946. 

  947. 

  948.         private async Task SetIntervalTriggerAsync(string key, string imei, long interval)

  949. 

  950.         {

  951.             // var key = $"health_monitor/schedule_push/{type}/imei/{imei}";

  952.             var schedulePush = await _serviceEtcd.GetValAsync(key).ConfigureAwait(false);

  953.             if (string.IsNullOrWhiteSpace(schedulePush))

  954.             {

  955.                 var now = DateTime.Now;

  956.                 var timeNextRun = now.Add(TimeSpan.FromSeconds(interval));

  957.                 var data = new

  958.                 {

  959.                     imei,

  960.                     create_time = now.ToString("yyyy-MM-dd HH:mm:ss"),

  961.                     ttl = interval,

  962.                     next_run_time = timeNextRun.ToString("yyyy-MM-dd HH:mm:ss")

  963.                 };

  964.                 var result = JsonConvert.SerializeObject(data);

  965.                 await _serviceEtcd.PutValAsync(key, result, interval, false).ConfigureAwait(false);

  966.             }

  967.         }

  968. 

  969.         public static bool IsNowInTimeRanges()

  970.         {

  971.             var now = DateTime.Now.TimeOfDay;

  972. 

  973.             var timeRanges = new List<(TimeSpan Start, TimeSpan End)>

  974.             {

  975.                 // 8:00~10:00，12:00~14:00，18:00~20:00，22:00~24:00

  976.                 (new TimeSpan(8, 0, 0), new TimeSpan(10, 0, 0)),

  977.                 (new TimeSpan(12, 0, 0), new TimeSpan(14, 0, 0)),

  978.                 (new TimeSpan(18, 0, 0), new TimeSpan(20, 0, 0)),

  979.                 (new TimeSpan(22, 0, 0), new TimeSpan(24, 0, 0))

  980.             };

  981. 

  982.             return timeRanges.Any(range => now >= range.Start && now <= range.End);

  983.         }

  984.         public static bool IsLastUpdateInTimeRanges(DateTime lastUpdate)

  985.         {

  986.             var now = lastUpdate.TimeOfDay;

  987. 

  988.             var timeRanges = new List<(TimeSpan Start, TimeSpan End)>

  989.             {

  990.                 // 8:00~10:00，12:00~14:00，18:00~20:00，22:00~24:00

  991.                 (new TimeSpan(8, 0, 0), new TimeSpan(10, 0, 0)),

  992.                 (new TimeSpan(12, 0, 0), new TimeSpan(14, 0, 0)),

  993.                 (new TimeSpan(18, 0, 0), new TimeSpan(20, 0, 0)),

  994.                 (new TimeSpan(22, 0, 0), new TimeSpan(24, 0, 0))

  995.             };

  996. 

  997.             return timeRanges.Any(range => now >= range.Start && now <= range.End);

  998.         }

  999. 

  1000. 

  1001.     }

  1002. }