WeiCloud.Fusion/WeiCloud.Fusion/ThirdPartyServices/ThirdPartyServices.DomainService/ShenZhouShengAn/SunPalaceBoardSafetyService.cs

using Common.Shared.Application.BaseModels;
using Common.Shared.Application.SafetyFirePro.RequestDto;
using Common.Shared.Application.SafetyFirePro.ResponseDto;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.Logging;
using System.Text.Json;
using ThirdPartyServices.Application.ShenZhouShengAn.RequestDto;
using ThirdPartyServices.Application.ShenZhouShengAn.ResponseDto;

namespace ThirdPartyServices.DomainService.ShenZhouShengAn
{
    public class SunPalaceBoardSafetyService : ISunPalaceBoardSafetyService
    {
        private readonly IThirdPartyProviderService _tokenProviderService;
        private readonly ILogger<SunPalaceBoardSafetyService> _logger;
        private readonly IConfiguration _configuration;

        public SunPalaceBoardSafetyService(IThirdPartyProviderService thirdPartyProviderService, ILogger<SunPalaceBoardSafetyService> logger, IConfiguration configuration)
        {
            _tokenProviderService = thirdPartyProviderService;
            _logger = logger;
            _configuration = configuration;
        }

        /// <summary>
        /// 获得四色图图层列表
        /// </summary>
        /// <param name="ubpid">用户单位标记码</param>
        /// <returns></returns>
        /// <exception cref="NotImplementedException"></exception>
        public async Task<ApiResult<FloorResDto>> GetListFloor()
        {
            ApiResult<FloorResDto> result = new ApiResult<FloorResDto>() { Code = 200, Msg = "接口调用成功", Data = null };

            try
            {
                //获取token
                var token = await _tokenProviderService.GetTokenAsync(_configuration["ThirdParty:SzdunanCode"]!);
                if (string.IsNullOrWhiteSpace(token))
                {
                    _logger.LogWarning("GetListFloor接口获取token失败");
                    return ApiResult<FloorResDto>.IsFail("GetListFloor接口获取token失败");
                }

                //获取用户配置
                HttpClientResult<LoginUsersConfiguration> loginUsers = await _tokenProviderService.GetUserConfiguration(token);
                if (loginUsers.Code == "Error")
                {
                    _logger.LogWarning("GetListFloor接口获取用户配置失败");
                    return ApiResult<FloorResDto>.IsFail("GetListFloor接口获取用户配置失败");
                }

                //生产风险识别
                HttpClientResult<List<FloorDto>> riskResult = await _tokenProviderService
                .SendAndParseAsync<int, HttpClientResult<List<FloorDto>>>(
         "https://zrh.szdunan.cn/v1/api/riskFourcoloringMap/getlistFloor",
         token, loginUsers.Data.Ubpid, HttpMethod.Post);

                if (riskResult.Data != null)
                {
                    result.Data = new FloorResDto { Data = riskResult.Data };
                }
            }
            catch (Exception ex)
            {
                _logger.LogWarning(ex, "GetListFloor接口出错");
                return ApiResult<FloorResDto>.IsFail($"GetListFloor接口出错{ex.Message}");
            }

            return result;
        }

        /// <summary>
        /// 生产风险识别(盾安云数据)-智慧建筑的看板上使用
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        public async Task<ApiResult<DangerRiskAreaResDto>> GetProductionRiskEchart()
        {
            ApiResult<DangerRiskAreaResDto> result = new() { Code = 200, Msg = "接口调用成功", Data = new DangerRiskAreaResDto() { DangerInfos = [], ProductionRiskStats = [] } };
            try
            {
                //获取token
                var token = await _tokenProviderService.GetTokenAsync(_configuration["ThirdParty:SzdunanCode"]!);
                if (string.IsNullOrWhiteSpace(token))
                {
                    _logger.LogWarning("GetProductionRiskEchart接口获取token失败");
                    return ApiResult<DangerRiskAreaResDto>.IsFail("GetProductionRiskEchart接口获取token失败");
                }

                //获取用户配置
                HttpClientResult<LoginUsersConfiguration> loginUsers = await _tokenProviderService.GetUserConfiguration(token);
                if (loginUsers.Code == "Error")
                {
                    _logger.LogWarning("GetProductionRiskEchart接口获取用户配置失败");
                    return ApiResult<DangerRiskAreaResDto>.IsFail("GetProductionRiskEchart接口获取用户配置失败");
                }

                //获取单位信息
                HttpClientResult<BranchResDto> branchs = await _tokenProviderService.GetBranchPermissions(token, loginUsers.Data.Uid);
                if (branchs.Code == "Error")
                {
                    _logger.LogWarning("GetProductionRiskEchart接口获取单位信息失败");
                    return ApiResult<DangerRiskAreaResDto>.IsFail("GetProductionRiskEchart接口获取单位信息失败");
                }

                //生产风险识别

                HttpClientResult<DangerRiskAreaResDto> riskResult = await _tokenProviderService.SendAndParseAsync<RiskAreaQueryDto, HttpClientResult<DangerRiskAreaResDto>>(
                       "https://zrh.szdunan.cn/v1/api/home/risk/index", token,
                       new RiskAreaQueryDto
                       {
                           Branch_Id = branchs.Data.BranchPermissionIds[0],
                           Ubpid = loginUsers.Data.Ubpid,
                           Uid = loginUsers.Data.Uid
                       }, HttpMethod.Post);

                if (riskResult.Code != "Error" || riskResult.Data != null)
                    result.Data.ProductionRiskStats = riskResult.Data.ProductionRiskStats;

                //获取隐患信息
                string[] dangerStatus = ["0", "1", "2",]; //0-待核查，1-待整改，2-待验收
                int[] dangerLevel = [3]; //2一般隐患，3重大隐患。目前只要重大隐患，如果要查询一般隐患，可以将2添加到数组中
                List<DangerInfo> dangerInfoList = [];
                DangerInfo dangerInfo = new DangerInfo();

                var tasks = new List<Task<DangerInfo>>();

                foreach (string status in dangerStatus)
                {
                    tasks.Add(Task.Run(async () =>
                    {
                        var info = new DangerInfo { Status = status };

                        // 1. 查该状态下的总数
                        string jsonResult = await _tokenProviderService.SendJsonAsync<DangerInfoQueryDto>("https://zrh.szdunan.cn/v1/api/danger/ledger/dangerInfo/new", token, new DangerInfoQueryDto { Ubpid = loginUsers.Data.Ubpid, Status = status }, HttpMethod.Post);

                        using JsonDocument doc = JsonDocument.Parse(jsonResult);
                        JsonElement root = doc.RootElement;

                        int total = 0;
                        if (root.TryGetProperty("data", out JsonElement dataElement))
                        {
                            if (dataElement.TryGetProperty("total", out JsonElement totalElement))
                            {
                                total = totalElement.GetInt32();
                            }
                        }
                        info.StatusCount = total;

                        return info;
                    }));
                }

                dangerInfoList = [.. (await Task.WhenAll(tasks))];
                //3.待排查
                DateTime startTime = new DateTime(DateTime.Today.Year, 1, 1);
                dangerInfo = new DangerInfo();
                var jsonBranch = await _tokenProviderService.SendJsonAsync("https://zrh.szdunan.cn/v1/api/danger/task/index_branch", token, new DangerInfoQueryDto { Status = "0", Branch_id = branchs.Data.BranchPermissionIds[0], Start_time = startTime.ToString("yyyy-MM-dd HH:mm:ss"), End_time = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss") }, HttpMethod.Post);
                using JsonDocument doc = JsonDocument.Parse(jsonBranch);
                JsonElement root = doc.RootElement;

                int total = 0;
                if (root.TryGetProperty("data", out JsonElement dataElement))
                {
                    // 如果"data"存在，再尝试获取"total"
                    if (dataElement.TryGetProperty("total", out JsonElement totalElement))
                    {
                        // 尝试转换为int（如果类型不匹配，也会返回默认值0）
                        total = totalElement.GetInt32();
                    }
                }
                dangerInfo.StatusCount = total;
                dangerInfo.Status = "3"; //待排查
                dangerInfoList.Add(dangerInfo);

                result.Data.DangerInfos = dangerInfoList;
            }
            catch (Exception ex)
            {
                _logger.LogWarning(ex, "GetProductionRiskEchart接口出错");
                return ApiResult<DangerRiskAreaResDto>.IsFail($"GetProductionRiskEchart接口出错{ex.Message}");
            }
            return result;
        }

        /// <summary>
        /// 获取指定区域ID的隐患数据
        /// </summary>
        /// <param name="regionId">返回本区域隐患（不包含下属子区域隐患）</param>
        /// <param name="pRegionId">返回本区域及下属子区域隐患</param>
        /// <returns></returns>
        public async Task<ApiResult<DangerInfoRootResDto>> GetDangerInfos(DangerInfoQueryDto dto)
        {
            ApiResult<DangerInfoRootResDto> result = new() { Code = 200, Msg = "接口调用成功", Data = new() };
            try
            {
                //获取token
                var token = await _tokenProviderService.GetTokenAsync(_configuration["ThirdParty:SzdunanCode"]!);
                if (string.IsNullOrWhiteSpace(token))
                {
                    _logger.LogWarning("GetDangerInfos接口获取token失败");
                    return ApiResult<DangerInfoRootResDto>.IsFail("GetDangerInfos接口获取token失败");
                }

                //获取用户配置
                HttpClientResult<LoginUsersConfiguration> loginUsers = await _tokenProviderService.GetUserConfiguration(token);
                if (loginUsers.Code == "Error")
                {
                    _logger.LogWarning("GetDangerInfos接口获取用户配置失败");
                    return ApiResult<DangerInfoRootResDto>.IsFail("GetDangerInfos接口获取用户配置失败");
                }

                //获取单位信息
                HttpClientResult<BranchResDto> branchs = await _tokenProviderService.GetBranchPermissions(token, loginUsers.Data.Uid);
                if (branchs.Code == "Error")
                {
                    _logger.LogWarning("GetDangerInfos接口获取单位信息失败");
                    return ApiResult<DangerInfoRootResDto>.IsFail("GetDangerInfos接口获取单位信息失败");
                }
                dto.Ubpid = loginUsers.Data.Ubpid;
                //  dto.Branch_id = branchs.Data.BranchPermissionIds[0];

                var jsonResult = await _tokenProviderService.SendJsonAsync<DangerInfoQueryDto>("https://zrh.szdunan.cn/v1/api/danger/ledger/dangerInfo/new", token, dto, HttpMethod.Post);

                var root = JsonSerializer.Deserialize<HttpClientResult<DangerInfoRootResDto>>(jsonResult);
                if (root != null)
                {
                    result.Data = root.Data;
                }
            }
            catch (Exception ex)
            {
                _logger.LogWarning(ex, "GetDangerInfos接口出错");
                return ApiResult<DangerInfoRootResDto>.IsFail($"GetDangerInfos接口出错{ex.Message}");
            }
            return result;
        }

        /// <summary>
        /// 获得四色图区域列表
        /// </summary>
        /// <param name="floorId"></param>
        /// <returns></returns>
        public async Task<ApiResult<RootReqDto>> GetRiskMapInfo(int floorId)
        {
            ApiResult<RootReqDto> result = new ApiResult<RootReqDto>() { Code = 200, Msg = "接口调用成功", Data = null };

            try
            {
                //获取token
                var token = await _tokenProviderService.GetTokenAsync(_configuration["ThirdParty:SzdunanCode"]!);
                if (string.IsNullOrWhiteSpace(token))
                {
                    _logger.LogWarning("GetRiskMapInfo接口获取token失败");
                    return ApiResult<RootReqDto>.IsFail("GetRiskMapInfo接口获取token失败");
                }

                //获取用户配置
                HttpClientResult<LoginUsersConfiguration> loginUsers = await _tokenProviderService.GetUserConfiguration(token);
                if (loginUsers.Code == "Error")
                {
                    _logger.LogWarning("GetRiskMapInfo接口获取用户配置失败");
                    return ApiResult<RootReqDto>.IsFail("GetRiskMapInfo接口获取用户配置失败");
                }

                //生产风险识别
                HttpClientResult<object> riskResult = await _tokenProviderService
                  .SendAndParseAsync<RiskFourcoMapReqDto, HttpClientResult<object>>(
           "https://zrh.szdunan.cn/v1/api/riskFourcoloringMap/getRiskFourColoringMapInfo",
           token, new RiskFourcoMapReqDto
           {
               Floor = floorId,
               Ubpid = loginUsers.Data.Ubpid
           }, HttpMethod.Post);

                if (riskResult != null && riskResult.Data != null && riskResult.Data.ToString()!.Length > 10)
                {
                    RootReqDto httpClientResult = JsonSerializer.Deserialize<RootReqDto>(riskResult.Data.ToString()!)!;
                    if (httpClientResult != null)
                    {
                        result.Data = httpClientResult;
                    }
                }
            }
            catch (Exception ex)
            {
                _logger.LogWarning(ex, $"GetRiskMapInfo接口出错");
                return ApiResult<RootReqDto>.IsFail($"GetRiskMapInfo接口出错{ex.Message}");
            }

            return result;
        }

        /// <summary>
        /// 获得危险作业（施工）数据
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        /// <exception cref="NotImplementedException"></exception>
        public async Task<ApiResult<LedgerDto>> GetLedger(WorkTaskQueryParamsDto dto)
        {
            ApiResult<LedgerDto> result = new ApiResult<LedgerDto>() { Code = 200, Msg = "接口调用成功", Data = null };

            try
            {
                //获取token
                var token = await _tokenProviderService.GetTokenAsync(_configuration["ThirdParty:SzdunanCode"]!);
                if (string.IsNullOrWhiteSpace(token))
                {
                    _logger.LogWarning("GetProductionRiskEchart接口获取token失败");
                    return ApiResult<LedgerDto>.IsFail("GetProductionRiskEchart接口获取token失败");
                }

                //获取用户配置
                HttpClientResult<LoginUsersConfiguration> loginUsers = await _tokenProviderService.GetUserConfiguration(token);
                if (loginUsers.Code == "Error")
                {
                    _logger.LogWarning("GetProductionRiskEchart接口获取用户配置失败");
                    return ApiResult<LedgerDto>.IsFail("GetProductionRiskEchart接口获取用户配置失败");
                }

                //获取单位信息
                HttpClientResult<BranchResDto> branchs = await _tokenProviderService.GetBranchPermissions(token, loginUsers.Data.Uid);
                if (branchs.Code == "Error")
                {
                    _logger.LogWarning("GetProductionRiskEchart接口获取单位信息失败");
                    return ApiResult<LedgerDto>.IsFail("GetProductionRiskEchart接口获取单位信息失败");
                }

                dto.Ubpid = loginUsers.Data.Ubpid.ToString();

                HttpClientResult<object> riskResult = await _tokenProviderService
                  .SendAndParseAsync<WorkTaskQueryParamsDto, HttpClientResult<object>>(
           "https://zrh.szdunan.cn/v1/api/ticket/safe/ledger",
           token, dto, HttpMethod.Post);

                if (riskResult != null && riskResult.Data != null && riskResult.Data.ToString()!.Length > 10)
                {
                    LedgerDto httpClientResult = JsonSerializer.Deserialize<LedgerDto>(riskResult.Data.ToString()!)!;
                    if (httpClientResult != null)
                    {
                        result.Data = httpClientResult;
                    }
                }
            }
            catch (Exception ex)
            {
                _logger.LogWarning(ex, "GetRiskMapInfo接口出错");
                return ApiResult<LedgerDto>.IsFail($"GetRiskMapInfo接口出错{ex.Message}");
            }

            return result;
        }

        /// <summary>
        /// 获取隐患详情
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        /// <exception cref="NotImplementedException"></exception>
        public async Task<ApiResult<HazardDataDto>> GetDangerDetail(DangerDetailReqDto dto)
        {
            ApiResult<HazardDataDto> result = new ApiResult<HazardDataDto>() { Code = 200, Msg = "接口调用成功", Data = null };

            try
            {
                //获取token
                var token = await _tokenProviderService.GetTokenAsync(_configuration["ThirdParty:SzdunanCode"]!);
                if (string.IsNullOrWhiteSpace(token))
                {
                    _logger.LogWarning("GetDangerDetail接口获取token失败");
                    return ApiResult<HazardDataDto>.IsFail("GetDangerDetail接口获取token失败");
                }

                HttpClientResult<object> riskResult = await _tokenProviderService
                  .SendAndParseAsync<DangerDetailReqDto, HttpClientResult<object>>(
           "https://zrh.szdunan.cn/v1/api/danger/rectification/check/detail",
           token, dto, HttpMethod.Post);

                if (riskResult != null && riskResult.Data != null && riskResult.Data.ToString()!.Length > 10)
                {
                    HazardDataDto httpClientResult = JsonSerializer.Deserialize<HazardDataDto>(riskResult.Data.ToString()!)!;
                    if (httpClientResult != null)
                    {
                        result.Data = httpClientResult;
                    }
                }
            }
            catch (Exception ex)
            {
                _logger.LogWarning(ex, "GetDangerDetail接口出错");
                return ApiResult<HazardDataDto>.IsFail($"GetDangerDetail接口出错{ex.Message}");
            }

            return result;
        }

        /// <summary>
        /// 11、获得危害辨识项目数据
        /// </summary>
        /// <returns></returns>
        /// <exception cref="NotImplementedException"></exception>
        public async Task<ApiResult<List<InjureResDto>>> GetInjureInfo()
        {
            ApiResult<List<InjureResDto>> result = new ApiResult<List<InjureResDto>>() { Code = 200, Msg = "接口调用成功", Data = null };

            try
            {
                //获取token
                var token = await _tokenProviderService.GetTokenAsync(_configuration["ThirdParty:SzdunanCode"]!);
                if (string.IsNullOrWhiteSpace(token))
                {
                    _logger.LogWarning("GetInjureInfo接口获取token失败");
                    return ApiResult<List<InjureResDto>>.IsFail("GetInjureInfo接口获取token失败");
                }

                //获取用户配置
                HttpClientResult<LoginUsersConfiguration> loginUsers = await _tokenProviderService.GetUserConfiguration(token);
                if (loginUsers.Code == "Error")
                {
                    _logger.LogWarning("GetInjureInfo接口获取用户配置失败");
                    return ApiResult<List<InjureResDto>>.IsFail("GetInjureInfo接口获取用户配置失败");
                }
                InjureReqDto dto = new()
                {
                    Ubpid = loginUsers.Data.Ubpid,
                    Uid = loginUsers.Data.Uid
                };

                HttpClientResult<object> riskResult = await _tokenProviderService
                  .SendAndParseAsync<InjureReqDto, HttpClientResult<object>>(
           "https://zrh.szdunan.cn/v1/api/risk/init/injure",
           token, dto, HttpMethod.Post);

                if (riskResult != null && riskResult.Data != null && riskResult.Data.ToString()!.Length > 10)
                {
                    List<InjureResDto> httpClientResult = JsonSerializer.Deserialize<List<InjureResDto>>(riskResult.Data.ToString()!)!;
                    if (httpClientResult != null)
                    {
                        result.Data = httpClientResult;
                    }
                }
            }
            catch (Exception ex)
            {
                _logger.LogWarning(ex, "GetInjureInfo接口出错");
                return ApiResult<List<InjureResDto>>.IsFail($"GetInjureInfo接口出错{ex.Message}");
            }

            return result;
        }

        /// <summary>
        /// 得区域（空间）列表树数据
        /// </summary>
        /// <returns></returns>
        /// <exception cref="NotImplementedException"></exception>
        public async Task<ApiResult<RegionStructureRootDto>> GetRegionRootInfo(RegionRootInfoReqDto dto)
        {
            ApiResult<RegionStructureRootDto> result = new ApiResult<RegionStructureRootDto>() { Code = 200, Msg = "接口调用成功", Data = null };

            try
            {
                //获取token
                var token = await _tokenProviderService.GetTokenAsync(_configuration["ThirdParty:SzdunanCode"]!);
                if (string.IsNullOrWhiteSpace(token))
                {
                    _logger.LogWarning("GetRegionRootInfo接口获取token失败");
                    return ApiResult<RegionStructureRootDto>.IsFail("GetRegionRootInfo接口获取token失败");
                }

                //获取用户配置
                HttpClientResult<LoginUsersConfiguration> loginUsers = await _tokenProviderService.GetUserConfiguration(token);
                if (loginUsers.Code == "Error")
                {
                    _logger.LogWarning("GetRegionRootInfo接口获取用户配置失败");
                    return ApiResult<RegionStructureRootDto>.IsFail("GetRegionRootInfo接口获取用户配置失败");
                }
                dto.Ubpid = loginUsers.Data.Ubpid;

                HttpClientResult<object> riskResult = await _tokenProviderService
                  .SendAndParseAsync<RegionRootInfoReqDto, HttpClientResult<object>>(
           "https://zrh.szdunan.cn/v1/api/region/index_no_check_region",
           token, dto, HttpMethod.Post);

                if (riskResult != null && riskResult.Data != null && riskResult.Data.ToString()!.Length > 10)
                {
                    RegionStructureRootDto httpClientResult = JsonSerializer.Deserialize<RegionStructureRootDto>(riskResult.Data.ToString()!)!;
                    if (httpClientResult != null)
                    {
                        result.Data = httpClientResult;
                    }
                }
            }
            catch (Exception ex)
            {
                _logger.LogWarning(ex, "GetRegionRootInfo接口出错");
                return ApiResult<RegionStructureRootDto>.IsFail($"GetRegionRootInfo接口出错{ex.Message}");
            }

            return result;
        }

        /// <summary>
        /// 获得危险作业（施工）数据统计
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        /// <exception cref="NotImplementedException"></exception>
        public async Task<ApiResult<List<StatisticsInfoDto>>> GetStatistics(WorkTaskQueryParamsDto dto)
        {
            ApiResult<List<StatisticsInfoDto>> result = new ApiResult<List<StatisticsInfoDto>>() { Code = 200, Msg = "接口调用成功", Data = null };

            try
            {
                //获取token
                var token = await _tokenProviderService.GetTokenAsync(_configuration["ThirdParty:SzdunanCode"]!);
                if (string.IsNullOrWhiteSpace(token))
                {
                    _logger.LogWarning("GetStatistics接口获取token失败");
                    return ApiResult<List<StatisticsInfoDto>>.IsFail("GetStatistics接口获取token失败");
                }

                //获取用户配置
                HttpClientResult<LoginUsersConfiguration> loginUsers = await _tokenProviderService.GetUserConfiguration(token);
                if (loginUsers.Code == "Error")
                {
                    _logger.LogWarning("GetStatistics接口获取用户配置失败");
                    return ApiResult<List<StatisticsInfoDto>>.IsFail("GetStatistics接口获取用户配置失败");
                }

                //获取单位信息
                HttpClientResult<BranchResDto> branchs = await _tokenProviderService.GetBranchPermissions(token, loginUsers.Data.Uid);
                if (branchs.Code == "Error")
                {
                    _logger.LogWarning("GetStatistics接口获取单位信息失败");
                    return ApiResult<List<StatisticsInfoDto>>.IsFail("GetStatistics接口获取单位信息失败");
                }

                dto.Ubpid = loginUsers.Data.Ubpid.ToString();
                List<StatisticsInfoDto> data = [];

                //查询未开始，status=1、2
                int[] statusNot = [1, 2, 3, 4, 6, 7, 8, 11, 12, 13];

                for (int i = 0; i < statusNot.Length; i++)
                {
                    dto.Status = statusNot[i].ToString();
                    dto.Page = 1;
                    dto.Page_size = 1;
                    HttpClientResult<object> riskResult = await _tokenProviderService
                 .SendAndParseAsync<WorkTaskQueryParamsDto, HttpClientResult<object>>(
          "https://zrh.szdunan.cn/v1/api/ticket/safe/ledger",
          token, dto, HttpMethod.Post);

                    if (riskResult != null && riskResult.Data != null && riskResult.Data.ToString()!.Length > 10)
                    {
                        LedgerDto httpClientResult = JsonSerializer.Deserialize<LedgerDto>(riskResult.Data.ToString()!)!;
                        if (httpClientResult != null)
                        {
                            if (statusNot[i] == 3)
                            {
                                int c = 0;
                                //统计状态为3但是实际结束时间大于计划结束时间的
                                if (httpClientResult.Data != null && httpClientResult.Data.Count > 0)
                                {
                                    for (int j = 0; j < httpClientResult.Data.Count; j++)
                                    {
                                        if (httpClientResult.Data[j].EndAt != "" && httpClientResult.Data[j].FinishTime != "")
                                        {
                                            if (Convert.ToDateTime(httpClientResult.Data[j].EndAt) < Convert.ToDateTime(httpClientResult.Data[j].FinishTime))
                                            {
                                                c++;
                                            }
                                        }
                                    }
                                }
                                StatisticsInfoDto statisticsInfoDto = new()
                                {
                                    Name = statusNot[i].ToString() + "已超时",
                                    Total = httpClientResult.Total,
                                };
                                data.Add(statisticsInfoDto);
                            }
                            else
                            {
                                StatisticsInfoDto statisticsInfoDto = new()
                                {
                                    Name = statusNot[i].ToString(),
                                    Total = httpClientResult.Total,
                                };
                                data.Add(statisticsInfoDto);
                            }
                        }
                    }
                }

                result.Data = MergeStatistics(data);
            }
            catch (Exception ex)
            {
                _logger.LogWarning(ex, "GetStatistics接口出错");
                return ApiResult<List<StatisticsInfoDto>>.IsFail($"GetStatistics接口出错{ex.Message}");
            }

            return result;
        }

        private static List<StatisticsInfoDto> MergeStatistics(List<StatisticsInfoDto> originalStats)
        {
            // 防御性判断：若原始列表为空，返回默认4项（Total均为0）
            if (originalStats == null || !originalStats.Any())
            {
                return
            [
                new() { Name = "未开始", Total = 0 },
                new() { Name = "已结束", Total = 0 },
                new() { Name = "进行中", Total = 0 },
                new() { Name = "已超时", Total = 0 }
            ];
            }

            // 1. 未开始：name=1、2 的Total求和
            var notStartedTotal = originalStats
                .Where(dto => dto.Name is "1" or "2")
                .Sum(dto => dto.Total);

            // 2. 已结束：name=6、7、8、11、12、13 的Total求和
            var finishedTotal = originalStats
                .Where(dto => dto.Name is "6" or "7" or "8" or "11" or "12" or "13")
                .Sum(dto => dto.Total);

            // 3. 进行中：name=3、4 的Total求和（排除"3已超时"）
            var inProgressTotal = originalStats
                .Where(dto => dto.Name is "3" or "4")
                .Sum(dto => dto.Total);

            // 4. 已超时：name="3已超时" 的Total求和
            var timeoutTotal = originalStats
                .Where(dto => dto.Name == "3已超时")
                .Sum(dto => dto.Total);

            // 构造合并后的结果列表
            return
        [
            new() { Name = "未开始", Total = notStartedTotal },
            new() { Name = "已结束", Total = finishedTotal },
            new() { Name = "进行中", Total = inProgressTotal },
            new() { Name = "已超时", Total = timeoutTotal }
        ];
        }

        public async Task<ApiResult<List<DangerHomeResDto>>> GetDangerHome()
        {
            ApiResult<List<DangerHomeResDto>> result = new ApiResult<List<DangerHomeResDto>>() { Code = 200, Msg = "接口调用成功", Data = null };

            try
            {
                //获取token
                var token = await _tokenProviderService.GetTokenAsync(_configuration["ThirdParty:SzdunanCode"]!);
                if (string.IsNullOrWhiteSpace(token))
                {
                    _logger.LogWarning("GetRegionRootInfo接口获取token失败");
                    return ApiResult<List<DangerHomeResDto>>.IsFail("GetRegionRootInfo接口获取token失败");
                }

                //获取用户配置
                HttpClientResult<LoginUsersConfiguration> loginUsers = await _tokenProviderService.GetUserConfiguration(token);
                if (loginUsers.Code == "Error")
                {
                    _logger.LogWarning("GetRegionRootInfo接口获取用户配置失败");
                    return ApiResult<List<DangerHomeResDto>>.IsFail("GetRegionRootInfo接口获取用户配置失败");
                }
                Params dto = new();
                dto.Ubpid = loginUsers.Data.Ubpid;

                HttpClientResult<object> riskResult = await _tokenProviderService
                  .SendAndParseAsync<Params, HttpClientResult<object>>(
           "https://zrh.szdunan.cn/v1/api/home/danger",
           token, dto, HttpMethod.Get);

                if (riskResult != null && riskResult.Data != null && riskResult.Data.ToString()!.Length > 10)
                {
                    DangerStatsRootResDto httpClientResult = JsonSerializer.Deserialize<DangerStatsRootResDto>(riskResult.Data.ToString()!)!;
                    if (httpClientResult != null)
                    {
                        // 定义固定的状态名称（顺序必须与dangerStatusCount数组一致）
                        var statusNames = new List<string>
        {
            "待核查隐患数",
            "待整改隐患数",
            "待验收隐患数",
            "整改完毕隐患数"
        };

                        // 构建结果集合（处理数组长度不匹配的情况）
                        var resultItem = new List<DangerHomeResDto>();
                        for (int i = 0; i < statusNames.Count; i++)
                        {
                            resultItem.Add(new DangerHomeResDto
                            {
                                Name = statusNames[i],
                                Total = httpClientResult?.DangerStatusCount?.ElementAtOrDefault(i) ?? 0
                            });
                        }

                        result.Data = resultItem;
                    }
                }
            }
            catch (Exception ex)
            {
                _logger.LogWarning(ex, "GetRegionRootInfo接口出错");
                return ApiResult<List<DangerHomeResDto>>.IsFail($"GetRegionRootInfo接口出错{ex.Message}");
            }

            return result;
        }
    }
}