J1147
/
HealthMonitor
Beobachten 1
Favorisieren 0
Fork 0
Code Issues 0 Pull-Requests 0 Releases 0 Wiki Aktivität
Du kannst nicht mehr als 25 Themen auswählen Themen müssen entweder mit einem Buchstaben oder einer Ziffer beginnen. Sie können Bindestriche („-“) enthalten und bis zu 35 Zeichen lang sein.
159 Commits
8 Branches
14MB
Struktur: f58ea36ba2
Branches Tags
${ item.name }
Erstelle Branch ${ searchTerm }
von „f58ea36ba2“
${ noResults }
HealthMonitor/HealthMonitor.Service/Resolver/PregnancyHeartRateResolver.cs

1027 Zeilen
61KB
Originalformat Blame Verlauf 

  1. using Etcdserverpb;

  2. using HealthMonitor.Common;

  3. using HealthMonitor.Common.helper;

  4. using HealthMonitor.Model.Service.Mapper;

  5. using HealthMonitor.Service.Biz;

  6. using HealthMonitor.Service.Biz.db;

  7. using HealthMonitor.Service.Cache;

  8. using HealthMonitor.Service.Etcd;

  9. using HealthMonitor.Service.MessageQueue;

  10. using HealthMonitor.Service.Resolver.Interface;

  11. using HealthMonitor.Service.Sub;

  12. using HealthMonitor.Service.Sub.Topic.Model;

  13. using Microsoft.EntityFrameworkCore.Metadata;

  14. using Microsoft.Extensions.Logging;

  15. using Newtonsoft.Json;

  16. using Newtonsoft.Json.Linq;

  17. using SqlSugar;

  18. using System;

  19. using System.Collections.Generic;

  20. using System.Linq;

  21. using System.Net;

  22. using System.Text;

  23. using System.Threading.Tasks;

  24. using TelpoDataService.Util.Clients;

  25. using TelpoDataService.Util.Entities.GpsCard;

  26. using TelpoDataService.Util.Entities.GpsLocationHistory;

  27. using TelpoDataService.Util.Models;

  28. using TelpoDataService.Util.QueryObjects;

  29. 

  30. namespace HealthMonitor.Service.Resolver

  31. {

  32.     public class PregnancyHeartRateResolver : IResolver

  33.     {

  34.         private readonly ILogger<PregnancyHeartRateResolver> _logger;

  35.         private readonly TDengineService _serviceTDengine;

  36. 

  37.         private readonly DeviceCacheManager _deviceCacheMgr;

  38.         private readonly IotApiService _serviceIotApi;

  39. 

  40. 

  41.         private readonly AsyncLocal<string> _messageId = new();

  42.         private readonly AsyncLocal<HisGpsHeartRate> _msgData = new();

  43.         private readonly HttpHelper _httpHelper = default!;

  44.         private readonly EtcdService _serviceEtcd;

  45. 

  46.         private readonly GpsLocationHistoryAccessorClient<HisGpsFetalHeartRate> _hisFetalHeartApiClient;

  47.         private readonly GpsLocationHistoryAccessorClient<HisGpsFetalMovement> _hisFetalMovementApiClient;

  48. 

  49.         private readonly FetalMovementNormalValueRangeCacheManager _mgrFetalMovementNormalValueRangeCache;

  50. 

  51.         private readonly MqProcessLogic _serviceMqProcess;

  52. 

  53. 

  54. 

  55. 

  56.         public PregnancyHeartRateResolver(ILogger<PregnancyHeartRateResolver> logger, 

  57.             HttpHelper httpHelper, EtcdService serviceEtcd, DeviceCacheManager deviceCacheMgr,

  58.             MqProcessLogic serviceMqProcess,

  59.             IotApiService iotApiService, TDengineService serviceDengine, FetalMovementNormalValueRangeCacheManager fetalMovementNormalValueRangeCacheMgr,

  60.             GpsLocationHistoryAccessorClient<HisGpsFetalHeartRate> hisFetalHeartApiClient,

  61.             GpsLocationHistoryAccessorClient<HisGpsFetalMovement> hisFetalMovementApiClient

  62.             )

  63.         { 

  64.             _logger = logger;

  65.             _httpHelper = httpHelper;

  66.             _serviceEtcd = serviceEtcd;

  67.             _serviceTDengine = serviceDengine;  

  68.             _deviceCacheMgr = deviceCacheMgr;

  69.             _serviceIotApi = iotApiService;

  70.             _serviceMqProcess=  serviceMqProcess;

  71.             _hisFetalHeartApiClient = hisFetalHeartApiClient;

  72.             _hisFetalMovementApiClient = hisFetalMovementApiClient;

  73.             _mgrFetalMovementNormalValueRangeCache = fetalMovementNormalValueRangeCacheMgr;

  74.         }

  75. 

  76.         public void SetResolveInfo(PackageMsgModel msg)

  77.         {

  78.             var topicHmPregnancyHeartRate = JsonConvert.DeserializeObject<TopicHmPregnancyHeartRate>(msg.DetailData.ToString()!);

  79.             _messageId.Value = msg.MessageId;

  80.             _msgData.Value = new HisGpsHeartRate()

  81.             {

  82.                 HeartRateId = topicHmPregnancyHeartRate!.PregnancyHeartRateId,

  83.                 MessageId = topicHmPregnancyHeartRate!.MessageId,

  84.                 Serialno = topicHmPregnancyHeartRate!.Serialno,

  85.                 HeartRate= topicHmPregnancyHeartRate.PregnancyHeartRate,

  86.                 LastUpdate = DateTimeUtil.GetDateTimeFromUnixTimeMilliseconds(SafeType.SafeInt64(topicHmPregnancyHeartRate.LastUpdate) / 1000000),

  87.                 CreateTime = DateTimeUtil.GetDateTimeFromUnixTimeMilliseconds(SafeType.SafeInt64(topicHmPregnancyHeartRate.CreateTime) / 1000000),

  88.                 Method = topicHmPregnancyHeartRate!.Method,

  89.                 IsDisplay = topicHmPregnancyHeartRate!.IsDisplay ? 1 : 0

  90.             };

  91.         }

  92.         public override string ToString()

  93.         {

  94.             return $"{nameof(PregnancyHeartRateResolver)}[{_messageId.Value}]";

  95.         }

  96. 

  97.         public async Task ExecuteMessageAsync()

  98.         {

  99.             var messageId = _messageId.Value;

  100.             var heartRate = _msgData.Value!;

  101. 

  102.             var watchConfig = await _deviceCacheMgr.GetGpsDeviceWatchConfigCacheObjectBySerialNoAsync(heartRate.Serialno, "0067");

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

  104. 

  105.             if (isFetalHeartEnable)

  106.             {

  107.                 // 高频心率采样间隔

  108.                 var highFreqSampleInterval = (int)watchConfig!["highFreqSampleInterval"]!;

  109.                 // 触发高频监测的心率上限值

  110.                 var triggerHighFreqHigh = (int)watchConfig["triggerHighFreqHigh"]!;

  111.                 // 触发高频监测的心率下限值

  112.                 var triggerHighFreqLow = (int)watchConfig["triggerHighFreqLow"]!;

  113.                 //停止高频心率采样心率连续正常次数

  114.                 var stopHighFreqSampleCount = (int)watchConfig["stopHighFreqSampleCount"]!;

  115.                 // 高频心率采集时长 0 为持续采集，非零为高频心率的采集时长

  116.                 var highFreqSampleTimes = (int)watchConfig["stopHighFreqSampleCount"]!;

  117.                 // 告警上限阀值

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

  119.                 // 告警下限阀值

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

  121.                 // EDOC

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

  123.                 // interval (分钟)

  124.                 var intervalFHR= (int)watchConfig["interval"]!;

  125. 

  126.                 var fetalHeartRateIsAbnormal = 0;

  127. 

  128.                 var phr = await _serviceTDengine.GetBySerialNoAsync<PregnancyHeartRateModel>(heartRate.Serialno, 7);

  129.                 if (phr.Count >= 30)

  130.                 {

  131.                     /**

  132.                     var commonPHR = await _serviceTDengine.GetLastAsync<PregnancyCommonHeartRateModel>(heartRate.Serialno);

  133.                     if (commonPHR != null)

  134.                     {

  135.                         var lastUpdateNow = (DateTime)heartRate.LastUpdate!;

  136.                         var midNight = new DateTime(lastUpdateNow.Year, lastUpdateNow.Month, lastUpdateNow.Day, 0, 0, 0);

  137.                         #region 计算胎心数据

  138.                         _logger.LogInformation($"{heartRate.Serialno} 计算胎心数据 ");

  139. 

  140.                         var fhrNow = lastUpdateNow;

  141. 

  142.                         TimeSpan fhrTS = fhrNow - midNight;

  143.                         // 当天每隔intervalFHR 分钟的段数，取整数部分

  144.                         int segmentCountFHR = (int)(fhrTS.TotalMinutes / intervalFHR);

  145.                         for (int i = 0; i < segmentCountFHR; i++) 

  146.                         {

  147.                             // 每intervalFHR * i分钟

  148.                             var fhrSampleTime = DateTimeUtil.ConvertToTimeStamp(midNight.AddMinutes(intervalFHR * i)).ToString()[..10];

  149. 

  150.                             // 统计开始时间

  151.                             var statStartTimeFHR = midNight.AddMinutes(intervalFHR * i);

  152.                             // 统计结束时间

  153.                             var statEndTimeFHR = midNight.AddMinutes(intervalFHR * (i + 1));

  154. 

  155.                             var isFHRExisted =await _mgrFetalHeartRateCache.FetalHeartRateIsExistedAsync(heartRate.Serialno, fhrSampleTime);

  156.                             

  157.                             _logger.LogInformation($"{heartRate.Serialno} 胎心数据采样时间:{fhrSampleTime}|{midNight.AddMinutes(intervalFHR * i).ToString("yyyy-MM-dd HH:mm:ss")}, 采样周期:{statStartTimeFHR}-{statEndTimeFHR},isFHRExisted:{isFHRExisted} ");

  158. 

  159.                             if (!isFHRExisted)

  160.                             {

  161.                                 // 开始计算 ,每intervalFHR分钟计算一个

  162.                                 var phrRange = phr.Where(i => i.LastUpdate >= statStartTimeFHR && i.LastUpdate <= statEndTimeFHR)

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

  164.                                 .ToList();

  165. 

  166.                                 // 胎心数据每intervalFHR分钟计算1个值，采集的数据多于1个取平均值再*胎心系数。

  167.                                 var phrValue = phrRange.Count == 1

  168.                                         ? phrRange.First().PregnancyHeartRate

  169.                                         : phrRange.Average(i => i.PregnancyHeartRate);

  170.                                 // 当天的系数,没有的就实时计算

  171.                                 var fprCoefficient = 0f;

  172. 

  173.                                 //if (commonPHR.CreateTime.Year == lastUpdateNow.Year &&

  174.                                 //    commonPHR.CreateTime.Month == lastUpdateNow.Month &&

  175.                                 //    commonPHR.CreateTime.Day == lastUpdateNow.Day

  176.                                 //    )

  177.                                 //{

  178.                                 //    fprCoefficient = (float)commonPHR?.StatModeAvgFprCoefficient!;

  179.                                 //}

  180.                                 //else

  181.                                 //{

  182.                                 //    //var daysDiff = 7 - (DateTime.Now.Day - lastUpdateNow.Day);

  183.                                 //    //var realtimePCHR = await _serviceTDengine.InitPregnancyCommonHeartRateModeAsync(heartRate.Serialno, daysDiff);

  184.                                 //    //fprCoefficient = realtimePCHR!.StatModeAvgFprCoefficient;

  185.                                 //    var pchr = await _serviceTDengine.GetBySerialNoAsync<PregnancyCommonHeartRateModel>(heartRate.Serialno);

  186.                                 //    var dayPCHR = pchr.Where(i => i.CreateTime.Year == lastUpdateNow.Year && i.CreateTime.Month == lastUpdateNow.Month && i.CreateTime.Day == i.CreateTime.Day);

  187.                                 //    fprCoefficient=dayPCHR.First().StatModeAvgFprCoefficient;

  188.                                 //}

  189. 

  190.                                 fprCoefficient = (float)commonPHR?.StatModeAvgFprCoefficient!;

  191. 

  192.                                 var fetalHeartRate = SafeType.SafeInt(phrValue * fprCoefficient);

  193. 

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

  195.                                 fetalHeartRateIsAbnormal = 0;// 不是高频数据,按正常值

  196.                                 HisGpsFetalHeartRate gpsFetalHeartRate = new()

  197.                                 {

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

  199.                                     PersonId = commonPHR!.PersonId,

  200.                                     Serialno = heartRate.Serialno,

  201.                                     HeartRate = fetalHeartRate,

  202.                                     SampleTime = fhrSampleTime.Length > 10 ? fhrSampleTime.Substring(0, 10) : fhrSampleTime,

  203.                                     IsAbnormal = fetalHeartRateIsAbnormal,

  204.                                     StatStartTime = phrRange.OrderBy(i => i.LastUpdate).First().LastUpdate,

  205.                                     StatEndTime = phrRange.OrderBy(i => i.LastUpdate).Last().LastUpdate,

  206.                                     CreateTime = DateTime.Now,

  207.                                     Method = 1,

  208.                                     IsDisplay = 1,

  209.                                     DeviceKey = commonPHR!.DeviceKey

  210.                                 };

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

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

  213. 

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

  215.                                 await _serviceIotApi.SetFetalHeartRateConfig(heartRate.Serialno, fetalHeartRate, fhrSampleTime, fetalHeartRateIsAbnormal);

  216. 

  217.                                 // 推送到微信

  218. 

  219. 

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

  221.                                 await  _mgrFetalHeartRateCache.SetFetalHeartRateAsync(heartRate.Serialno, fhrSampleTime);

  222.                             }

  223.                         }

  224. 

  225.                         #endregion

  226. 

  227.                         #region 计算胎动数据

  228.                         _logger.LogInformation($"{heartRate.Serialno} 计算胎动数据 ");

  229. 

  230.                         var fmNow = lastUpdateNow;

  231. 

  232.                         TimeSpan fmTS = fmNow - midNight;

  233. 

  234.                         // 当天每隔2小时的段数，取整数部分

  235.                         int segmentCountFM = (int)(fmTS.TotalHours / 2);

  236. 

  237.                         for (int i = 0; i < segmentCountFM; i++)

  238.                         {

  239.                             // 每两小时

  240.                             var fetalMovementSampleTime = DateTimeUtil.ConvertToTimeStamp(midNight.AddHours(2 * i)).ToString()[..10];

  241. 

  242.                             // 统计开始时间

  243.                             var statStartTime = midNight.AddHours(2 * i);

  244.                             // 统计结束时间

  245.                             var statEndTime = midNight.AddHours(2 * (i + 1));

  246. 

  247.                             //var isFetalMovementExist = await _hisFetalMovementApiClient.GetFirstAsync(param, heartRate.Serialno[^2..], null, new RequestHeader { RequestId = Guid.NewGuid().ToString("D") });

  248.                             var isFetalMovementExisted = await _mgrFetalMovement.FetalMovementIsExistedAsync(heartRate.Serialno, fetalMovementSampleTime);

  249. 

  250.                             if (!isFetalMovementExisted)

  251.                             {

  252.                                 /// 开始计算

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

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

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

  256.                                 .ToList();

  257. 

  258.                                 if (phrRange.Count >= 2)

  259.                                 {

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

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

  262.                                     bool isInTimeRanges = IsLastUpdateInTimeRanges(fmNow);

  263. 

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

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

  266.                                     {

  267.                                         var fetalMovementMap = _mgrFetalMovementNormalValueRangeCache.GetFetalMovements();

  268. 

  269.                                         var fetalMovementMapValue = isInTimeRanges ? fetalMovementMap

  270.                                                 .Where(i =>

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

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

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

  274.                                                 .FirstOrDefault()

  275.                                                 :

  276.                                                 fetalMovementMap

  277.                                                 .Where(i =>

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

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

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

  281.                                                 .FirstOrDefault()

  282.                                         ;

  283. 

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

  285. 

  286. 

  287.                                         // 四舍五入

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

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

  290. 

  291.                                         _logger.LogInformation($"{heartRate.Serialno} 胎动数据采样时间:{fetalMovementSampleTime}|{midNight.AddHours(2 * i).ToString("yyyy-MM-dd HH:mm:ss")}, 采样周期:{statStartTime}-{statEndTime}, 原始胎动值:{fetalMovementMapValue}, 佩戴时间 :{duringMins}|{statStartTime}-{phrRange.First()}, 胎动计算值:{fetalMovementValue}, 胎动最终值:{fetalMovement}");

  292. 

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

  294.                                         //var feltalMovementIsAbnormal = fetalHeartRateIsAbnormal;

  295.                                         var feltalMovementIsAbnormal = 0;

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

  297. 

  298.                                         await _serviceIotApi.SetFetalMovementConfig(heartRate.Serialno, fetalMovement, fetalMovementSampleTime, feltalMovementIsAbnormal);

  299. 

  300.                                         // 保存到MySQL数据库

  301.                                         HisGpsFetalMovement fm = new()

  302.                                         {

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

  304.                                             PersonId = commonPHR!.PersonId,

  305.                                             Serialno = heartRate.Serialno,

  306.                                             CreateTime = DateTime.Now,

  307.                                             IsAbnormal = feltalMovementIsAbnormal,

  308.                                             FetalMovementValue = fetalMovement,

  309.                                             SampleTime = fetalMovementSampleTime,

  310.                                             Method = 1,

  311.                                             IsDisplay = 1,

  312.                                             DeviceKey = commonPHR!.DeviceKey

  313.                                         };

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

  315. 

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

  317.                                         await _mgrFetalMovement.SetFetalMovementAsync(heartRate.Serialno, fetalMovementSampleTime);

  318.                                     }

  319.                                 }

  320.                             }

  321. 

  322.                         }

  323.                         #endregion

  324.                     }

  325.                     */

  326.                    

  327.                     

  328.                     #region 高频心率计算

  329.                     

  330.                     //// 获取最近的两个记录，并计算它们的 LastUpdate 时间差

  331.                     //var firstTwoPhr = phr.OrderByDescending(i => i.LastUpdate).Take(2).Select(i => i.LastUpdate).ToList();

  332.                     //var timeDiff = firstTwoPhr[0] - firstTwoPhr[1];

  333. 

  334.                     //// 如果需要，将时间差转换为秒

  335.                     //var timeDiffInSeconds = timeDiff.TotalSeconds;

  336. 

  337.                     //// 高频心率启动

  338.                     //if (timeDiffInSeconds<=highFreqSampleInterval)

  339.                     //{

  340.                        

  341.                     //    var phrFreqstatus =await _deviceCacheMgr.GetPregnancyHeartRateFreqStatusAsync(heartRate.Serialno);

  342.                     //    if (phrFreqstatus == null)

  343.                     //    {

  344.                     //        /// 设置高频状态

  345.                     //        _logger.LogInformation($"进入高频心率启动状态 timeDiffInSeconds {timeDiffInSeconds},highFreqSampleInterval:{highFreqSampleInterval}");

  346.                     //        // 设置高频状态

  347.                     //        var freqFirstPhr= phr.OrderByDescending(i => i.Timestamp).First();

  348.                     //        await _deviceCacheMgr.SetPregnancyHeartRateFreqStatusAsync(heartRate.Serialno, freqFirstPhr);

  349.                     //        phrFreqstatus = await _deviceCacheMgr.GetPregnancyHeartRateFreqStatusAsync(heartRate.Serialno);

  350.                     //    }

  351.                     //    /// phr  PregnancyHeartRate 连续连续正常次数个值都是正常(大于等于triggerHighFreqLow，少于等于triggerHighFreqHig),

  352.                     //    /// 取连续正常次数正常值的平均值,推送到api/v1/open/OpenIot/SetFetalHeartRateConfig

  353.                     //    #region 检查是否连续12个值都是正常的

  354.                     //    // 获取最近连续正常次数个心率记录

  355.                     //    var lastPhr = phr.OrderByDescending(i => i.Timestamp).Take(stopHighFreqSampleCount).ToList();

  356. 

  357.                     //    // 检查是否连续12个值都是正常的

  358.                     //    if (lastPhr.All(i => i.PregnancyHeartRate >= triggerHighFreqLow && i.PregnancyHeartRate <= triggerHighFreqHigh))

  359.                     //    {

  360.                     //        var avgPhr = lastPhr.Select(i => i.PregnancyHeartRate).Average();

  361.                     //        // 计算一般心率得到胎心系数

  362.                     //        await SaveAndPushFetalHeartRateAsync(heartRate, upperAlarmThreshold, lowerAlarmThreshold, avgPhr);

  363. 

  364.                     //    }

  365.                     //    #endregion

  366.                     //}

  367.                     //// 高频心率结束

  368.                     //else

  369.                     //{

  370.                     //    var phrFreqstatus = await _deviceCacheMgr.GetPregnancyHeartRateFreqStatusAsync(heartRate.Serialno);

  371.                     //    if (phrFreqstatus != null)

  372.                     //    {

  373.                     //        /// 在highFreqSampleTimes=0一直异常(大于等于triggerHighFreqLow，少于等于triggerHighFreqHig),

  374.                     //        /// 取所有值的平均值，推送胎心数据到api/v1/open/OpenIot/SetFetalHeartRateConfig

  375.                     //        if (highFreqSampleTimes==0)

  376.                     //        {

  377.                     //            // if (phr.OrderByDescending(i => i.Timestamp)

  378.                     //            //.Where(i => i.Timestamp >= phrFreqstatus?.Timestamp)

  379.                     //            //.Skip(1) // 去除首条

  380.                     //            //.All(i => i.PregnancyHeartRate < triggerHighFreqLow || i.PregnancyHeartRate > triggerHighFreqHig))

  381.                     //            // {

  382.                     //            //     var avgPhr = phr.Select(i => i.PregnancyHeartRate).Average();

  383. 

  384.                     //            //     // 推送胎心数据到 api/v1/open/OpenIot/SetFetalHeartRateConfig

  385.                     //            //     // 计算一般心率得到胎心系数

  386.                     //            // }

  387. 

  388.                     //            var avgPhr = phr.OrderByDescending(i => i.Timestamp)

  389.                     //                   .Where(i => i.Timestamp >= phrFreqstatus?.Timestamp)

  390.                     //                   .Skip(1) // 去除首条

  391.                     //                   .Where(i => i.PregnancyHeartRate < triggerHighFreqLow || i.PregnancyHeartRate > triggerHighFreqHigh)

  392.                     //                   .Select(i => i.PregnancyHeartRate).Average();

  393.                     //            // 推送胎心数据到 api/v1/open/OpenIot/SetFetalHeartRateConfig

  394.                     //            // 计算一般心率得到胎心系数

  395.                     //            await SaveAndPushFetalHeartRateAsync(heartRate, upperAlarmThreshold, lowerAlarmThreshold, avgPhr);

  396. 

  397.                     //        }

  398. 

  399.                     //        /// 在highFreqSampleTimes>0一直异常(大于等于triggerHighFreqLow，少于等于triggerHighFreqHig),

  400.                     //        /// 取所有值的平均值，推送胎心数据到api/v1/open/OpenIot/SetFetalHeartRateConfig

  401.                     //        if (highFreqSampleTimes > 0 && heartRate.LastUpdate >= (phrFreqstatus?.LastUpdate + TimeSpan.FromSeconds(highFreqSampleTimes)))

  402.                     //        {

  403. 

  404.                     //            var avgPhr = phr

  405.                     //                  .Where(i => i.Timestamp >= phrFreqstatus?.Timestamp)

  406.                     //                  .Skip(1) // 去除首条

  407.                     //                  .Where(i => i.PregnancyHeartRate < triggerHighFreqLow || i.PregnancyHeartRate > triggerHighFreqHigh)

  408.                     //                  .Select(i => i.PregnancyHeartRate).Average();

  409.                     //            // 推送胎心数据到 api/v1/open/OpenIot/SetFetalHeartRateConfig

  410.                     //            // 计算一般心率得到胎心系数

  411.                     //            await SaveAndPushFetalHeartRateAsync(heartRate, upperAlarmThreshold, lowerAlarmThreshold, avgPhr);

  412.                     //        }

  413. 

  414.                     //        // 删除高频状态的首条记录

  415.                     //        await _deviceCacheMgr.DelPregnancyHeartRateFreqStatusAsync(heartRate.Serialno);

  416. 

  417.                     //        /// 设置高频状态

  418.                     //        _logger.LogInformation($"结束高频心率状态 timeDiffInSeconds {timeDiffInSeconds},highFreqSampleInterval:{highFreqSampleInterval}");

  419.                     //    }

  420.                     //}

  421.                     

  422.                     #endregion

  423. 

  424.                     #region 计算胎心和胎动数据

  425.                     var commonPHR = await _serviceTDengine.GetLastAsync<PregnancyCommonHeartRateModel>(heartRate.Serialno);

  426.                     if (commonPHR != null)

  427.                     {

  428. 

  429.                         #region 计算胎心数据

  430. 

  431.                         // 获取最近的两个记录，并计算它们的 LastUpdate 时间差

  432.                         var firstTwoPhr = phr.OrderByDescending(i => i.LastUpdate).Take(2).Select(i => i.LastUpdate).ToList();

  433.                         var timeDiff = firstTwoPhr[0] - firstTwoPhr[1];

  434. 

  435.                         // 如果需要，将时间差转换为秒

  436.                         var timeDiffInSeconds = timeDiff.TotalSeconds;

  437. 

  438.                         // 高频心率启动

  439.                         if (timeDiffInSeconds <= highFreqSampleInterval)

  440.                         {

  441. 

  442.                             var phrFreqstatus = await _deviceCacheMgr.GetPregnancyHeartRateFreqStatusAsync(heartRate.Serialno);

  443.                             if (phrFreqstatus == null)

  444.                             {

  445.                                 /// 设置高频状态

  446.                                 _logger.LogInformation($"进入高频心率启动状态 timeDiffInSeconds {timeDiffInSeconds},highFreqSampleInterval:{highFreqSampleInterval}");

  447.                                 // 设置高频状态

  448.                                 var freqFirstPhr = phr.OrderByDescending(i => i.Timestamp).First();

  449.                                 await _deviceCacheMgr.SetPregnancyHeartRateFreqStatusAsync(heartRate.Serialno, freqFirstPhr);

  450.                                 //phrFreqstatus = await _deviceCacheMgr.GetPregnancyHeartRateFreqStatusAsync(heartRate.Serialno);

  451.                             }

  452.                             /// phr  PregnancyHeartRate 连续连续正常次数个值都是正常(大于等于triggerHighFreqLow，少于等于triggerHighFreqHig),

  453.                             /// 取连续正常次数正常值的平均值,推送到api/v1/open/OpenIot/SetFetalHeartRateConfig

  454.                             #region 检查是否连续12个值都是正常的

  455.                             // 获取最近连续正常次数个心率记录

  456.                             var lastPhr = phr.OrderByDescending(i => i.Timestamp).Take(stopHighFreqSampleCount).ToList();

  457. 

  458.                             // 检查是否连续12个值都是正常的

  459.                             if (lastPhr.All(i => i.PregnancyHeartRate >= triggerHighFreqLow && i.PregnancyHeartRate <= triggerHighFreqHigh))

  460.                             {

  461.                                 var avgPhr = lastPhr.Select(i => i.PregnancyHeartRate).Average();

  462.                                 // 计算一般心率得到胎心系数

  463.                                 await SaveAndPushFreqFetalHeartRateAsync(heartRate, upperAlarmThreshold, lowerAlarmThreshold, avgPhr, DateTimeUtil.ConvertToTimeStamp(DateTime.Now).ToString());

  464. 

  465.                             }

  466.                             #endregion

  467.                         }

  468.                         // 高频心率结束或正常心率

  469.                         else

  470.                         {

  471.                             var phrFreqstatus = await _deviceCacheMgr.GetPregnancyHeartRateFreqStatusAsync(heartRate.Serialno);

  472.                             if (phrFreqstatus != null)

  473.                             {

  474.                                 /// 在highFreqSampleTimes=0一直异常(大于等于triggerHighFreqLow，少于等于triggerHighFreqHig),

  475.                                 /// 取所有值的平均值，推送胎心数据到api/v1/open/OpenIot/SetFetalHeartRateConfig

  476.                                 if (highFreqSampleTimes == 0)

  477.                                 {

  478.                                     var avgPhr = phr.OrderByDescending(i => i.Timestamp)

  479.                                            .Where(i => i.Timestamp >= phrFreqstatus?.Timestamp)

  480.                                            .Skip(1) // 去除首条

  481.                                            .Where(i => i.PregnancyHeartRate < triggerHighFreqLow || i.PregnancyHeartRate > triggerHighFreqHigh)

  482.                                            .Select(i => i.PregnancyHeartRate).Average();

  483.                                     // 推送胎心数据到 api/v1/open/OpenIot/SetFetalHeartRateConfig

  484.                                     // 计算一般心率得到胎心系数

  485.                                     //await SaveAndPushFetalHeartRateAsync(heartRate, upperAlarmThreshold, lowerAlarmThreshold, avgPhr);

  486.                                     await SaveAndPushFreqFetalHeartRateAsync(heartRate, upperAlarmThreshold, lowerAlarmThreshold, avgPhr, DateTimeUtil.ConvertToTimeStamp(DateTime.Now).ToString());

  487. 

  488.                                 }

  489. 

  490.                                 /// 在highFreqSampleTimes>0一直异常(大于等于triggerHighFreqLow，少于等于triggerHighFreqHig),

  491.                                 /// 取所有值的平均值，推送胎心数据到api/v1/open/OpenIot/SetFetalHeartRateConfig

  492.                                 if (highFreqSampleTimes > 0 && heartRate.LastUpdate >= (phrFreqstatus?.LastUpdate + TimeSpan.FromSeconds(highFreqSampleTimes)))

  493.                                 {

  494. 

  495.                                     var avgPhr = phr

  496.                                           .Where(i => i.Timestamp >= phrFreqstatus?.Timestamp)

  497.                                           .Skip(1) // 去除首条

  498.                                           .Where(i => i.PregnancyHeartRate < triggerHighFreqLow || i.PregnancyHeartRate > triggerHighFreqHigh)

  499.                                           .Select(i => i.PregnancyHeartRate).Average();

  500.                                     // 推送胎心数据到 api/v1/open/OpenIot/SetFetalHeartRateConfig

  501.                                     // 计算一般心率得到胎心系数

  502.                                     //await SaveAndPushFetalHeartRateAsync(heartRate, upperAlarmThreshold, lowerAlarmThreshold, avgPhr);

  503.                                     await SaveAndPushFreqFetalHeartRateAsync(heartRate, upperAlarmThreshold, lowerAlarmThreshold, avgPhr, DateTimeUtil.ConvertToTimeStamp(DateTime.Now).ToString());

  504. 

  505.                                 }

  506. 

  507.                                 // 删除高频状态的首条记录

  508.                                 await _deviceCacheMgr.DelPregnancyHeartRateFreqStatusAsync(heartRate.Serialno);

  509. 

  510.                                 /// 设置高频状态

  511.                                 _logger.LogInformation($"结束高频心率状态 timeDiffInSeconds {timeDiffInSeconds},highFreqSampleInterval:{highFreqSampleInterval}");

  512.                             }

  513.                             // 正常心率

  514.                             else

  515.                             {

  516.                                

  517.                                 // 上15分钟的数据

  518.                                 // 获取当前时间

  519.                                 DateTime nowInterval = (DateTime)heartRate.LastUpdate!;

  520. 

  521.                                 // 计算last_update到上一刻钟的分钟数

  522.                                 int minutesToSubtract = nowInterval.Minute % intervalFHR;

  523. 

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

  525.                                 DateTime previousInterval = nowInterval.AddMinutes(-minutesToSubtract).AddSeconds(-nowInterval.Second).AddMilliseconds(-nowInterval.Millisecond);

  526. 

  527.                                 // 使用 last_update 上一刻

  528.                                 var sampleTimeFHR = DateTimeUtil.ConvertToTimeStamp(previousInterval).ToString();

  529. 

  530.                                 // 计算last_update到下一刻钟的分钟数

  531.                                 int minutesToAdd = intervalFHR - (nowInterval.Minute % intervalFHR);

  532.                                 if (minutesToAdd == intervalFHR)

  533.                                 {

  534.                                     minutesToAdd = 0; // 如果已经是刻钟，则不需要增加分钟

  535.                                 }

  536. 

  537.                                 // 计算下一刻钟的时间

  538.                                 DateTime nextInterval = nowInterval.AddMinutes(minutesToAdd)

  539.                                                                 .AddSeconds(-nowInterval.Second)

  540.                                                                 .AddMilliseconds(-nowInterval.Millisecond);

  541. 

  542. 

  543.                                 var daysPhr = await _serviceTDengine.GetBySerialNoAsync<PregnancyHeartRateModel>(heartRate.Serialno, 7);

  544. 

  545.                                 var normalPhrStatStartTime = nextInterval;

  546. 

  547.                                 var normalPhrStatEndTime = nextInterval.AddMinutes(-intervalFHR);

  548. 

  549.                                 _logger.LogInformation($"{heartRate.Serialno} 计算胎心数据, 周期:{normalPhrStatStartTime}-{normalPhrStatEndTime} ");

  550.                                 var filteredPhr = daysPhr

  551.                                     // 使用 last_update 下一刻

  552.                                     .Where(i => i.LastUpdate <= normalPhrStatStartTime && i.LastUpdate >= normalPhrStatEndTime)

  553.                                     .ToList();

  554.                                 if (filteredPhr.Count == 0)

  555.                                 {

  556.                                     _logger.LogWarning($"{heartRate.Serialno}  周期:{normalPhrStatStartTime}-{normalPhrStatEndTime} 孕妇心率数据不足,{filteredPhr.Count}条记录");

  557.                                     return;

  558.                                 }

  559.                                 var phrValue = filteredPhr.Count == 1

  560.                                     ? filteredPhr.First().PregnancyHeartRate

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

  562. 

  563.                                 var fetalHeartRate = SafeType.SafeInt(phrValue * commonPHR?.StatModeAvgFprCoefficient!);

  564. 

  565. 

  566.                                 fetalHeartRateIsAbnormal = fetalHeartRate > upperAlarmThreshold ? 1 : (fetalHeartRate < lowerAlarmThreshold ? 2 : 0);

  567.                                 fetalHeartRateIsAbnormal = 0;// 不是高频数据,按正常值

  568.                                 HisGpsFetalHeartRate gpsFetalHeartRate = new()

  569.                                 {

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

  571.                                     PersonId = commonPHR!.PersonId,

  572.                                     Serialno = heartRate.Serialno,

  573.                                     HeartRate = fetalHeartRate,

  574.                                     SampleTime = sampleTimeFHR.Length > 10 ? sampleTimeFHR.Substring(0, 10) : sampleTimeFHR,

  575.                                     IsAbnormal = fetalHeartRateIsAbnormal,

  576.                                     StatStartTime = filteredPhr.OrderBy(i => i.LastUpdate).First().LastUpdate,

  577.                                     StatEndTime = filteredPhr.OrderBy(i => i.LastUpdate).Last().LastUpdate,

  578.                                     CreateTime = DateTime.Now,

  579.                                     Method = 1,

  580.                                     IsDisplay = 1,

  581.                                     DeviceKey = commonPHR!.DeviceKey

  582.                                 };

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

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

  585. 

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

  587.                                 await _serviceIotApi.SetFetalHeartRateConfig(heartRate.Serialno, fetalHeartRate, sampleTimeFHR, fetalHeartRateIsAbnormal);

  588. 

  589.                                 // 推送送微信

  590.                                 if (fetalHeartRateIsAbnormal!=0)

  591.                                 {

  592.                                     var device = await _deviceCacheMgr.GetDeviceBySerialNoAsync(heartRate.Serialno).ConfigureAwait(false);

  593.                                     var fhrMsgId = $"{heartRate.Serialno}-{sampleTimeFHR}-{Guid.NewGuid().ToString("D")[^3..]}";

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

  595.                                     var fhrMsg = new

  596.                                     {

  597.                                         messageId = fhrMsgId,

  598.                                         topic = topic,

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

  600.                                         data = new

  601.                                         {

  602.                                             deviceId = device?.DeviceId,

  603.                                             imei = heartRate.Serialno,

  604.                                             alarmTypeId = 12,

  605.                                             alarmDeviceName = heartRate.Serialno,

  606.                                             alarmRemarks = JsonConvert.SerializeObject(new { fetalHeartValue = fetalHeartRate, isAbnormal = fetalHeartRateIsAbnormal }),

  607.                                             address = string.Empty,

  608.                                             deviceKey = device?.DeviceId

  609.                                         }

  610.                                     };

  611.                                     await _serviceMqProcess.ProcessIMEIEventMessageAsync(fhrMsgId, topic, fhrMsg).ConfigureAwait(false);

  612.                                 }

  613.                                 

  614. 

  615.                             }

  616.                         }

  617. 

  618.                         #endregion

  619. 

  620.                         #region 计算胎动数据

  621.                         _logger.LogInformation($"{heartRate.Serialno} 计算胎动数据 ");

  622. 

  623.                         var fetalMovementNow = (DateTime)heartRate.LastUpdate!;

  624. 

  625.                         var midNight = new DateTime(fetalMovementNow.Year, fetalMovementNow.Month, fetalMovementNow.Day, 0, 0, 0);

  626. 

  627.                         TimeSpan fetalMovementTS = fetalMovementNow - midNight;

  628. 

  629.                         // 当天每隔2小时的段数，取整数部分

  630.                         int segmentCountFM = (int)(fetalMovementTS.TotalHours / 2);

  631. 

  632.                         for (int i = 0; i < segmentCountFM; i++)

  633.                         {

  634.                             // 每两小时

  635.                             var fetalMovementSampleTime = DateTimeUtil.ConvertToTimeStamp(midNight.AddHours(2 * i)).ToString()[..10];

  636.                            

  637.                             // 统计开始时间

  638.                             var statStartTime = midNight.AddHours(2 * i);

  639.                             // 统计结束时间

  640.                             var statEndTime = midNight.AddHours(2 * (i+1));

  641. 

  642.                             var isFetalMovementExisted = await _deviceCacheMgr.FetalMovementIsExistedAsync(heartRate.Serialno, fetalMovementSampleTime);

  643.                             _logger.LogInformation($"{heartRate.Serialno} 胎动记录{isFetalMovementExisted},数据采样时间:{fetalMovementSampleTime}|{midNight.AddHours(2 * i).ToString("yyyy-MM-dd HH:mm:ss")}, 周期:{statStartTime}-{statEndTime} 开始");

  644. 

  645.                             if (!isFetalMovementExisted)

  646.                             {

  647.                                 /// 开始计算

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

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

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

  651.                                 .ToList();

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

  653.                                 if (phrRange.Count >= 2)

  654.                                 {

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

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

  657.                                     bool isInTimeRanges = IsLastUpdateInTimeRanges(fetalMovementNow);

  658. 

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

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

  661.                                     {

  662.                                         var fetalMovementMap = _mgrFetalMovementNormalValueRangeCache.GetFetalMovements();

  663. 

  664.                                         var fetalMovementMapValue = isInTimeRanges ? fetalMovementMap

  665.                                                 .Where(i =>

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

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

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

  669.                                                 .FirstOrDefault()

  670.                                                 :

  671.                                                 fetalMovementMap

  672.                                                 .Where(i =>

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

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

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

  676.                                                 .FirstOrDefault()

  677.                                         ;

  678. 

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

  680.                                         // 四舍五入

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

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

  683. 

  684.                                         _logger.LogInformation($"{heartRate.Serialno} 胎动数据采样时间:{fetalMovementSampleTime}|{midNight.AddHours(2 * i).ToString("yyyy-MM-dd HH:mm:ss")}, 采样周期:{statStartTime}-{statEndTime}, 原始胎动值:{fetalMovementMapValue}, 佩戴时间 :{duringMins}|{statStartTime}-{phrRange.First()}, 胎动计算值:{fetalMovementValue}, 胎动最终值:{fetalMovement} 已完成.");

  685. 

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

  687.                                         var feltalMovementIsAbnormal = fetalHeartRateIsAbnormal;

  688.                                         //var feltalMovementIsAbnormal = 0;

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

  690. 

  691.                                         await _serviceIotApi.SetFetalMovementConfig(heartRate.Serialno, fetalMovement, fetalMovementSampleTime, feltalMovementIsAbnormal);

  692.                                         

  693.                                         // 保存到MySQL数据库

  694.                                         HisGpsFetalMovement fm = new()

  695.                                         {

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

  697.                                             PersonId = commonPHR!.PersonId,

  698.                                             Serialno = heartRate.Serialno,

  699.                                             CreateTime = DateTime.Now,

  700.                                             IsAbnormal = feltalMovementIsAbnormal,

  701.                                             FetalMovementValue = fetalMovement,

  702.                                             SampleTime = fetalMovementSampleTime,

  703.                                             Method = 1,

  704.                                             IsDisplay = 1,

  705.                                             DeviceKey = commonPHR!.DeviceKey

  706.                                         };

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

  708. 

  709.                                         // 发送到微信

  710.                                         if (feltalMovementIsAbnormal != 0)

  711.                                         {

  712.                                             var device = await _deviceCacheMgr.GetDeviceBySerialNoAsync(heartRate.Serialno).ConfigureAwait(false);

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

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

  715.                                             var fmMsg = new

  716.                                             {

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

  718.                                                 topic = topic,

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

  720.                                                 data = new

  721.                                                 {

  722.                                                     deviceId = device?.DeviceId,

  723.                                                     imei = heartRate.Serialno,

  724.                                                     alarmTypeId = 12,

  725.                                                     alarmDeviceName = heartRate.Serialno,

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

  727.                                                     address = string.Empty,

  728.                                                     deviceKey = device?.DeviceId

  729.                                                 }

  730.                                             };

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

  732.                                         }

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

  734.                                         await _deviceCacheMgr.SetFetalMovementAsync(heartRate.Serialno, fetalMovementSampleTime,fm);

  735.                                         

  736.                                     }

  737.                                     else

  738.                                     {

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

  740.                                     }

  741.                                 }

  742.                                 else

  743.                                 {

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

  745. 

  746.                                 }

  747.                             }

  748.                             else

  749.                             {

  750.                                 _logger.LogInformation($"{heartRate.Serialno} 胎动记录{isFetalMovementExisted},数据采样时间:{fetalMovementSampleTime}|{midNight.AddHours(2 * i).ToString("yyyy-MM-dd HH:mm:ss")}, 周期:{statStartTime}-{statEndTime} 已处理");

  751.                             }

  752. 

  753.                         }

  754.                         #endregion

  755.                     }

  756.                     #endregion

  757.                     

  758. 

  759. 

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

  761.                     //var fetalKey = $"health_monitor/schedule_push/cal_fetal_heart_rate/imei/{heartRate.Serialno}";

  762.                     //await SetIntervalTriggerAsync(fetalKey, heartRate.Serialno, 60 * 15);

  763.                     #endregion

  764. 

  765.                     #region  定时计算胎心数据触发器下一刻钟后

  766.                     //// 获取当前时间

  767.                     //DateTime nowInterval = DateTime.Now;

  768. 

  769.                     //// 计算下一个15分钟的刻钟

  770.                     //int minutesToAdd = 15 - (nowInterval.Minute % 15);

  771.                     //if (minutesToAdd == 15)

  772.                     //{

  773.                     //    minutesToAdd = 0; // 如果已经是刻钟，则不需要增加分钟

  774.                     //}

  775.                     //// 计算下一刻钟的时间

  776.                     //DateTime nextInterval = nowInterval.AddMinutes(minutesToAdd)

  777.                     //                                .AddSeconds(-nowInterval.Second)

  778.                     //                                .AddMilliseconds(-nowInterval.Millisecond);

  779. 

  780.                     //// 计算时间差

  781.                     //TimeSpan timeDifference = nextInterval - nowInterval;

  782. 

  783.                     //var fetalKey = $"health_monitor/schedule_push/cal_fetal_heart_rate/imei/{heartRate.Serialno}";

  784.                     //await SetIntervalTriggerAsync(fetalKey, heartRate.Serialno, (long)timeDifference.TotalSeconds);

  785.                     #endregion

  786. 

  787.                     #region 定时计算胎动数据触发器 0 点开始

  788.                     //var fetalMovementKey = $"health_monitor/schedule_push/cal_fetal_movement/imei/{heartRate.Serialno}";

  789.                     ///// 计算 0 点秒数

  790.                     //DateTime now = DateTime.Now;

  791.                     //var rand = new Random();

  792.                     //var pushSec = rand.Next(59);

  793.                     //int pushMin = int.TryParse(heartRate.Serialno.AsSpan(heartRate.Serialno.Length - 1), out pushMin) ? pushMin : 10;

  794.                     //DateTime nextRunTime = new (now.Year, now.Month, now.Day, 0, pushMin, pushSec);

  795.                     //TimeSpan timeUntilNextRun = nextRunTime - now;

  796.                     //if (timeUntilNextRun < TimeSpan.Zero)

  797.                     //{

  798.                     //    timeUntilNextRun = timeUntilNextRun.Add(TimeSpan.FromDays(1));

  799.                     //    nextRunTime += timeUntilNextRun;

  800.                     //}

  801.                     //var ttl = (long)timeUntilNextRun.TotalSeconds;

  802. 

  803.                     //await SetIntervalTriggerAsync(fetalMovementKey, heartRate.Serialno, ttl);

  804.                     #endregion

  805.                 }

  806. 

  807.                 #region 定时下发触发器(定时建模)

  808.                 var key = $"health_monitor/schedule_push/pregnancy_heart_rate/imei/{heartRate.Serialno}";

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

  810. 

  811.                 if (string.IsNullOrWhiteSpace(schedule_push))

  812.                 {

  813.                     // 注册首次下推

  814. #if DEBUG

  815.                     //  await _serviceEtcd.PutValAsync(key, result, 60*1, false).ConfigureAwait(false);

  816. 

  817.                     var interval = 0;

  818.                     // 获取当前时间

  819.                     DateTime now = DateTime.Now;

  820. 

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

  822.                     DateTime nextRunTime = new DateTime(now.Year, now.Month, now.Day, now.Hour, now.Minute + 1, 58).AddDays(interval);

  823.                     TimeSpan timeUntilNextRun = nextRunTime - now;

  824. 

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

  826.                     if (timeUntilNextRun < TimeSpan.Zero)

  827.                     {

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

  829.                         nextRunTime += timeUntilNextRun;

  830.                     }

  831.                     var ttl = (long)timeUntilNextRun.TotalSeconds;

  832.                     var data = new

  833.                     {

  834.                         imei = heartRate.Serialno,

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

  836.                         ttl,

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

  838.                     };

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

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

  841. 

  842. #else

  843. 

  844.                 var interval = 0;

  845.                 // 获取当前时间

  846.                 DateTime now = DateTime.Now;

  847.                 var rand=new Random();  

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

  849.                 int pushMin= int.TryParse(heartRate.Serialno.AsSpan(heartRate.Serialno.Length - 1), out pushMin) ? pushMin : 10;

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

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

  852.                 TimeSpan timeUntilNextRun = nextRunTime - now;

  853. 

  854.                 

  855.                 if (timeUntilNextRun < TimeSpan.Zero)

  856.                 {

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

  858.                     nextRunTime += TimeSpan.FromDays(1);

  859.                 }

  860. 

  861.                 var ttl =(long)timeUntilNextRun.TotalSeconds;

  862.                 var data = new

  863.                 {

  864.                     imei = heartRate.Serialno,

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

  866.                     ttl,

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

  868.                 };

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

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

  871. #endif

  872. 

  873.                 }

  874. 

  875.                 #endregion

  876. 

  877.             }

  878. 

  879. 

  880. 

  881.         }

  882. 

  883.         private async Task SaveAndPushFetalHeartRateAsync(HisGpsHeartRate heartRate, int upperAlarmThreshold, int lowerAlarmThreshold, double avgPhr)

  884.         {

  885.             var commonPHR = await _serviceTDengine.InitPregnancyCommonHeartRateModeAsync(heartRate.Serialno);

  886.             if (commonPHR != null)

  887.             {

  888.                 // 保存到TDengine数据库

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

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

  891.                 var fetalHeartRate = SafeType.SafeInt(avgPhr * commonPHR?.StatModeAvgFprCoefficient!);

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

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

  894. 

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

  896.                 HisGpsFetalHeartRate gpsFetalHeartRate = new ()

  897.                 {

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

  899.                     PersonId = commonPHR!.PersonId,

  900.                     Serialno = heartRate.Serialno,

  901.                     HeartRate = fetalHeartRate,

  902.                     SampleTime = sampleTime.Length > 10 ? sampleTime.Substring(0, 10) : sampleTime,

  903.                     IsAbnormal = isAbnormal,

  904.                     StatStartTime = commonPHR.StatStartTime,

  905.                     StatEndTime = commonPHR.StatEndTime,

  906.                     CreateTime = DateTime.Now,

  907.                     Method = 1,

  908.                     IsDisplay = 1,

  909.                     DeviceKey = commonPHR!.DeviceKey

  910.                 };

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

  912. 

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

  914.                 await _serviceIotApi.SetFetalHeartRateConfig(heartRate.Serialno, fetalHeartRate, sampleTime, isAbnormal);

  915. 

  916.                 // 推送到微信

  917.                 var device = await _deviceCacheMgr.GetDeviceBySerialNoAsync(heartRate.Serialno).ConfigureAwait(false);

  918. 

  919.                 var deviceId = device?.DeviceId;

  920.                 var msg = new

  921.                 {

  922.                     messageId = "",

  923.                     topic = "topic.push.wx",

  924.                     time=""

  925.                 };

  926.             }

  927.         }

  928. 

  929.         private async Task SaveAndPushFreqFetalHeartRateAsync(HisGpsHeartRate heartRate, int upperAlarmThreshold, int lowerAlarmThreshold, double avgPhr,string sampleTime)

  930.         {

  931.             var commonPHR = await _serviceTDengine.InitPregnancyCommonHeartRateModeAsync(heartRate.Serialno);

  932.             if (commonPHR != null)

  933.             {

  934.                 // 保存到TDengine数据库

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

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

  937.                 var fetalHeartRate = SafeType.SafeInt(avgPhr * commonPHR?.StatModeAvgFprCoefficient!);

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

  939. 

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

  941.                 HisGpsFetalHeartRate gpsFetalHeartRate = new()

  942.                 {

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

  944.                     PersonId = commonPHR!.PersonId,

  945.                     Serialno = heartRate.Serialno,

  946.                     HeartRate = fetalHeartRate,

  947.                     SampleTime = sampleTime.Length > 10 ? sampleTime.Substring(0, 10) : sampleTime,

  948.                     IsAbnormal = isAbnormal,

  949.                     StatStartTime = commonPHR.StatStartTime,

  950.                     StatEndTime = commonPHR.StatEndTime,

  951.                     CreateTime = DateTime.Now,

  952.                     Method = 1,

  953.                     IsDisplay = 1,

  954.                     DeviceKey = commonPHR!.DeviceKey

  955.                 };

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

  957. 

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

  959.                 await _serviceIotApi.SetFetalHeartRateConfig(heartRate.Serialno, fetalHeartRate, sampleTime, isAbnormal);

  960. 

  961.                 // 推送到微信

  962.                 if (isAbnormal!=0)

  963.                 {

  964.                     var device = await _deviceCacheMgr.GetDeviceBySerialNoAsync(heartRate.Serialno).ConfigureAwait(false);

  965.                     var fhrMsgId = $"{heartRate.Serialno}-{sampleTime}-{Guid.NewGuid().ToString("D")[^3..]}";

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

  967.                     var fhrMsg = new

  968.                     {

  969.                         messageId = fhrMsgId,

  970.                         topic = topic,

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

  972.                         data = new

  973.                         {

  974.                             deviceId = device?.DeviceId,

  975.                             imei = heartRate.Serialno,

  976.                             alarmTypeId = 12,

  977.                             alarmDeviceName = heartRate.Serialno,

  978.                             alarmRemarks = JsonConvert.SerializeObject(new { fetalHeartValue = fetalHeartRate, isAbnormal = isAbnormal }),

  979.                             address = string.Empty,

  980.                             deviceKey = device?.DeviceId

  981.                         }

  982.                     };

  983.                     await _serviceMqProcess.ProcessIMEIEventMessageAsync(fhrMsgId, topic, fhrMsg).ConfigureAwait(false);

  984. 

  985.                 }

  986. 

  987. 

  988.             }

  989.         }

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

  991.         {

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

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

  994.             if (string.IsNullOrWhiteSpace(schedulePush))

  995.             {

  996.                 var now = DateTime.Now;

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

  998.                 var data = new

  999.                 {

  1000.                     imei,

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

  1002.                     ttl = interval,

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

  1004.                 };

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

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

  1007.             }

  1008.         }

  1009. 

  1010.         public static bool IsLastUpdateInTimeRanges(DateTime lastUpdate)

  1011.         {

  1012.             var now = lastUpdate.TimeOfDay;

  1013. 

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

  1015.             {

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

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

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

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

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

  1021.             };

  1022. 

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

  1024.         }

  1025.     }

  1026. }