HealthMonitor/HealthMonitor.Service/Biz/IotApiService.cs

using HealthMonitor.Common.helper;
using HealthMonitor.Model.Config;
using HealthMonitor.Service.Resolver;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Options;
using Newtonsoft.Json.Linq;
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using HealthMonitor.Model.Service;
using TelpoDataService.Util.Entities.GpsCard;
using TelpoDataService.Util;
using TelpoDataService.Util.Clients;
using TelpoDataService.Util.Models;
using TelpoDataService.Util.QueryObjects;
using HealthMonitor.Service.Cache;
using HealthMonitor.Model.Cache;
using Etcdserverpb;

namespace HealthMonitor.Service.Biz
{
    public class IotApiService
    {
        private readonly ServiceConfig _configService;
        private readonly ILogger<IotApiService> _logger;
        private readonly PersonCacheManager _personCacheMgr;
        private readonly DeviceCacheManager _deviceCacheMgr;


        private readonly HttpHelper _httpHelper = default!;

        private readonly GpsCardAccessorClient<GpsPerson> _gpsPersonApiClient;

        public IotApiService(ILogger<IotApiService> logger, HttpHelper httpHelper, DeviceCacheManager deviceCacheMgr, GpsCardAccessorClient<GpsPerson> gpsPersonApiClient, IOptions<ServiceConfig> optConfigService, PersonCacheManager personCacheMgr)
        {
            _configService = optConfigService.Value;
            _httpHelper=httpHelper; 
            _logger = logger;
            _personCacheMgr = personCacheMgr;
            _gpsPersonApiClient = gpsPersonApiClient;
            _deviceCacheMgr = deviceCacheMgr;
        }

        #region 平台下发血压标定参数
        /// <summary>
        /// 平台下发血压标定参数
        /// </summary>
        /// <param name="bpsCalibrationConfig"></param>
        /// <returns></returns>
        public async Task<bool> SetBloodPressCalibrationConfigAsync(BloodPressCalibrationConfigModel bpsCalibrationConfig)
        {

#if DEBUG
             var flag = true;
#else
            //systolicCalibrationValue = 0,  //收缩压标定值，值为0 表示不生效
            //diastolicCalibrationValue 0, //舒张压标定值，值为0表示不生效
            //systolicIncValue = 0, //收缩压显示增量，值为0 表示不生效
            //diastolicIncValue = 0   //舒张压显示增量，值为0 表示不生效

            var flag = false;
            try
            {
                var url = $"{_configService.IotWebApiUrl}Command/SetBloodPressCalibrationConfig";
                List<KeyValuePair<string, string>> headers = new()
                {
                    new KeyValuePair<string, string>("AuthKey", "key1")
                };
                var res = await _httpHelper.HttpToPostAsync(url, bpsCalibrationConfig, headers).ConfigureAwait(false);
                _logger.LogInformation($"向{bpsCalibrationConfig.Imei}下发增量值数据:{JsonConvert.SerializeObject(bpsCalibrationConfig)}，响应：{res}");
                var resJToken = JsonConvert.DeserializeObject(res ?? string.Empty) as JToken;
                flag= resJToken?["message"]?.ToString().Equals("ok") ?? false;

            }
            catch (Exception ex)
            {
                _logger.LogError($"{nameof(SetBloodPressCalibrationConfigAsync)} 下发血压增量值异常:{ex.Message}, {ex.StackTrace}");

            }
           

#endif

            return flag;


        }


        public async Task<BloodPressCalibrationConfigModelReponse> SetBloodPressCalibrationConfig2Async(BloodPressCalibrationConfigModel bpsCalibrationConfig)
        {
            BloodPressCalibrationConfigModelReponse response = new BloodPressCalibrationConfigModelReponse();
            response.Flag = false;
            response.Message = string.Empty;
#if DEBUG
            //var flag = true;
            response.Flag=true;
#else
            //systolicCalibrationValue = 0,  //收缩压标定值，值为0 表示不生效
            //diastolicCalibrationValue 0, //舒张压标定值，值为0表示不生效
            //systolicIncValue = 0, //收缩压显示增量，值为0 表示不生效
            //diastolicIncValue = 0   //舒张压显示增量，值为0 表示不生效

            // var flag = false;
            try
            {
                var url = $"{_configService.IotWebApiUrl}Command/SetBloodPressCalibrationConfig";
                List<KeyValuePair<string, string>> headers = new()
                {
                    new KeyValuePair<string, string>("AuthKey", "key1")
                };
                var res = await _httpHelper.HttpToPostAsync(url, bpsCalibrationConfig, headers).ConfigureAwait(false);
                _logger.LogInformation($"向{bpsCalibrationConfig.Imei}下发增量值数据:{JsonConvert.SerializeObject(bpsCalibrationConfig)}，响应：{res}");
                var resJToken = JsonConvert.DeserializeObject(res ?? string.Empty) as JToken;
                //response.Flag= resJToken?["message"]?.ToString().Equals("ok") ?? false;
                response.Flag = Convert.ToBoolean(resJToken?["succeed"]?.ToString());
                if (!response.Flag)
                {
                    response.Message = resJToken?["message"]?.ToString()!;
                }
            }
            catch (Exception ex)
            {
                _logger.LogError($"{nameof(SetBloodPressCalibrationConfigAsync)} 下发血压增量值异常:{ex.Message}, {ex.StackTrace}");

            }
           

#endif

            return response;
        }

        public async Task<bool> UpdatePersonRemarksAsync(string imei, int systolicRefValue, int diastolicRefValue, int systolicIncValue, int diastolicIncValue, string remarks = "is_blood_press")
        {
            var flag = false;
            try
            {

                // 保证实时性，先更新缓存，再更新数据库
                var personCache = await _personCacheMgr.GetDeviceGpsPersonCacheObjectBySerialNoAsync(new Guid().ToString(), imei).ConfigureAwait(false);

                if (personCache == null)
                {
                    _logger.LogInformation($"{imei} -- Person remarks数据异常，检查缓存和数据库");
                }
                else
                {
                    var newRemarkData = new
                    {
                        imei,
                        time = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"),
                        commandValue = new
                        {
                            systolicCalibrationValue = systolicRefValue,  //收缩压标定值，值为0 表示不生效
                            diastolicCalibrationValue = diastolicRefValue, //舒张压标定值，值为0表示不生效
                            systolicIncValue, //收缩压显示增量，值为0 表示不生效
                            diastolicIncValue  //舒张压显示增量，值为0 表示不生效
                        }
                    };
                    var newRemarkStr = $"{remarks}:{JsonConvert.SerializeObject(newRemarkData)}|";

                    personCache["person"]!["remarks"] = newRemarkStr;
                    bool cacheFlag = await _personCacheMgr.UpdateDeviceGpsPersonCacheObjectBySerialNoAsync(personCache, imei);
                    if (cacheFlag)
                    {
                        GeneralParam condition = new()
                        {
                            Filters = new List<QueryFilterCondition> {
                            new QueryFilterCondition {
                                Key=nameof(GpsDevice.Serialno),
                                Value=imei,
                                Operator= QueryOperatorEnum.Equal,
                                ValueType=QueryValueTypeEnum.String
                            }
                        },
                            OrderBys = new List<OrderByCondition> { new OrderByCondition { Key = "serialno", IsDesc = true } }

                        };
                        _logger.LogInformation($"{imei} 更新缓存{nameof(UpdatePersonRemarksAsync)}成功，{JsonConvert.SerializeObject(personCache)}");
                        // 读取数据库
                        var person = await _gpsPersonApiClient.GetFirstAsync(condition, new RequestHeader() { RequestId = $"{imei}" }).ConfigureAwait(false);
                        // 更新字段
                        person!.Remarks = newRemarkStr;
                        await _gpsPersonApiClient.UpdateAsync(person, new RequestHeader() { RequestId = $"{imei}" }).ConfigureAwait(false);
                        _logger.LogInformation($"{imei} 更新Person remarks字段|{person.Remarks}");

                    }
                    else
                    {
                        _logger.LogInformation($"{imei} 更新缓存和数据库{nameof(UpdatePersonRemarksAsync)}失败，{JsonConvert.SerializeObject(personCache)}");
                    }
                    flag = cacheFlag;
                }
                // else if (string.IsNullOrWhiteSpace(personCache["person"]!["remarks"]!.ToString()))
                //else if (personCache?["person"]!["remarks"]!.ToString()!=null)
                //{
                //    var newRemarkData = new
                //    {
                //        imei,
                //        time = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"),
                //        commandValue = new
                //        {
                //            systolicCalibrationValue = systolicRefValue,  //收缩压标定值，值为0 表示不生效
                //            diastolicCalibrationValue = diastolicRefValue, //舒张压标定值，值为0表示不生效
                //            systolicIncValue, //收缩压显示增量，值为0 表示不生效
                //            diastolicIncValue  //舒张压显示增量，值为0 表示不生效
                //        }
                //    };
                //    var newRemarkStr = $"{remarks}:{JsonConvert.SerializeObject(newRemarkData)}|";

                //    personCache["person"]!["remarks"] = newRemarkStr;
                //    bool cacheFlag = await _personCacheMgr.UpdateDeviceGpsPersonCacheObjectBySerialNoAsync(personCache, imei);
                //    if (cacheFlag)
                //    {
                //        GeneralParam condition = new()
                //        {
                //            Filters = new List<QueryFilterCondition> {
                //            new QueryFilterCondition {
                //                Key=nameof(GpsDevice.Serialno),
                //                Value=imei,
                //                Operator= QueryOperatorEnum.Equal,
                //                ValueType=QueryValueTypeEnum.String
                //            }
                //        },
                //            OrderBys = new List<OrderByCondition> { new OrderByCondition { Key = "serialno", IsDesc = true } }

                //        };
                //        _logger.LogInformation($"{imei} 更新缓存{nameof(UpdatePersonRemarksAsync)}成功，{JsonConvert.SerializeObject(personCache)}");
                //        // 读取数据库
                //        var person = await _gpsPersonApiClient.GetFirstAsync(condition, new RequestHeader() { RequestId = $"{imei}" }).ConfigureAwait(false);
                //        // 更新字段
                //        person!.Remarks = newRemarkStr;
                //        await _gpsPersonApiClient.UpdateAsync(person, new RequestHeader() { RequestId = $"{imei}" }).ConfigureAwait(false);
                //        _logger.LogInformation($"{imei} 更新Person remarks字段|{person.Remarks}");

                //    }
                //    else
                //    {
                //        _logger.LogInformation($"{imei} 更新缓存和数据库{nameof(UpdatePersonRemarksAsync)}失败，{JsonConvert.SerializeObject(personCache)}");
                //    }
                //    flag = cacheFlag;
                //}
            }
            catch (Exception ex)
            {
                _logger.LogError($"{nameof(UpdatePersonRemarksAsync)} {imei}--更新个人信息异常:{ex.Message}, {ex.StackTrace}");
            }
            return flag;
        }

        #endregion

        #region 平台下发胎心监测参数
        public async Task<bool> SetFetalHeartRateConfig(string serialno, int modeStatus=0, int maxValue=0, int minValue = 0)
        {
            try
            {
                #region 读取缓存
                // db7.HashGet("TELPO#GPSDEVICE_WATCH_CONFIG_HASH","861281060086083_0067")
                var watchConfig = await _deviceCacheMgr.GetGpsDeviceWatchConfigCacheObjectBySerialNoAsync(serialno, "0067");
                if (watchConfig==null)
                {
                    return false;
                }

                #endregion

                #region 获取B端 Token
                var getTokenUrl = $"{_configService.IotAuth}/getAccessToken2";
                var tokenReq = new
                {
                    manufactorId= "7c7c38cb-d045-41d8-b3d0-fcaaa84a8f02",
                    imei= serialno
                };
                var resToken = await _httpHelper.HttpToPostAsync(getTokenUrl, tokenReq).ConfigureAwait(false);
                var tokenAuth= JsonConvert.DeserializeObject(resToken ?? string.Empty) as JToken;
                var tokenAuthData = tokenAuth?["data"]?.ToString()??string.Empty;
                if (tokenAuthData == null)
                {
                    return false;
                }
                #endregion

                #region 发送到B端
                List<KeyValuePair<string, string>> headers = new()
                {
                    new KeyValuePair<string, string>("TelpoManufactorId", tokenAuthData)
                };
                var data = new
                {
                    imeis = new string[] { serialno },
                    enabled = (int)watchConfig["fetalParamters"]!["enabled"]!,
                    triggerHighFreqHigh = maxValue == 0 ? (int)watchConfig["fetalParamters"]!["triggerHighFreqHigh"]!:maxValue,
                    triggerLowFreqLow = minValue == 0 ? (int)watchConfig["fetalParamters"]!["triggerHighFreqLow"]! : minValue,
                    highFreqSampleTimes = (int)watchConfig["fetalParamters"]!["highFreqSampleTimes"]!,
                    highFreqSampleInterval = (int)watchConfig["fetalParamters"]!["highFreqSampleInterval"]!,
                    stopHighFreqSampleCount = (int)watchConfig["fetalParamters"]!["stopHighFreqSampleCount"]!,
                    mode = modeStatus,
                    edoc = watchConfig["fetalParamters"]!["EDOC"]!,
                    vibrateEnabled = (int)watchConfig["fetalParamters"]!["vibrateEnabled"]!,
                    lcdEnabled= (int)watchConfig["fetalParamters"]!["lcdEnabled"]!
                };
                var setUrl = $"{_configService.IotCore}/api/v1/open/OpenIot/SetFetalConfig";
                var res = await _httpHelper.HttpToPostAsync(setUrl, data, headers).ConfigureAwait(false);
                var resJToken = JsonConvert.DeserializeObject(res ?? string.Empty) as JToken;
                return resJToken?["message"]?.ToString().Equals("ok") ?? false;
                //response.Flag = resJToken?["message"]?.ToString().Equals("ok") ?? false;
                //response.Flag = Convert.ToBoolean(resJToken?["succeed"]?.ToString());
                //if (!response.Flag)
                //{
                //    response.Message = resJToken?["message"]?.ToString()!;
                //}
                #endregion
            }
            catch (Exception ex)
            {
                _logger.LogError($"{nameof(SetFetalHeartRateConfig)} 下发胎心检测参数异常:{ex.Message}, {ex.StackTrace}");
                return false;
            }
        }
        #endregion

    }
}