SOMS/src/YunDa.Application/YunDa.ISAS.Application/GeneralInformation/EquipmentLiveData/EquipmentLiveDataAppService.cs

using Abp.Authorization;
using Abp.Domain.Repositories;
using Abp.Domain.Uow;
using Abp.Web.Mvc.Alerts;
using Google.Protobuf;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Mvc.ModelBinding;
using MongoDB.Bson;
using MongoDB.Bson.Serialization;
using MongoDB.Driver;
using NPOI.SS.Formula.Functions;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Linq.Dynamic.Core;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;
using ToolLibrary.LogHelper;
using YunDa.ISAS.Application.Core;
using YunDa.ISAS.Application.Core.Configuration;
using YunDa.ISAS.Application.Core.Session;
using YunDa.ISAS.Application.Core.SwaggerHelper;
using YunDa.ISAS.Core.Helper;
using YunDa.ISAS.DataTransferObject;
using YunDa.ISAS.DataTransferObject.Account;
using YunDa.ISAS.DataTransferObject.GeneralInformation.EquipmentInfoDto;
using YunDa.ISAS.DataTransferObject.GeneralInformation.EquipmentInfoDto.SearchCondition;
using YunDa.ISAS.DataTransferObject.VideoSurveillance.VideoDevDto;
using YunDa.ISAS.Entities.ClientConfiguration.ThreeDimension;
using YunDa.ISAS.Entities.DataMonitoring;
using YunDa.ISAS.Entities.GeneralInformation;
using YunDa.ISAS.Entities.MySQL.DataMonitoring;
using YunDa.ISAS.Entities.VideoSurveillance;
using YunDa.ISAS.MongoDB.Repositories;
using YunDa.ISAS.Redis.Entities.AlarmCategory;
using YunDa.ISAS.Redis.Repositories;
using YunDa.SOMS.DataTransferObject.AlarmDataDto;
using YunDa.SOMS.DataTransferObject.GeneralInformation.EquipmentLiveDataDto;
using YunDa.SOMS.DataTransferObject.MainStationMaintenanceInfo.OperationReport;
using YunDa.SOMS.DataTransferObject.ThirdPartyData.NJJW;
using YunDa.SOMS.Entities.GeneralInformation;
using ZstdSharp.Unsafe;
using JsonSerializer = System.Text.Json.JsonSerializer;

namespace YunDa.ISAS.Application.GeneralInformation
{
    /// <summary>
    /// 设备信息
    /// </summary>
    [Description("设备信息管理服务")]
    public class EquipmentLiveDataAppService : ISASAppServiceBase, IEquipmentLiveDataAppService
    {
        private LoginUserOutput _currentUser;
        private readonly IRepository<EquipmentInfo, Guid> _equipmentInfoRepository;
        private readonly IRepository<VideoDev, Guid> _videoDevRepository;
        private readonly IRepository<LinkageStrategy, Guid> _linkageStrategyRepository;
        private readonly IRepository<MeasureTemperaturePoint, Guid> _measureTemperaturePointRepository;

        private readonly IRepository<EquipmentType, Guid> _equipmentTypeRepository;
        private readonly IRepository<PresetPoint, Guid> _presetPointRepository;
        private readonly IRepository<TelemeteringConfiguration, Guid> _telemeteringConfigurationResitory;
        private readonly IRepository<TelesignalisationConfiguration, Guid> _telesignalisationConfigurationResitory;
        private readonly IRepository<TelecommandConfiguration, Guid> _telecommandConfigurationResitory;
        private readonly IRepository<TelemeteringAlarmStrategy, Guid> _telemeteringAlarmStrategyResitory;
        private readonly IRepository<TelemeteringTemplate, Guid> _telemeteringTemplateResitory;
        private readonly IRedisRepository<object, string> _redisRepository;
        private readonly IUnitOfWorkManager _unitOfWorkManager;
        private readonly  IRedisRepository<EquipmentDataModel, string> _equipmentDataModelDicRedis;
        private readonly IRepository<CCThreeDimension, Guid> _threeDimensionResitory;
        private readonly string _telemeteringModelListRediskey = "telemeteringModelList";
        /// <summary>
        /// 遥测数据实时库
        /// </summary>
        private readonly IRedisRepository<TelemeteringModel, string> _telemeteringModelListRedis;
        private readonly string _telesignalisationModelListRediskey = "telesignalisationModelList";
        /// <summary>
        /// 遥信数据实时库
        /// </summary>
        private readonly IRedisRepository<TelesignalisationModel, string> _telesignalisationModelListRedis;

        private readonly IRedisRepository<EquipmentInfoDiagnoseResult, string> _equipmentInfoDiagnoseResult;
        private readonly IRedisRepository<DiagnoseResultOutPut, string> _diagnoseResultOutPutRedis;


        private readonly IMongoDbRepository<BsonDocument, Guid> _bsonDocumentResultRepository;
        public readonly IRedisRepository<AlarmMessage, string> _alarmMessageRedis;
        private readonly IRedisRepository<AlarmListRedis, string> _redisDataRepository;

        private readonly IRedisRepository<EquipmentInfoSearchRecord, string> _equipmentInfoDetailRedis;
        private readonly IRedisRepository<VideoDevProperty, string> _videoDevPropertyRedis;

        private readonly string _equipmentInfoDetailRedisChannel = "equipmentInfoDetailRedisChannel";

        private readonly string _equipmentInfoDiagnoseResultChanel = "equipmentInfoDiagnoseResultChanel";
        private readonly EquipmentInfoExAppService _equipmentInfoExAppService;
        private readonly IRedisRepository<CheckDefect, string> _checkDefectRedis;

        private readonly IRedisRepository<DiagnosisImageResult, string> _diagnosisImageResult;

        public EquipmentLiveDataAppService(
            IRepository<EquipmentInfo, Guid> repositoryEquipmentInfo
            , IRepository<EquipmentType, Guid> repositoryEquipmentType
            , IRepository<TelemeteringConfiguration, Guid> telemeteringConfigurationResitory
            , IRepository<TelesignalisationConfiguration, Guid> telesignalisationConfigurationResitory
            , IRepository<TelecommandConfiguration, Guid> telecommandConfigurationResitory
            , IRepository<PresetPoint, Guid> presetPointRepository
            , IRepository<TelemeteringAlarmStrategy, Guid> telemeteringAlarmStrategyResitory
            , IRepository<TelemeteringTemplate, Guid> telemeteringTemplateResitory
            , IRepository<VideoDev, Guid> videoDevRepository
            , IRepository<LinkageStrategy, Guid> linkageStrategyRepository
            , IRepository<MeasureTemperaturePoint, Guid> measureTemperaturePointRepository
            , IRedisRepository<object, string> redisRepository
            , IRedisRepository<EquipmentDataModel, string> equipmentDataModelDicRedis
            , IRepository<CCThreeDimension, Guid> threeDimensionResitory
            , IUnitOfWorkManager unitOfWorkManager
            , IRedisRepository<TelemeteringModel, string> telemeteringModelListRedis
            , IRedisRepository<TelesignalisationModel, string> telesignalisationModelListRedis
            , IRedisRepository<EquipmentInfoDiagnoseResult, string> equipmentInfoDiagnoseResult
            , IRedisRepository<EquipmentInfoSearchRecord, string> equipmentInfoDetailRedis
            , EquipmentInfoExAppService equipmentInfoExAppService
            , IAppServiceConfiguration appServiceConfiguration
            , IRedisRepository<DiagnoseResultOutPut, string> diagnoseResultOutPutRedis
            , IMongoDbRepository<BsonDocument, Guid> bsonDocumentResultRepository
            , IRedisRepository<AlarmMessage, string> alarmMessageRedis
            , IRedisRepository<AlarmListRedis, string> redisDataRepository
            , IRedisRepository<CheckDefect, string> checkDefectRedis
            , IRedisRepository<DiagnosisImageResult, string> diagnosisImageResult
            , IRedisRepository<VideoDevProperty, string> videoDevPropertyRedis
            , ISessionAppService sessionAppService) : base(sessionAppService, appServiceConfiguration)
        {
            _equipmentInfoRepository = repositoryEquipmentInfo;
            _equipmentTypeRepository = repositoryEquipmentType;
            _telemeteringConfigurationResitory = telemeteringConfigurationResitory;
            _telesignalisationConfigurationResitory = telesignalisationConfigurationResitory;
            _telecommandConfigurationResitory = telecommandConfigurationResitory;
            _telemeteringAlarmStrategyResitory = telemeteringAlarmStrategyResitory;
            _presetPointRepository = presetPointRepository;
            _telemeteringTemplateResitory = telemeteringTemplateResitory;
            _currentUser = base.GetCurrentUser();
            _unitOfWorkManager = unitOfWorkManager;
            _redisRepository = redisRepository;
            _equipmentDataModelDicRedis = equipmentDataModelDicRedis;
            _threeDimensionResitory = threeDimensionResitory;
            _videoDevRepository = videoDevRepository;
            _linkageStrategyRepository = linkageStrategyRepository;
            _measureTemperaturePointRepository = measureTemperaturePointRepository;
            _telemeteringModelListRedis = telemeteringModelListRedis;
            _telesignalisationModelListRedis = telesignalisationModelListRedis;
            _equipmentInfoDiagnoseResult = equipmentInfoDiagnoseResult;
            _equipmentInfoDetailRedis = equipmentInfoDetailRedis;
            _equipmentInfoExAppService = equipmentInfoExAppService;
            _diagnoseResultOutPutRedis = diagnoseResultOutPutRedis;
            _bsonDocumentResultRepository = bsonDocumentResultRepository;
            _alarmMessageRedis = alarmMessageRedis;
            _redisDataRepository = redisDataRepository;
            _checkDefectRedis = checkDefectRedis;
            _diagnosisImageResult = diagnosisImageResult;
            _videoDevPropertyRedis = videoDevPropertyRedis;
        }
        #region 基础接口
        public RequestPageResult<EquipmentInfoOutput> FindDatas(PageSearchCondition<EquipmentInfoSearchConditionInput> searchCondition)
        {
            throw new NotImplementedException();
        }

        public Task<RequestResult<EquipmentInfoOutput>> CreateOrUpdateAsync(EditEquipmentInfoInput input)
        {
            throw new NotImplementedException();
        }

        public Task<RequestEasyResult> DeleteByIdsAsync(List<Guid> ids)
        {
            throw new NotImplementedException();
        }

        public Task<RequestEasyResult> DeleteByIdAsync(Guid id)
        {
            throw new NotImplementedException();
        }
        #endregion
        /// <summary>
        /// 根据设备id获取设备实时运行数据
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        [HttpGet]
        [AbpAllowAnonymous]
        [ShowApi]
        public async Task<RequestResult<EquipmentDataModel>> GetEquipmentLiveStateByEquipmentId(Guid id)
        {
            RequestResult<EquipmentDataModel> rst = new RequestResult<EquipmentDataModel>();
            if (id == default)
            {
                rst.Message = "设备id为空";
                return rst;
            }
            try
            {
                var dic =  await _equipmentDataModelDicRedis.HashSetGetAllAsync(ConstantModel.EquipmentDataModelDicRedisKey);
                if (dic.Any(t=>t.EquipmentInfoId == id))
                {
                    var equipmentdata = dic.FirstOrDefault(t=> t.EquipmentInfoId == id);
                    var cfgs =  _threeDimensionResitory.GetAll().Where(t => t.EquipmentInfoId == id);
                    equipmentdata.Telemeterings = equipmentdata.Telemeterings.Where(t => cfgs.Any(x => x.TelemeteringConfigurationId == t.Id)).ToList();
                    equipmentdata.Telesignalisations = equipmentdata.Telesignalisations.Where(t => cfgs.Any(x => x.TelesignalisationConfigurationId == t.Id)).ToList();
                    rst.Flag = true;
                    rst.ResultData = equipmentdata;
                }
            }
            catch (Exception ex)
            {
                Log4Helper.Error(this.GetType(), "根据设备id获取设备实时运行数据出错", ex);
            }
            return rst;
        }


        /// <summary>
        /// 根据模型id获取设备实时运行数据
        /// </summary>
        /// <param name="modelId"></param>
        /// <returns></returns>
        [HttpGet]
        [AbpAllowAnonymous]
        [ShowApi]
        public async Task<RequestResult<EquipmentDataModel>> GetEquipmentLiveStateByModelId(int modelId)
        {
            RequestResult<EquipmentDataModel> rst = new RequestResult<EquipmentDataModel>();
            if (modelId == 0)
            {
                rst.Message = "模型id为0";
                return rst;
            }
            try
            {
                var ccDatas = _threeDimensionResitory.GetAll().ToList();
                var dic = await _equipmentDataModelDicRedis.HashSetGetAllAsync(ConstantModel.EquipmentDataModelDicRedisKey);
                var cc = ccDatas.FirstOrDefault(t => t.ModelId == modelId);
                if (dic!=null&&cc != null&& cc.EquipmentInfoId.HasValue)
                {
                    Guid id = cc.EquipmentInfoId.Value;
                    if (dic.Any(t => t.EquipmentInfoId == id))
                    {
                        var equipmentdata = dic.FirstOrDefault(t => t.EquipmentInfoId == id);
                        var cfgs = ccDatas.Where(t => t.EquipmentInfoId == id);
                        equipmentdata.Telemeterings = equipmentdata.Telemeterings.Where(t => cfgs.Any(x => x.TelemeteringConfigurationId == t.Id)).ToList();
                        equipmentdata.Telesignalisations = equipmentdata.Telesignalisations.Where(t => cfgs.Any(x => x.TelesignalisationConfigurationId == t.Id)).ToList();
                        rst.Flag = true;
                        rst.ResultData = equipmentdata;
                    }
                }
               
            }
            catch (Exception ex)
            {
                Log4Helper.Error(this.GetType(), "根据设备id获取设备实时运行数据出错", ex);
            }
            return rst;
        }
        /// <summary>
        /// 设备总览信息
        /// </summary>
        /// <param name="stationId"></param>
        /// <returns></returns>
        [HttpGet]
        [AbpAllowAnonymous]
        [ShowApi]
        public async Task<RequestResult<List<EquimentOverviewOutput>>> GetEquipmentOverviewAsync(Guid stationId)
        {
            RequestResult<List<EquimentOverviewOutput>> rst = new RequestResult<List<EquimentOverviewOutput>>();
            try
            {
                if (stationId == default)
                {
                    Log4Helper.Error(this.GetType(), "传入id为空");

                }
                List<EquimentOverviewOutput> datas = new List<EquimentOverviewOutput>();
                var equipmentTypesRepo = _equipmentTypeRepository.GetAllIncluding(t=>t.EquipmentInfos).OrderBy(t=>t.SeqNo).ToList();

                var typesRepo = equipmentTypesRepo.Where(x => x.EquipmentTypeLevel == EquipmentTypeLevelEnum.Type);
                var equipmentTypeRepo = equipmentTypesRepo.Where(x => x.EquipmentTypeLevel == EquipmentTypeLevelEnum.Equipment);
                var dic = await _equipmentDataModelDicRedis.HashSetGetAllAsync(ConstantModel.EquipmentDataModelDicRedisKey);
                foreach (var item in typesRepo)
                {
                    var equipments =  equipmentTypeRepo.Where(t => t.EquipmentTypeId == item.Id).SelectMany(t => t.EquipmentInfos);
                    var query = from equip in equipments
                                join dataModel in dic on equip.Id equals dataModel.EquipmentInfoId
                                where dataModel.Telemeterings!=null
                                from telemetry in dataModel.Telemeterings
                                where telemetry.ResultValue != -99999
                                select new
                                {
                                    EquipmentId = equip.Id,
                                  
                                    // Include other properties as needed
                                };
                    var query1 = from equip in equipments
                                join dataModel in dic on equip.Id equals dataModel.EquipmentInfoId
                                where dataModel.Telesignalisations != null
                                from telemetry in dataModel.Telesignalisations
                                 where telemetry.ResultValue != -99999
                                select new
                                {
                                    EquipmentId = equip.Id,
                              
                                    // Include other properties as needed
                                };
                    int lineCount = query.Concat(query1).Distinct().Count();
                    datas.Add(new EquimentOverviewOutput
                    {
                        Id = item.Id,
                        SeqNo = datas.Count + 1,
                        Count = equipments.Count(),
                        LineCount = lineCount,
                        IsVisable = true,
                        TypeName = item.Name
                    });
                }
                var video = _videoDevRepository.GetAllIncluding(t=>t.PresetPoints).OrderBy(t=>t.SeqNo).ToList();
                var nvr = video.Where(t => t.VideoDevId == null);
                int nvrOnlineCount = 0;
                //CameraOnlineInfo.GetDeviceConnected( nvr.Select(t=>t.IP).ToList()).Where(t=>t.Value).Count();
               
                datas.Add(new EquimentOverviewOutput
                {
                    Id = default,
                    SeqNo = datas.Count + 1,
                    Count = nvr.Count(),
                    LineCount = nvrOnlineCount,
                    IsVisable = true,
                    TypeName = "NVR",
                    Description = ""

                });

                var camera = video.Where(t => t.VideoDevId != null);
                int cameraOnlineCount = 0;//
                                          //CameraOnlineInfo.GetDeviceConnected(camera.Where(x=> !string.IsNullOrWhiteSpace(x.IP)).Select(t => t.IP).ToList()).Where(t => t.Value).Count();
               
                datas.Add(new EquimentOverviewOutput
                {
                    Id = default,
                    SeqNo = datas.Count + 1,
                    Count = camera.Count(),
                    LineCount = cameraOnlineCount,
                    IsVisable = true,
                    TypeName = "摄像头",
                    Description = ""
                });
                var presetsCount = _presetPointRepository.Count();
                datas.Add(new EquimentOverviewOutput
                {
                    Id = default,
                    SeqNo = datas.Count + 1,
                    Count = presetsCount,
                    LineCount = -1,
                    IsVisable = true,
                    TypeName = "预置位"
                });
                var linkageCount = _linkageStrategyRepository.Count();
                datas.Add(new EquimentOverviewOutput
                {
                    Id = default,
                    SeqNo = datas.Count+1,
                    Count = linkageCount,
                    LineCount = -1,
                    IsVisable = true,
                    TypeName = "联动"
                });
                var measureTempCount = _measureTemperaturePointRepository.Count();
                datas.Add(new EquimentOverviewOutput
                {
                    Id = default,
                    SeqNo = datas.Count + 1,
                    Count = measureTempCount,
                    LineCount = -1,
                    IsVisable = true,
                    TypeName = "测温点"
                });
                rst.ResultData = datas;
                rst.Flag = true;
                //_equipmentInfoRepository.GetAllIncluding(t => t.EquipmentType);
            }
            catch (Exception ex)
            {
                Log4Helper.Error(this.GetType(), "根据设备id获取设备实时运行数据出错", ex);
            }
            return rst;
        }

        /// <summary>
        /// 根据设备id获取设备遥测实时数据
        /// </summary>
        /// <returns></returns>
        [HttpGet]
        [AbpAllowAnonymous]
        [ShowApi]
        public async Task<RequestResult<List<TelemeteringModel>>> GetEquipmentTelemeteringByEquipmentId(Guid equipmentId,int dataSourceCategory)
        {
            RequestResult<List<TelemeteringModel>> rst = new RequestResult<List<TelemeteringModel>> ();
            if (equipmentId == default)
            {
                rst.Message = "设备id为空";
                return rst;
            }
            try
            {
                var telemeterings = await _telemeteringModelListRedis.HashSetGetAllAsync(_telemeteringModelListRediskey + "_" + ((DataSourceCategoryEnum)dataSourceCategory).ToString());

                if (telemeterings == null || telemeterings.Count == 0)
                {
                    rst.ResultData = new List<TelemeteringModel>();
                }
                else
                {
                    var datas = telemeterings
                  .Where(t => t.EquipmentInfoId == equipmentId && t.DataSourceCategory == (DataSourceCategoryEnum)dataSourceCategory)
                  .Where(t => t.Name != "未用" || !t.Name.Contains("预留"))
                  .OrderBy(t => t.DispatcherAddress)
                  .ToList();
                    rst.ResultData = datas;
                }
              
                rst.Flag = true;
            }
            catch (Exception ex)
            {
                Log4Helper.Error(this.GetType(), "根据设备id获取设备遥测实时数据", ex);
            }
            return rst;
        }
        [HttpGet]
        [AbpAllowAnonymous]
        [ShowApi]
        public RequestResult<DateTime> TestTimeFormat()
        {
          
            return new RequestResult<DateTime> { ResultData = DateTime.Now };
        }
        /// <summary>
        /// 根据设备id获取设备遥信实时数据
        /// </summary>
        /// <param name="equipmentId"></param>
        /// <param name="dataSourceCategory"></param>
        /// <returns></returns>
        [HttpGet]
        [AbpAllowAnonymous]
        [ShowApi]
        public async Task<RequestResult<List<TelesignalisationModel>>> GetEquipmentTelesignalisationByEquipmentId(Guid equipmentId, int dataSourceCategory)
        {
            RequestResult<List<TelesignalisationModel>> rst = new RequestResult<List<TelesignalisationModel>>();
            if (equipmentId == default)
            {
                rst.Message = "设备id为空";
                return rst;
            }
            try
            {
                var telemeterings = await _telesignalisationModelListRedis.HashSetGetAllAsync(_telesignalisationModelListRediskey + "_" + ((DataSourceCategoryEnum)dataSourceCategory).ToString());
                if (telemeterings == null|| telemeterings.Count==0)
                {
                    rst.ResultData = new List<TelesignalisationModel>();
                }
                else
                {
                    var datas = telemeterings
                     .Where(t => t.EquipmentInfoId == equipmentId && t.DataSourceCategory == (DataSourceCategoryEnum)dataSourceCategory)
                     .Where(t => t.Name != "未用" || !t.Name.Contains("预留"))
                     .OrderBy(t => t.DispatcherAddress)
                     .ToList();
                    rst.ResultData = datas;
                }
             
                rst.Flag = true;
            }
            catch (Exception ex)
            {
                Log4Helper.Error(this.GetType(), "根据设备id获取设备遥测实时数据", ex);
            }
            return rst;
        }


        
        /// <summary>
        /// 九维发送设备诊断信息到后台
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost]
        [AbpAllowAnonymous]
        [ShowApi]
        [DisableRequestSizeLimit]
        [Route("/soms/api/uploadEquipmentDiagnosis")] // 指定完整路径
        public async Task<RequestEasyResult> UploadEquipmentDiagnosisAsync(object input)
        {
            RequestEasyResult rst = new RequestEasyResult();

            try
            {
                //Log4Helper.Info(this.GetType(), $"九维数据：{input.ToString()}");
                string filePath = $"..\\logs\\九维数据—{Guid.NewGuid()}.txt";

                Directory.CreateDirectory(Path.GetDirectoryName(filePath));
                File.WriteAllText(filePath, input.ToString());

                var options = new JsonSerializerOptions
                {
                    PropertyNameCaseInsensitive = true
                };

                var diagnostic = JsonSerializer.Deserialize<IntelligentDiagnostic>(input.ToString(), options);
                List<DiagnoseResultOutPut> diagnoseResultOutPuts = new List<DiagnoseResultOutPut>();
                DateTime time = DateTime.Now;
                string format = "yyyy-MM-dd HH-mm-ss.fff";
                if (DateTime.TryParseExact(
                        diagnostic?.SaveTime,
                        format,
                        CultureInfo.InvariantCulture,
                        DateTimeStyles.None,
                        out time
                    ))
                {
                    Log4Helper.Info(this.GetType(), time.ToString("yyyy-MM-dd HH:mm:ss.fff"));
                }
                else
                {
                    Log4Helper.Info(this.GetType(), $"时间解析失败：{diagnostic.SaveTime}");

                }
                //电站 运检
                if (diagnostic != null)
                {

                    Log4Helper.Info(this.GetType(), $"SaveTime: {diagnostic.SaveTime}");
                    var equipmentDic = _equipmentInfoRepository.GetAllIncluding(t => t.TransformerSubstation)
                        .Where(t => t.TransformerSubstation.SubstationName.Contains("神池南"))
                        .ToDictionary(t => t.Name);

                    foreach (var item in diagnostic.DiagnoseResult)
                    {
                        if (item.Name.Contains("整体"))
                        {
                            if (item.Device == "电站" || item.Device == "电站诊断")
                            {
                                var diagnoseResultOutPut = diagnoseResultOutPuts.FirstOrDefault(t => t.EquipmentInfoName == "变电所");
                                if (diagnoseResultOutPut == null)
                                {
                                    diagnoseResultOutPuts.Add(new DiagnoseResultOutPut
                                    {
                                        DiagnoseResultName = item.Name,
                                        DiaStatus = item.DiaStatus,
                                        Score = float.Parse(string.IsNullOrEmpty(item.Score) ? "0" : item.Score),
                                        EquipmentInfoName = "变电所",
                                        Suggest = item.Suggest,
                                        Errortype = item.ErrorType,
                                        Time = time,
                                    });
                                }

                            }
                            else if (item.Device == "运检" || item.Device == "运检诊断")
                            {
                                var diagnoseResultOutPut = diagnoseResultOutPuts.FirstOrDefault(t => t.EquipmentInfoName == "运检");

                                if (diagnoseResultOutPut == null)
                                {
                                    diagnoseResultOutPuts.Add(new DiagnoseResultOutPut
                                    {
                                        DiagnoseResultName = item.Name,
                                        DiaStatus = item.DiaStatus,
                                        Score = float.Parse(string.IsNullOrEmpty(item.Score) ? "0" : item.Score),
                                        EquipmentInfoName = "运检",
                                        Suggest = item.Suggest,
                                        Errortype = item.ErrorType,
                                        Time = time,
                                    });
                                }

                            }
                            else
                            {
                                item.Device = item.Device.Replace("诊断", "");
                                item.Name = item.Name.Replace(item.Device, "");
                                var equipmentObjName = equipmentDic.Keys.FirstOrDefault(t => StringHelper.HasMinimumSequentialMatch(t, item.Device));
                                if (!string.IsNullOrWhiteSpace(equipmentObjName))
                                {
                                    if (equipmentDic.ContainsKey(equipmentObjName))
                                    {
                                        diagnoseResultOutPuts.Add(new DiagnoseResultOutPut
                                        {
                                            DiagnoseResultName = item.Name,
                                            DiaStatus = item.DiaStatus,
                                            Score = float.Parse(string.IsNullOrEmpty(item.Score) ? "0" : item.Score),
                                            EquipmentInfoName = equipmentObjName,
                                            Suggest = item.Suggest,
                                            Errortype = item.ErrorType,
                                            EquipmentInfoId = equipmentDic[equipmentObjName].Id,
                                            Time = time,
                                        });
                                    }
                                }
                                    
                            }
                        }

                    }

                    foreach (var item in diagnostic.DiagnoseResult)
                    {
                        if (!item.Name.Contains("整体"))
                        {
                            if (item.Device == "电站" || item.Device == "电站诊断")
                            {

                                var diagnoseResultOutPut = diagnoseResultOutPuts.FirstOrDefault(t => t.EquipmentInfoName == "变电所");
                                if (diagnoseResultOutPut != null)
                                {
                                    diagnoseResultOutPut.DiagnoseContentItems.Add(new DiagnoseContent
                                    {
                                        DiagnoseResultName = item.Name,
                                        DiaStatus = item.DiaStatus,
                                        Score = float.Parse(string.IsNullOrEmpty(item.Score) ? "0" : item.Score),
                                        Errortype = item.ErrorType,
                                        Suggest = item.Suggest,
                                        Time = time,

                                    });
                                }


                            }
                            else if (item.Device == "运检" || item.Device == "运检诊断")
                            {
                                var diagnoseResultOutPut = diagnoseResultOutPuts.FirstOrDefault(t => t.EquipmentInfoName == "运检");
                                if (diagnoseResultOutPut != null)
                                {
                                    diagnoseResultOutPut.DiagnoseContentItems.Add(new DiagnoseContent
                                    {
                                        DiagnoseResultName = item.Name,
                                        DiaStatus = item.DiaStatus,
                                        Score = float.Parse(string.IsNullOrEmpty(item.Score) ? "0" : item.Score),
                                        Errortype = item.ErrorType,
                                        Time = time,
                                        Suggest = item.Suggest
                                    });
                                }
                            }
                            else
                            {
                                item.Device = item.Device.Replace("诊断", "");
                                item.Name = item.Name.Replace(item.Device, "");
                               

                                var equipmentObjName = equipmentDic.Keys.FirstOrDefault(t => StringHelper.HasMinimumSequentialMatch(t, item.Device));
                                if (!string.IsNullOrWhiteSpace(equipmentObjName))
                                {
                                    if (equipmentDic.ContainsKey(equipmentObjName))
                                    {
                                        var diagnoseResultOutPut = diagnoseResultOutPuts.FirstOrDefault(t => t.EquipmentInfoName == equipmentObjName);

                                        if (diagnoseResultOutPut != null)
                                        {
                                            diagnoseResultOutPut.DiagnoseContentItems.Add(new DiagnoseResultOutPut
                                            {
                                                DiagnoseResultName = item.Name,
                                                DiaStatus = item.DiaStatus,
                                                Score = float.Parse(string.IsNullOrEmpty(item.Score) ? "0" : item.Score),
                                                EquipmentInfoName = equipmentObjName,
                                                Suggest = item.Suggest,
                                                Errortype = item.ErrorType,
                                                Time = time,

                                                EquipmentInfoId = equipmentDic[equipmentObjName].Id
                                            });
                                        }
                                    }
                                }

                            }
                        }

                    }

                    foreach (var item in diagnoseResultOutPuts)
                    {
                        var dataItems = diagnostic.Data.Where(t => t.Name.Contains(item.EquipmentInfoName));
                        item.DataItems = dataItems.ToList();
                    }

                }
                var rediskeys = diagnoseResultOutPuts.Select(t => t.EquipmentInfoName).ToList();
                _diagnoseResultOutPutRedis.HashSetUpdateManyAsync(nameof(DiagnoseResultOutPut), rediskeys, diagnoseResultOutPuts);
                foreach (var diagnoseResultOutPut in diagnoseResultOutPuts)
                {
                    if (diagnoseResultOutPut.DiaStatus != "正常")
                    {
                        var alarmId = $"{diagnoseResultOutPut.EquipmentInfoName}:{diagnoseResultOutPut.DiagnoseResultName}";

                        var alarmMessage = new AlarmMessage
                        {
                            HandlingMeasures = diagnoseResultOutPut.Suggest,
                            AlarmContent = diagnoseResultOutPut.Errortype,
                            AlarmDateTime = time.ToString("yyyy-MM-dd HH:mm:ss"),
                            Id = alarmId,
                            AlarmObject = $"{diagnoseResultOutPut.EquipmentInfoName}|{diagnoseResultOutPut.DiagnoseResultName}",
                            AlarmLevel = GetAlarmLevelStr(diagnoseResultOutPut.DiaStatus),
                            EquipmentInfoId = diagnoseResultOutPut.EquipmentInfoId,
                            DataSourceCategory = "在线监测",
                            IsConfirm = false,
                            AlarmType = "健康诊断",
                        };
                        if (!string.IsNullOrEmpty(diagnoseResultOutPut.Errortype))
                        {
                            if (IsTrueAlarm(diagnoseResultOutPut.Suggest))
                            {
                                _alarmMessageRedis.PublishAsync("alarmMessageChannel", alarmMessage);
                                _alarmMessageRedis.HashSetUpdateOneAsync(nameof(AlarmMessage), alarmId, alarmMessage);
                                ChecKAlarm(alarmMessage, diagnoseResultOutPut.Suggest);
                            }

                        }
                    }
                    foreach (var diaItem in diagnoseResultOutPut.DiagnoseContentItems)
                    {
                        if (diaItem.DiaStatus != "正常")
                        {
                            var alarmId = $"{diagnoseResultOutPut.EquipmentInfoName}:{diaItem.DiagnoseResultName}";
                            var alarmMessage = new AlarmMessage
                            {
                                HandlingMeasures = diaItem.Suggest,
                                AlarmContent = diaItem.Errortype,
                                AlarmDateTime = time.ToString("yyyy-MM-dd HH:mm:ss"),
                                Id = alarmId,
                                AlarmObject = $"{diagnoseResultOutPut.EquipmentInfoName}|{diagnoseResultOutPut.DiagnoseResultName}",
                                AlarmLevel = GetAlarmLevelStr(diagnoseResultOutPut.DiaStatus),
                                EquipmentInfoId = diagnoseResultOutPut.EquipmentInfoId,
                                EquipmentInfoName = diagnoseResultOutPut.EquipmentInfoName,
                                DataSourceCategory = "在线监测",
                                IsConfirm = false,
                                AlarmType = "健康诊断",
                            };
                            if (!string.IsNullOrEmpty(diaItem.Errortype))
                            {

                                if (IsTrueAlarm(diaItem.Suggest))
                                {
                                    _alarmMessageRedis.PublishAsync("alarmMessageChannel", alarmMessage);
                                    _alarmMessageRedis.HashSetUpdateOneAsync(nameof(AlarmMessage), alarmId, alarmMessage);
                                    ChecKAlarm(alarmMessage, diaItem.Suggest);
                                }
                                else
                                {
                                    ChecKAlarm(alarmMessage, diaItem.Suggest,"在线监测设备");

                                }
                            }

                        }
                        await _diagnoseResultOutPutRedis.PublishAsync(_equipmentInfoDiagnoseResultChanel, diagnoseResultOutPut);
                        await Task.Delay(10);
                    }
                    _bsonDocumentResultRepository.CollectionName = nameof(DiagnoseResultOutPut);
                    await _bsonDocumentResultRepository.InsertManyAsync(diagnoseResultOutPuts.Select(t => t.ToBsonDocument()));

                    var yuanjian = diagnoseResultOutPuts.FirstOrDefault(t => t.EquipmentInfoName == "运检");
                   
                    // 保存或处理 jsonString

                    rst.Flag = true;
                }
            }
            catch (Exception ex)
            {
                Log4Helper.Error(this.GetType(), "获取实时环境数据出错", ex);
            }
            return rst;
        }
        /// <summary>
        /// 是否为可信报警
        /// </summary>
        /// <param name="suggest"></param>
        /// <returns></returns>
        private bool IsTrueAlarm(string suggest)
        {
            return !suggest.Contains("输入数据异常");
        }
        /// <summary>
        /// 获取报警级别
        /// </summary>
        /// <param name="status"></param>
        /// <returns></returns>
        private string GetAlarmLevelStr(string status)
        {
            string resStr = "告知";
            if (status.Contains("异常"))
            {
                resStr = "异常";
            }
            else if (status.Contains("报警"))
            {
                resStr = "告知";
            }
            return resStr;
        }
        private void ChecKAlarm(AlarmMessage alarm, string suggest, string category ="一次设备")
        {
            
            var checkDefect = new CheckDefect
            {
                Content = alarm.AlarmContent,
                DateTime = alarm.AlarmDateTime,
                Id = alarm.Id,
                DataSourceCategory = category,
                IsConfirm = false,
                EquipmentInfoId = alarm.EquipmentInfoId,
                HandlingMeasures = suggest,
                Level = alarm.AlarmLevel,
                Object = alarm.AlarmObject,
                Type = alarm.AlarmType,
                Analysis = "",
            };
            _checkDefectRedis.HashSetUpdateOneAsync(nameof(CheckDefect), checkDefect.Id, checkDefect);
        }

        /// <summary>
        /// 导航到客户端详细页面
        /// </summary>
        /// <param name="equipemntInfoId"></param>
        /// <returns></returns>
        [HttpPost]
        [AbpAllowAnonymous]
        [ShowApi]
        [DisableRequestSizeLimit]
        public async Task<RequestEasyResult> NavigateToClientEquipmentDetailAsync(string equipemntInfoId)
        {
            RequestEasyResult rst = new RequestEasyResult();

            try
            {
                if (equipemntInfoId!=default)
                {
                     var tempData = await _equipmentInfoExAppService.FindEquipmentSearchRecordAsync(default);
                    var equipmentInfo =  tempData.ResultData.FirstOrDefault(t => t.Id == Guid.Parse( equipemntInfoId));
                    if (equipmentInfo == null)
                    {
                       await NavigateToClientCameraAsync(equipemntInfoId);
                    }
                    else
                    {
                        await _equipmentInfoDetailRedis.PublishAsync(_equipmentInfoDetailRedisChannel, equipmentInfo);
                    }
                    rst.Flag = true;
                }
                else
                {
                    Log4Helper.Error(this.GetType(), "导航到客户端详细页面：设备ID为空");
                }


            }
            catch (Exception ex)
            {
                Log4Helper.Error(this.GetType(), "导航到客户端详细页面", ex);
            }
            return rst;
        }
        /// <summary>
        /// 导航到客户端视频页面
        /// </summary>
        /// <param name="equipemntInfoId"></param>
        /// <returns></returns>
        [HttpPost]
        [AbpAllowAnonymous]
        [ShowApi]
        [DisableRequestSizeLimit]
        public async Task<RequestEasyResult> NavigateToClientCameraAsync(string cameraId)
        {
            RequestEasyResult rst = new RequestEasyResult();

            try
            {
                if (cameraId != default)
                {
                    var tempData = _videoDevRepository.GetAllIncluding(t => t.Parent,t=>t.ManufacturerInfo).FirstOrDefault(t => t.Id == Guid.Parse(cameraId));
                    if (tempData!=null)
                    {
                         var resData = ObjectMapper.Map<VideoDevProperty>(tempData);
                        await _videoDevPropertyRedis.PublishAsync("CameraInfo", resData);
                        rst.Flag = true;
                    }
                   
                }
                else
                {
                    Log4Helper.Error(this.GetType(), "导航到客户端详细页面：设备ID为空");
                }

            }
            catch (Exception ex)
            {
                Log4Helper.Error(this.GetType(), "导航到客户端详细页面", ex);
            }
            return rst;
        }
       

        [HttpPost, AbpAllowAnonymous]
        [ShowApi]
        [UnitOfWork(false)]
        [DisableRequestSizeLimit]
        [RequestFormLimits(ValueLengthLimit = int.MaxValue, MultipartBodyLengthLimit = int.MaxValue)]
        public async Task<RequestEasyResult> UploadEquipmentDiagnosisImageAsync(
            [FromQuery] string deviceName,
            string description,
            [FromForm] IFormFile file = null,
            IFormFile datafile = null)
        {
            RequestEasyResult rst = new RequestEasyResult();
            try
            {
                // 检查设备是否存在
                var equipments = _equipmentInfoRepository.GetAll().ToList()
                    .GroupBy(t => t.Name)
                    .ToDictionary(g => g.Key, g => g.First());

                if (!equipments.ContainsKey(deviceName))
                {
                    rst.Message = $"设备名称不存在:{deviceName}";
                    Log4Helper.Info(GetType(), rst.Message);
                    return rst;
                }

                // 验证至少上传一个文件
                if (file == null && datafile == null)
                {
                    rst.Message = "必须上传至少一个文件";
                    return rst;
                }

                // 处理图片文件
                string imagePath = null, imageUrl = null;
                //if (file != null)
                //{
                //    var imgResult = await ProcessFileAsync(file, deviceName, "Images",
                //        new[] { ".jpg", ".jpeg", ".png", ".svg", ".bmp" });
                //    if (!imgResult.Success)
                //    {
                //        rst.Message = imgResult.Message;
                //        return rst;
                //    }
                //    (imagePath, imageUrl) = (imgResult.FilePath, imgResult.Url);
                //}

                // 处理数据文件
                string dataPath = null, dataUrl = null;
                DateTime dataTimestamp = DateTime.Now;
                int[] dataArray = null;

                
//#if DEBUG
//                Random random = new Random();
//                dataArray = new int[100];

//                for (int i = 0; i < dataArray.Length; i++)
//                {
//                    dataArray[i] = random.Next(10, 31);  // 生成 10 到 30 之间的随机整数（31 不包括）
//                }
//#else
                if (datafile != null)
                {
                    var dataResult = await ProcessFileAsync(datafile, deviceName, "DataFiles",
                        new[] { ".csv", ".txt", ".xlsx", ".json", ".dat", "" });
                    if (!dataResult.Success)
                    {
                        rst.Message = dataResult.Message;
                        return rst;
                    }

                    (dataPath, dataUrl) = (dataResult.FilePath, dataResult.Url);

                    // 解析数据文件中的时间和数据
                    using (var reader = new StreamReader(datafile.OpenReadStream(), Encoding.Default))
                    {
                        string line = await reader.ReadLineAsync();  // 读取第一行时间戳
                        if (!string.IsNullOrEmpty(line) && DateTime.TryParse(line.Trim('[', ']', ' '), out var timestamp))
                        {
                            dataTimestamp = timestamp;
                        }

                        // 解析数据部分
                        line = await reader.ReadLineAsync();  // 读取第二行数据
                        if (!string.IsNullOrEmpty(line))
                        {
                            dataArray = line.Split(',')
                                            .Select(x => int.TryParse(x, out var num) ? num : 0)
                                            .ToArray();
                        }
                    }
                }
//#endif

                // 保存记录到数据库
                var diagnosisRecord = new DiagnosisImageResult
                {
                    EquipmentInfoId = equipments[deviceName].Id,
                    EquipmentInfoName = deviceName,
                    Time = dataTimestamp,
                    ImagePath = imagePath,
                    ImageUrl = imageUrl,
                    DataFilePath = dataPath,
                    DataFileUrl = dataUrl,
                    Description = description,
                    DataArray = dataArray,
                    DataType = 1
                };

                _bsonDocumentResultRepository.CollectionName = nameof(DiagnosisImageResult);
                await _bsonDocumentResultRepository.InsertOneAsync(diagnosisRecord.ToBsonDocument());
                rst.Flag = true;
                Log4Helper.Info(GetType(), $"上传成功 - 设备：{deviceName}，描述：{description}");
            }
            catch (Exception ex)
            {
                rst.Message = ex.Message;
                Log4Helper.Error(GetType(), "上传设备诊断文件失败", ex);
            }
            return rst;
        }


        private async Task<(bool Success, string Message, string FilePath, string Url)>
            ProcessFileAsync(IFormFile file, string deviceName, string fileType, string[] allowedExtensions)
        {
            try
            {
                // 验证文件类型
                var extension = Path.GetExtension(file.FileName).ToLowerInvariant();
                if (!allowedExtensions.Contains(extension))
                {
                    return (false, $"不支持的文件类型：{extension}", null, null);
                }

                // 创建存储目录
                var uploadDir = Path.Combine(
                    base.GetAttachmentDirectory(),
                    "Uploads",
                    deviceName,
                    DateTime.Now.ToString("yyyy-MM-dd"),
                    fileType);

                Directory.CreateDirectory(uploadDir); // 自动存在检查

                // 生成唯一文件名
                var fileName = $"{Guid.NewGuid():N}_{DateTime.Now:HHmmss}{extension}";
                var fullPath = Path.Combine(uploadDir, fileName);

                // 保存文件
                using (var stream = new FileStream(fullPath, FileMode.Create))
                {
                    await file.CopyToAsync(stream);
                }

                return (true, null, fullPath, fullPath.Replace(base.GetAttachmentDirectory(), ""));
            }
            catch (Exception ex)
            {
                Log4Helper.Error(GetType(), $"处理{fileType}文件失败", ex);
                return (false, ex.Message, null, null);
            }
        }
        [HttpGet]
        [AbpAllowAnonymous]
        [ShowApi]
        [DisableRequestSizeLimit]
        public async Task<RequestResult<List<DiagnosisImageResult>>> GetEquipmentDiagnoseResultAsync(Guid equipmentId,
            int dataType,
            DateTime? startTime = null,
            DateTime? endTime = null
            )
        {
            RequestResult<List<DiagnosisImageResult>> rst = new RequestResult<List<DiagnosisImageResult>>();
            try
            {
                _bsonDocumentResultRepository.CollectionName = nameof(DiagnosisImageResult);

                // 计算时间范围，默认查询最近1小时的数据
                DateTime defaultStartTime = DateTime.Now.AddHours(-1);
                DateTime defaultEndTime = DateTime.Now;

                DateTime queryStartTime = startTime ?? defaultStartTime;
                DateTime queryEndTime = endTime ?? defaultEndTime;

                // 构建查询条件
                var filterBuilder = Builders<BsonDocument>.Filter;
                var filter = filterBuilder.Eq("EquipmentInfoId", equipmentId) & 
                             filterBuilder.Eq("DataType", dataType) &
                             filterBuilder.Gte("Time", queryStartTime) &
                             filterBuilder.Lte("Time", queryEndTime);

                // 按时间降序排序
                SortDefinition<BsonDocument> sortDefinition = Builders<BsonDocument>.Sort.Descending("Time");

                // 查询数据
                var bsonDocuments = _bsonDocumentResultRepository
                    .GetAllIncludeToFindFluent(filter, sort: sortDefinition)
                    .Limit(15*60*24);  // 新增限制查询结果数量;

                if (bsonDocuments != null && bsonDocuments.Any())
                {
                    var diagnosisImageResults = bsonDocuments.ToList().Select(doc => BsonSerializer.Deserialize<DiagnosisImageResult>(doc)).ToList();
                    rst.ResultData = diagnosisImageResults;
                }
                else
                {
                    rst.Message = "未找到符合条件的设备诊断结果";
                }
                rst.Flag = true;
            }
            catch (Exception ex)
            {
                Log4Helper.Error(this.GetType(), "获取设备诊断结果", ex);
                rst.Message = "查询设备诊断结果时发生异常";
            }
            return rst;
        }

        [HttpPost]
        [AbpAllowAnonymous]
        [ShowApi]
        [DisableRequestSizeLimit]
        [RequestFormLimits(ValueLengthLimit = int.MaxValue, MultipartBodyLengthLimit = int.MaxValue)]
        [Route("/soms/api/voiceprint/upload")]
        public async Task<RequestResult<VoiceprintData>> UploadVoiceprintAsync(
            [FromForm] IFormFile voiceprint_data,
            [FromForm] string image_data,
            [FromForm] string analysis_result)
        {
            var result = new RequestResult<VoiceprintData>();
            try
            {
                // Validate required parameters
                if (voiceprint_data == null)
                {
                    result.Message = "缺少必要参数: voiceprint_data";
                    return result;
                }

                if (string.IsNullOrEmpty(image_data))
                {
                    result.Message = "缺少必要参数: image_data";
                    return result;
                }

                if (string.IsNullOrEmpty(analysis_result))
                {
                    result.Message = "缺少必要参数: analysis_result";
                    return result;
                }

                // Validate file type
                var extension = Path.GetExtension(voiceprint_data.FileName).ToLowerInvariant();
                if (!new[] { ".wav", ".pcm" }.Contains(extension))
                {
                    result.Message = "不支持的文件类型，仅支持.wav和.pcm格式";
                    return result;
                }

                // Validate file size (100MB limit)
                if (voiceprint_data.Length > 100 * 1024 * 1024)
                {
                    result.Message = "文件大小超过限制(100MB)";
                    return result;
                }

                // Parse analysis result
                VoiceprintData voiceprintData;
                try
                {
                    voiceprintData = JsonSerializer.Deserialize<VoiceprintData>(analysis_result);
                }
                catch (JsonException)
                {
                    result.Message = "JSON解析失败";
                    return result;
                }

                // Generate unique ID if not provided
                if (string.IsNullOrEmpty(voiceprintData.VoiceprintId))
                {
                    voiceprintData.VoiceprintId = $"VP_{DateTime.Now:yyyyMMdd_HHmmss}";
                }

                // Create storage directory
                var uploadDir = Path.Combine(
                    base.GetAttachmentDirectory(),
                    "Uploads",
                    "Voiceprints",
                    DateTime.Now.ToString("yyyy-MM-dd"));

                Directory.CreateDirectory(uploadDir);

                // Save voiceprint file
                var fileName = $"{voiceprintData.VoiceprintId}{extension}";
                var fullPath = Path.Combine(uploadDir, fileName);
                using (var stream = new FileStream(fullPath, FileMode.Create))
                {
                    await voiceprint_data.CopyToAsync(stream);
                }

                // Save image if provided
                if (image_data.StartsWith("data:image/"))
                {
                    try
                    {
                        var base64Data = image_data.Split(',')[1];
                        var imageBytes = Convert.FromBase64String(base64Data);
                        var imagePath = Path.Combine(uploadDir, $"{voiceprintData.VoiceprintId}.png");
                        await File.WriteAllBytesAsync(imagePath, imageBytes);
                        voiceprintData.ImageSaved = true;
                    }
                    catch
                    {
                        result.Message = "Base64解码失败";
                        return result;
                    }
                }

                // Update paths
                voiceprintData.SavedPath = fullPath.Replace(base.GetAttachmentDirectory(), "");
                voiceprintData.Timestamp = DateTime.Now;

                // Save to MongoDB
                _bsonDocumentResultRepository.CollectionName = nameof(VoiceprintData);
                await _bsonDocumentResultRepository.InsertOneAsync(voiceprintData.ToBsonDocument());

                result.ResultData = voiceprintData;
                result.Flag = true;
                result.Message = "操作成功";
            }
            catch (Exception ex)
            {
                Log4Helper.Error(this.GetType(), "上传声纹数据失败", ex);
                result.Message = "服务器存储失败";
            }
            return result;
        }
    }
}