J1147
/
HealthMonitor
Следить 1
В избранное 0
Форкнуть 0
Код Задачи 0 Pull Request'ы 0 Релизы 0 Вики Активность
Вы не можете выбрать более 25 тем Темы должны начинаться с буквы или цифры, могут содержать дефисы(-) и должны содержать не более 35 символов.
169 коммитов
8 Ветки
14MB
Дерево: 8a4ba0edad
Ветки Теги
${ item.name }
Создать ветку ${ searchTerm }
из '8a4ba0edad'
${ noResults }
HealthMonitor/HealthMonitor.WebApi/Worker.cs

993 lines
66KB
Исходник Blame История 

  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.                                     // 处理孕妇业务，计算一般心率并下发

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

  159.                                     // 设置胎心监测参数

  160. 

  161.                                     if (commonPHR == null)

  162.                                     {

  163.                                         // 建模中

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

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

  166.                                     }

  167.                                     else

  168.                                     {

  169.                                         // 建模完成

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

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

  172.                                         // 保存到TDengine数据库

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

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

  175. 

  176.                                         //

  177.                                     }

  178. 

  179.                                     #region 注册定时下发

  180.                                     var startTime = DateTime.Now;

  181.                                     // 注册下次下推

  182.                                     var endTime = DateTime.Now;

  183. 

  184. #if DEBUG

  185. 

  186. 

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

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

  189. 

  190.                                     var interval = 0;

  191.                                     // 获取当前时间

  192.                                     DateTime now = DateTime.Now;

  193. 

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

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

  196.                                     TimeSpan timeUntilNextRun = nextRunTime - now;

  197. 

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

  199.                                     if (timeUntilNextRun < TimeSpan.Zero)

  200.                                     {

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

  202.                                         nextRunTime += timeUntilNextRun;

  203.                                     }

  204. 

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

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

  207.                                     var data = new

  208.                                     {

  209.                                         imei = imeiDel,

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

  211.                                         ttl,

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

  213.                                     };

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

  215. 

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

  217. 

  218. 

  219. #else

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

  221.                                         var interval = 1;

  222.                                         // 获取当前时间

  223.                                         DateTime now = DateTime.Now;

  224.                                         var rand = new Random();

  225. 

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

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

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

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

  230.                                         TimeSpan timeUntilNextRun = nextRunTime - now;

  231. 

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

  233.                                         if (timeUntilNextRun < TimeSpan.Zero)

  234.                                         {

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

  236.                                             nextRunTime += timeUntilNextRun;

  237.                                         }

  238. 

  239.                                         // var ttl = timeUntilNextRun.TotalMilliseconds;

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

  241.                                         var data = new

  242.                                         {

  243.                                             imei = imeiDel,

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

  245.                                             ttl,

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

  247.                                         };

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

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

  250. #endif

  251.                                     #endregion

  252.                                 }

  253.                                 // health_monitor/schedule_push/cal_fetal_heart_rate/imei/

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

  255.                                 {

  256.                                     /**

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

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

  259.                                      

  260.                                      if (isFetalHeartEnable)

  261.                                      {

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

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

  264.                                          if (commonPHR != null)

  265.                                          {

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

  267.                                              // 告警上限阀值

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

  269.                                              // 告警下限阀值

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

  271. 

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

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

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

  275. 

  276.                                              // 上15分钟的数据

  277.                                              // 获取当前时间

  278.                                              DateTime now = DateTime.Now;

  279. 

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

  281.                                              int minutesToSubtract = now.Minute % 15;

  282. 

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

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

  285. 

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

  287. 

  288.                                              var filteredPhr = lastQuarterPhr

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

  290.                                                  .ToList();

  291. 

  292.                                              var lastQuarterPhrValue = filteredPhr.Count == 1

  293.                                                  ? filteredPhr.First().PregnancyHeartRate

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

  295. 

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

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

  298.                                              

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

  300. 

  301.                                              HisGpsFetalHeartRate gpsFetalHeartRate = new()

  302.                                              {

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

  304.                                                  PersonId = commonPHR!.PersonId,

  305.                                                  Serialno = imeiDel,

  306.                                                  HeartRate = fetalHeartRate,

  307.                                                  SampleTime = sampleTime,

  308.                                                  IsAbnormal = isAbnormal,

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

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

  311.                                                  CreateTime = DateTime.Now,

  312.                                                  Method = 1,

  313.                                                  IsDisplay = 1,

  314.                                                  DeviceKey = commonPHR!.DeviceKey

  315.                                              };

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

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

  318. 

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

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

  321.                                              #endregion

  322.                                              

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

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

  325.                                              #endregion

  326.                                          }

  327.                                      }

  328.                                     */

  329. 

  330.                                 }

  331. 

  332.                                 //health_monitor/schedule_push/cal_fetal_movement/imei/

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

  334.                                 {

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

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

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

  338.                                     //if (isFetalHeartEnable)

  339.                                     //{

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

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

  342.                                     //    if (fchr != null)

  343.                                     //    {

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

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

  346.                                     //        var now = DateTime.Now;

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

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

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

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

  351.                                     //        .ToList();

  352. 

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

  354.                                     //        {

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

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

  357.                                     //            bool isInTimeRanges = IsNowInTimeRanges();

  358. 

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

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

  361. 

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

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

  364.                                     //            {

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

  366. 

  367.                                     //                var fetalMovementMapValue = isInTimeRanges? fetalMovementMap

  368.                                     //                        .Where(i =>

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

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

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

  372.                                     //                        .FirstOrDefault()

  373.                                     //                        :

  374.                                     //                        fetalMovementMap

  375.                                     //                        .Where(i =>

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

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

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

  379.                                     //                        .FirstOrDefault()

  380.                                     //                ;

  381. 

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

  383.                                     //                // 四舍五入

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

  385. 

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

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

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

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

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

  391. 

  392.                                     //                GeneralParam param = new()

  393.                                     //                {

  394.                                     //                    Filters = new List<QueryFilterCondition>

  395.                                     //                    {

  396.                                     //                        new ()

  397.                                     //                        {

  398.                                     //                            Key=nameof(HisGpsFetalimeiDel),

  399.                                     //                            Value=imeiDel,

  400.                                     //                            ValueType=QueryValueTypeEnum.String,

  401.                                     //                            Operator=QueryOperatorEnum.Equal

  402.                                     //                        }

  403.                                     //                    },

  404.                                     //                    OrderBys = new List<OrderByCondition>

  405.                                     //                    {

  406.                                     //                        new() {

  407.                                     //                           IsDesc=true,

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

  409.                                     //                        }

  410.                                     //                     }

  411.                                     //                };

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

  413.                                     //                if (frh != null)

  414.                                     //                {

  415.                                     //                    var fetalHeartRate = frh.HeartRate;

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

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

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

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

  420.                                     //                }

  421.                                     //            }

  422. 

  423.                                     //        }

  424. 

  425.                                     //    }

  426. 

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

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

  429.                                     //    #endregion

  430.                                     //}

  431. 

  432.                                     #region 胎动延时计算

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

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

  435.                                     if (isFetalHeartEnable) 

  436.                                     {

  437.                                       

  438. 

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

  440.                                         // 已经建模

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

  442.                                         if (commonPHR != null)

  443.                                         {

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

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

  446. 

  447.                                             var fmNow = DateTime.Now;

  448.                                             // 两小时前

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

  450.                                             

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

  452. 

  453.                                             // 统计开始时间

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

  455.                                             // 统计结束时间

  456.                                             var statEndTime = fmNowSubtract;

  457. 

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

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

  460. 

  461.                                             if (!isFetalMovementExisted)

  462.                                             {

  463.                                                 /// 开始计算

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

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

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

  467.                                                 .ToList();

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

  469.                                                 if (phrRange.Count >= 2)

  470.                                                 {

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

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

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

  474. 

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

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

  477.                                                     {

  478.                                                         var fetalMovementMap = _mgrFetalMovementNormalValueRangeCache.GetFetalMovements();

  479. 

  480.                                                         var fetalMovementMapValue = isInTimeRanges ? fetalMovementMap

  481.                                                                 .Where(i =>

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

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

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

  485.                                                                 .FirstOrDefault()

  486.                                                                 :

  487.                                                                 fetalMovementMap

  488.                                                                 .Where(i =>

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

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

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

  492.                                                                 .FirstOrDefault()

  493.                                                         ;

  494. 

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

  496.                                                         // 四舍五入

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

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

  499. 

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

  501. 

  502.                                                         // 读取胎心数据

  503.                                                         GeneralParam param = new()

  504.                                                         {

  505.                                                             Filters = new List<QueryFilterCondition>

  506.                                                             {

  507.                                                                 new ()

  508.                                                                 {

  509.                                                                     Key=nameof(HisGpsFetalHeartRate.Serialno),

  510.                                                                     Value=imeiDel,

  511.                                                                     ValueType=QueryValueTypeEnum.String,

  512.                                                                     Operator=QueryOperatorEnum.Equal

  513.                                                                 },

  514.                                                                 //new ()

  515.                                                                 //{

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

  517.                                                                 //    Value=sampleTime,

  518.                                                                 //    ValueType=QueryValueTypeEnum.String,

  519.                                                                 //    Operator=QueryOperatorEnum.GreaterEqual

  520.                                                                 //},

  521.                                                             },

  522.                                                             OrderBys=new List<OrderByCondition>

  523.                                                             { 

  524.                                                                 new (){ 

  525.                                                                    IsDesc=true,

  526.                                                                    Key=nameof(HisGpsFetalHeartRate.SampleTime)

  527.                                                                 }

  528.                                                             }

  529.                                                         };

  530.                                                         var fetalHeartRateIsAbnormal = 0;

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

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

  533.                                                         var feltalMovementIsAbnormal = fetalHeartRateIsAbnormal;

  534.                                                         //var feltalMovementIsAbnormal = 0;

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

  536. 

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

  538. 

  539.                                                         // 保存到MySQL数据库

  540.                                                         HisGpsFetalMovement fm = new()

  541.                                                         {

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

  543.                                                             PersonId = commonPHR!.PersonId,

  544.                                                             Serialno = imeiDel,

  545.                                                             CreateTime = DateTime.Now,

  546.                                                             IsAbnormal = feltalMovementIsAbnormal,

  547.                                                             FetalMovementValue = fetalMovement,

  548.                                                             SampleTime = fetalMovementSampleTime,

  549.                                                             Method = 1,

  550.                                                             IsDisplay = 1,

  551.                                                             DeviceKey = commonPHR!.DeviceKey

  552.                                                         };

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

  554. 

  555.                                                         // 发送到微信

  556.                                                         if (feltalMovementIsAbnormal != 0)

  557.                                                         {

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

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

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

  561.                                                             var fmMsg = new

  562.                                                             {

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

  564.                                                                 topic = topic,

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

  566.                                                                 data = new

  567.                                                                 {

  568.                                                                     deviceId = device?.DeviceId,

  569.                                                                     imei = imeiDel,

  570.                                                                     alarmTypeId = 12,

  571.                                                                     alarmDeviceName = imeiDel,

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

  573.                                                                     address = string.Empty,

  574.                                                                     deviceKey = device?.DeviceId

  575.                                                                 }

  576.                                                             };

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

  578.                                                         }

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

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

  581. 

  582.                                                     }

  583.                                                     else

  584.                                                     {

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

  586.                                                     }

  587.                                                 }

  588.                                                 else

  589.                                                 {

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

  591. 

  592.                                                 }

  593.                                             }

  594.                                             else

  595.                                             {

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

  597.                                             }

  598.                                         }

  599. 

  600.                                         

  601.                                     }

  602.                                     #endregion

  603.                                 }

  604.                                 else

  605.                                 {

  606.                                     // 处理血压业务

  607.                                     int systolicInc;

  608.                                     int diastolicInc;

  609. 

  610.                                     int systolicRefValue;

  611.                                     int diastolicRefValue;

  612. 

  613.                                     decimal systolicAvg;

  614.                                     decimal diastolicAvg;

  615. 

  616.                                     int systolicMax = 0;

  617.                                     int diastolicMax = 0;

  618. 

  619.                                     // 统计时间

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

  621.                                     DateTime statStartTime = DateTime.Now;

  622. 

  623. 

  624.                                     // 最小值

  625.                                     int systolicMin = 0;

  626.                                     int diastolicMin = 0;

  627. 

  628.                                     // 偏移参数

  629.                                     var avgOffset = 0.25M;

  630.                                     var systolicAvgOffset = avgOffset;

  631.                                     var diastolicAvgOffset = avgOffset;

  632. 

  633.                                     // 最后一次下发值

  634.                                     int lastPushSystolicInc = 0;

  635.                                     int lastPushDiastolicInc = 0;

  636. 

  637. 

  638.                                     var startTime = DateTime.Now;

  639.                                     // 下发增量值

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

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

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

  643. 

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

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

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

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

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

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

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

  651.                                     //{

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

  653.                                     //    break;

  654.                                     //}

  655. 

  656.                                     // 7 天有效数据

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

  658.                                     {

  659.                                         // 计算增量值

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

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

  662.                                         if (lastPushResponse == null)

  663.                                         {

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

  665.                                             break;

  666.                                         }

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

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

  669.                                         // 有下推记录

  670.                                         if (lastPush != null)

  671.                                         {

  672.                                             systolicRefValue = lastPush!.SystolicRefValue;

  673.                                             diastolicRefValue = lastPush!.DiastolicRefValue;

  674.                                             lastPushSystolicInc = lastPush!.SystolicIncValue;

  675.                                             lastPushDiastolicInc = lastPush!.DiastolicIncValue;

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

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

  678.                                             $"and is_display = true";

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

  680.                                             statStartTime = lastPush!.Timestamp;

  681.                                         }

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

  683.                                         else

  684.                                         {

  685.                                             #region 获取个人信息

  686. 

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

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

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

  690.                                             {

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

  692.                                                 break;

  693.                                             }

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

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

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

  697.                                             {

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

  699.                                                 break;

  700.                                             }

  701. 

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

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

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

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

  706. 

  707.                                             #endregion

  708. 

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

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

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

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

  713.                                             #endregion

  714. 

  715.                                             systolicRefValue = bpRef!.Systolic;

  716.                                             diastolicRefValue = bpRef!.Diastolic;

  717.                                             lastPushSystolicInc = 0;

  718.                                             lastPushDiastolicInc = 0;

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

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

  721.                                             $"and is_display = true";

  722.                                         }

  723. 

  724. 

  725. 

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

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

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

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

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

  731.                                         if (hmBpParser!.Rows < 5)

  732.                                         {

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

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

  735.                                             break;

  736.                                         }

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

  738.                                         if (lastPush == null)

  739.                                         {

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

  741.                                             statStartTime = firstHmBp!.Timestamp;

  742.                                         }

  743. 

  744.                                         // NewMethod(systolicRefValue, hmBpParser);

  745. 

  746.                                         // 最大值

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

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

  749.                                         //// 最小值

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

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

  752. 

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

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

  755. 

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

  757.                                         systolicAvg = avgs[0];

  758.                                         diastolicAvg = avgs[1];

  759. 

  760. 

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

  762.                                         if (systolicAvg.Equals(0))

  763.                                         {

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

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

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

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

  768.                                             break;

  769.                                         }

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

  771.                                         if (systolicRefValue - systolicAvg < 4)

  772.                                         {

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

  774.                                             break;

  775.                                         }

  776. 

  777.                                         if (diastolicRefValue - diastolicAvg < 4)

  778.                                         {

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

  780.                                             break;

  781.                                         }

  782. 

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

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

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

  786. 

  787. 

  788.                                         // 累计增量

  789.                                         systolicInc = currentSystolicInc + lastPushSystolicInc;

  790.                                         diastolicInc = currentDiastolicInc + lastPushDiastolicInc;

  791. 

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

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

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

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

  796. 

  797. 

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

  799.                                         if (_configBoodPressResolver.EnableBPRefPush)

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

  801.                                         {

  802.                                             BloodPressCalibrationConfigModel bpIncData = new()

  803.                                             {

  804. 

  805.                                                 Imei = imeiDel,

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

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

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

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

  810.                                             };

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

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

  813.                                             var pushedBP = response.Flag;

  814.                                             if (pushedBP)

  815.                                             {

  816.                                                 #region 保存下推记录 stb_hm_bp_push_ref_inc_value

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

  818.                                                         $"USING health_monitor.stb_hm_bp_push_ref_inc_value " +

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

  820.                                                         $"VALUES(" +

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

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

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

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

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

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

  827.                                                             $"{false}," +

  828.                                                             $"{systolicAvg}," +

  829.                                                             $"{diastolicAvg}," +

  830.                                                             $"{systolicAvgOffset}," +

  831.                                                             $"{diastolicAvgOffset}," +

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

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

  834.                                                             $")";

  835.                                                 _serviceTDengine.ExecuteInsertSQL(sql);

  836.                                                 #endregion

  837. 

  838.                                                 #region 注册定时下发

  839.                                                 // 注册下次下推

  840.                                                 var endTime = DateTime.Now;

  841. 

  842. #if DEBUG

  843. 

  844. 

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

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

  847. 

  848.                                                 var interval = 0;

  849.                                                 // 获取当前时间

  850.                                                 DateTime now = DateTime.Now;

  851. 

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

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

  854.                                                 TimeSpan timeUntilNextRun = nextRunTime - now;

  855. 

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

  857.                                                 if (timeUntilNextRun < TimeSpan.Zero)

  858.                                                 {

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

  860.                                                     nextRunTime += timeUntilNextRun;

  861.                                                 }

  862. 

  863.                                                 // var ttl = timeUntilNextRun.TotalMilliseconds;

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

  865.                                                 var data = new

  866.                                                 {

  867.                                                     imei = imeiDel,

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

  869.                                                     ttl,

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

  871.                                                 };

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

  873. 

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

  875. 

  876. 

  877. #else

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

  879.                                         var interval = 1;

  880.                                         // 获取当前时间

  881.                                         DateTime now = DateTime.Now;

  882. 

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

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

  885.                                         TimeSpan timeUntilNextRun = nextRunTime - now;

  886. 

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

  888.                                         if (timeUntilNextRun < TimeSpan.Zero)

  889.                                         {

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

  891.                                             nextRunTime += timeUntilNextRun;

  892.                                         }

  893. 

  894.                                         // var ttl = timeUntilNextRun.TotalMilliseconds;

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

  896.                                         var data = new

  897.                                         {

  898.                                             imei = imeiDel,

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

  900.                                             ttl,

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

  902.                                         };

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

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

  905. #endif

  906.                                                 #endregion

  907. 

  908.                                             }

  909.                                             else

  910.                                             {

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

  912.                                             }

  913.                                         }

  914.                                     }

  915.                                     else

  916.                                     {

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

  918.                                     }

  919.                                     #endregion

  920. 

  921.                                 }

  922. 

  923.                             }

  924.                             break;

  925.                     }

  926.                 }

  927.                 catch (Exception ex)

  928.                 {

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

  930.                 }

  931. 

  932. 

  933.             });

  934. 

  935.         }

  936. 

  937. 

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

  939. 

  940.         {

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

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

  943.             if (string.IsNullOrWhiteSpace(schedulePush))

  944.             {

  945.                 var now = DateTime.Now;

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

  947.                 var data = new

  948.                 {

  949.                     imei,

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

  951.                     ttl = interval,

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

  953.                 };

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

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

  956.             }

  957.         }

  958. 

  959.         public static bool IsNowInTimeRanges()

  960.         {

  961.             var now = DateTime.Now.TimeOfDay;

  962. 

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

  964.             {

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

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

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

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

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

  970.             };

  971. 

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

  973.         }

  974.         public static bool IsLastUpdateInTimeRanges(DateTime lastUpdate)

  975.         {

  976.             var now = lastUpdate.TimeOfDay;

  977. 

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

  979.             {

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

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

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

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

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

  985.             };

  986. 

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

  988.         }

  989. 

  990. 

  991.     }

  992. }