FISLib_Old/Vinno.vCloud.Common.FIS/Helper/JsonRpcHelper.cs

using JsonRpcLite.Services;
using System;
using System.Collections.Generic;
using System.Net.Http;
using System.Text.Json;
using Vinno.IUS.Common.Log;
using Vinno.vCloud.Common.FIS.Remedicals;
using WingInterfaceLibrary.DTO.Device;
using WingInterfaceLibrary.DTO.Organization;
using WingInterfaceLibrary.DTO.RemoteParameters;
using WingInterfaceLibrary.DTO.ServerInfo;
using WingInterfaceLibrary.DTO.Storage;
using WingInterfaceLibrary.Interface;
using WingInterfaceLibrary.LiveConsultation;
using WingInterfaceLibrary.Request;
using WingInterfaceLibrary.Request.Device;
using WingInterfaceLibrary.Request.Education;
using WingInterfaceLibrary.Request.Examine;
using WingInterfaceLibrary.Request.FastestServer;
using WingInterfaceLibrary.Request.Record;
using WingInterfaceLibrary.Request.Remote;
using WingInterfaceLibrary.Request.Storage;
using WingInterfaceLibrary.Request.Upgrade;
using WingInterfaceLibrary.Request.User;
using WingInterfaceLibrary.Result;
using WingInterfaceLibrary.Result.Education;
using WingInterfaceLibrary.Result.Examine;
using WingInterfaceLibrary.Result.Languge;
using WingInterfaceLibrary.Result.Upgrade;

namespace Vinno.vCloud.Common.FIS.Helper
{
    internal static class JsonRpcHelper
    {
        #region IConnectService

        internal static ConnectResultInfo Connect(IConnectService connectService, ConnectRequest connectRequest)
        {
            try
            {
                var result = connectService.ConnectAsync(connectRequest).GetAwaiter().GetResult();
                return new ConnectResultInfo(true, 0, result?.UniqueCode, result?.Token);
            }
            catch (RpcException rpcExcetpion)
            {
                Logger.WriteLineError($"ConnectAsync Error,ErrorCode:{rpcExcetpion.ErrorCode},ErrorMsg:{rpcExcetpion.InternalMessage} ");
                return new ConnectResultInfo(false, rpcExcetpion.ErrorCode, string.Empty, string.Empty);
            }
            catch (Exception ex)
            {
                Logger.WriteLineError($"ConnectAsync Error,ErrorMsg:{ex}");
                return new ConnectResultInfo(false, -1, string.Empty, string.Empty);
            }
        }

        internal static CacheDeviceDTO GetDeviceByToken(IConnectService connectService, TokenRequest tokenRequest)
        {
            try
            {
                return connectService.GetDeviceByTokenAsync(tokenRequest).GetAwaiter().GetResult(); ;
            }
            catch (RpcException rpcExcetpion)
            {
                Logger.WriteLineError($"GetDeviceByTokenAsync Error,ErrorCode:{rpcExcetpion.ErrorCode},ErrorMsg:{rpcExcetpion.InternalMessage} ");
            }
            catch (Exception ex)
            {
                Logger.WriteLineError($"GetDeviceByTokenAsync Error,ErrorMsg:{ex}");
            }
            return null;
        }

        internal static bool Disconnect(IConnectService connectService, TokenRequest tokenRequest)
        {
            try
            {
                return connectService.DisConnectAsync(tokenRequest).GetAwaiter().GetResult();
            }
            catch (RpcException rpcExcetpion)
            {
                Logger.WriteLineError($"DisConnectAsync Error,ErrorCode:{rpcExcetpion.ErrorCode},ErrorMsg:{rpcExcetpion.InternalMessage} ");
            }
            catch (Exception ex)
            {
                Logger.WriteLineError($"DisConnectAsync Error,ErrorMsg:{ex}");
            }
            return false;
        }

        internal static bool SetDeviceIsEncryptedShow(IConnectService connectService, SetDeviceIsEncryptedShowRequest setDeviceIsEncryptedShowRequest)
        {
            try
            {
                return connectService.SetDeviceIsEncryptedShowAsync(setDeviceIsEncryptedShowRequest).GetAwaiter().GetResult();
            }
            catch (RpcException rpcExcetpion)
            {
                Logger.WriteLineError($"SetDeviceIsEncryptedShowAsync Error,ErrorCode:{rpcExcetpion.ErrorCode},ErrorMsg:{rpcExcetpion.InternalMessage} ");
            }
            catch (Exception ex)
            {
                Logger.WriteLineError($"SetDeviceIsEncryptedShowAsync Error,ErrorMsg:{ex}");
            }
            return false;
        }

        #endregion IConnectService

        #region IDeviceService

        internal static DeviceServerSettingResult QueryServerConfig(IDeviceService deviceService, TokenRequest tokenRequest)
        {
            try
            {
                return deviceService.QueryServerConfigAsync(tokenRequest).GetAwaiter().GetResult();
            }
            catch (RpcException rpcExcetpion)
            {
                Logger.WriteLineError($"QueryServerConfigAsync Error,ErrorCode:{rpcExcetpion.ErrorCode},ErrorMsg:{rpcExcetpion.InternalMessage} ");
            }
            catch (Exception ex)
            {
                Logger.WriteLineError($"QueryServerConfigAsync Error,ErrorMsg:{ex}");
            }
            return null;
        }

        internal static bool ReportLiveState(IDeviceService deviceService, ReportLiveStateRequest reportLiveStateRequest)
        {
            try
            {
                Logger.WriteLineInfo($"IDeviceService ReportLiveStateAsync:{JsonSerializer.Serialize(reportLiveStateRequest)}");
                return deviceService.ReportLiveStateAsync(reportLiveStateRequest).GetAwaiter().GetResult();
            }
            catch (RpcException rpcExcetpion)
            {
                Logger.WriteLineError($"ReportLiveStateAsync Error,ErrorCode:{rpcExcetpion.ErrorCode},ErrorMsg:{rpcExcetpion.InternalMessage} ");
            }
            catch (Exception ex)
            {
                Logger.WriteLineError($"ReportLiveStateAsync Error,ErrorMsg:{ex}");
            }
            return false;
        }

        internal static CreateLiveRoomInfoResult CreateLiveRoomInfo(IDeviceService deviceService, CreateLiveRoomInfoRequest createLiveRoomInfoRequest)
        {
            try
            {
                Logger.WriteLineInfo($"IDeviceService CreateLiveRoomInfoAsync:{JsonSerializer.Serialize(createLiveRoomInfoRequest)}");
                return deviceService.CreateLiveRoomInfoAsync(createLiveRoomInfoRequest).GetAwaiter().GetResult();
            }
            catch (RpcException rpcExcetpion)
            {
                Logger.WriteLineError($"CreateLiveRoomInfoAsync Error,ErrorCode:{rpcExcetpion.ErrorCode},ErrorMsg:{rpcExcetpion.InternalMessage} ");
            }
            catch (Exception ex)
            {
                Logger.WriteLineError($"CreateLiveRoomInfoAsync Error,ErrorMsg:{ex}");
            }
            return null;
        }

        internal static List<string> GetBrands(IDeviceService deviceService, GetBrandsRequest getBrandsRequest)
        {
            try
            {
                return deviceService.GetBrandsAsync(getBrandsRequest).GetAwaiter().GetResult();
            }
            catch (RpcException rpcExcetpion)
            {
                Logger.WriteLineError($"GetBrandsAsync Error,ErrorCode:{rpcExcetpion.ErrorCode},ErrorMsg:{rpcExcetpion.InternalMessage} ");
            }
            catch (Exception ex)
            {
                Logger.WriteLineError($"GetBrandsAsync Error,ErrorMsg:{ex}");
            }
            return new List<string>();
        }

        internal static List<string> GetModels(IDeviceService deviceService, GetModelsRequest getModelsRequest)
        {
            try
            {
                Logger.WriteLineInfo($"IDeviceService GetModelsAsync:{JsonSerializer.Serialize(getModelsRequest)}");
                return deviceService.GetModelsAsync(getModelsRequest).GetAwaiter().GetResult();
            }
            catch (RpcException rpcExcetpion)
            {
                Logger.WriteLineError($"GetModelsAsync Error,ErrorCode:{rpcExcetpion.ErrorCode},ErrorMsg:{rpcExcetpion.InternalMessage} ");
            }
            catch (Exception ex)
            {
                Logger.WriteLineError($"GetModelsAsync Error,ErrorMsg:{ex}");
            }
            return new List<string>();
        }

        internal static List<BrandModelOutputConfigDTO> SyncBrandModelOutputConfig(IDeviceService deviceService, SyncBrandModelOutputConfigRequest syncBrandModelOutputConfigRequest)
        {
            try
            {
                Logger.WriteLineInfo($"IDeviceService SyncBrandModelOutputConfigAsync:{JsonSerializer.Serialize(syncBrandModelOutputConfigRequest)}");
                return deviceService.SyncBrandModelOutputConfigAsync(syncBrandModelOutputConfigRequest).GetAwaiter().GetResult();
            }
            catch (RpcException rpcExcetpion)
            {
                Logger.WriteLineError($"SyncBrandModelOutputConfigAsync Error,ErrorCode:{rpcExcetpion.ErrorCode},ErrorMsg:{rpcExcetpion.InternalMessage} ");
            }
            catch (Exception ex)
            {
                Logger.WriteLineError($"SyncBrandModelOutputConfigAsync Error,ErrorMsg:{ex}");
            }
            return new List<BrandModelOutputConfigDTO>();
        }

        internal static ReportVideoDeviceInfoResult ReportVideoDeviceInfo(IDeviceService deviceService, ReportVideoDeviceInfoRequest reportVideoDeviceInfoRequest)
        {
            try
            {
                Logger.WriteLineInfo($"IDeviceService ReportVideoDeviceInfoAsync:{JsonSerializer.Serialize(reportVideoDeviceInfoRequest)}");
                return deviceService.ReportVideoDeviceInfoAsync(reportVideoDeviceInfoRequest).GetAwaiter().GetResult();
            }
            catch (RpcException rpcExcetpion)
            {
                Logger.WriteLineError($"ReportVideoDeviceInfoAsync Error,ErrorCode:{rpcExcetpion.ErrorCode},ErrorMsg:{rpcExcetpion.InternalMessage} ");
            }
            catch (Exception ex)
            {
                Logger.WriteLineError($"ReportVideoDeviceInfoAsync Error,ErrorMsg:{ex}");
            }
            return null;
        }

        internal static bool SendControlParameterByDevice(IDeviceService deviceService, SendControlParameterByDeviceRequest sendControlParameterByDeviceRequest)
        {
            try
            {
                Logger.WriteLineInfo($"IDeviceService SendControlParameterByDeviceAsync:{JsonSerializer.Serialize(sendControlParameterByDeviceRequest)}");
                return deviceService.SendControlParameterByDeviceAsync(sendControlParameterByDeviceRequest).GetAwaiter().GetResult();
            }
            catch (RpcException rpcExcetpion)
            {
                Logger.WriteLineError($"SendControlParameterByDeviceAsync Error,ErrorCode:{rpcExcetpion.ErrorCode},ErrorMsg:{rpcExcetpion.InternalMessage} ");
            }
            catch (Exception ex)
            {
                Logger.WriteLineError($"SendControlParameterByDeviceAsync Error,ErrorMsg:{ex}");
            }
            return false;
        }

        internal static bool AcceptRemoteConnnectionInDeviceService(IDeviceService deviceService, ControlDeviceResponseRequest controlDeviceResponseRequest)
        {
            try
            {
                Logger.WriteLineInfo($"IDeviceService AcceptRemoteConnnectionAsync:{JsonSerializer.Serialize(controlDeviceResponseRequest)}");
                return deviceService.AcceptRemoteConnnectionAsync(controlDeviceResponseRequest).GetAwaiter().GetResult();
            }
            catch (RpcException rpcExcetpion)
            {
                Logger.WriteLineError($"AcceptRemoteConnnectionInDeviceService Error,ErrorCode:{rpcExcetpion.ErrorCode},ErrorMsg:{rpcExcetpion.InternalMessage} ");
            }
            catch (Exception ex)
            {
                Logger.WriteLineError($"AcceptRemoteConnnection Error,ErrorMsg:{ex}");
            }
            return false;
        }

        internal static bool DisconnectRemoteControl(IDeviceService deviceService, RemoteConnectStautsRequest remoteConnectStautsRequest)
        {
            try
            {
                Logger.WriteLineInfo($"IDeviceService DisconnectRemoteControl:{JsonSerializer.Serialize(remoteConnectStautsRequest)}");
                return deviceService.DisconnectRemoteControl(remoteConnectStautsRequest).GetAwaiter().GetResult();
            }
            catch (RpcException rpcExcetpion)
            {
                Logger.WriteLineError($"DisconnectRemoteControl Error,ErrorCode:{rpcExcetpion.ErrorCode},ErrorMsg:{rpcExcetpion.InternalMessage} ");
            }
            catch (Exception ex)
            {
                Logger.WriteLineError($"DisconnectRemoteControl Error,ErrorMsg:{ex}");
            }
            return false;
        }

        internal static bool UploadDeviceDownloadPatchProgressToUser(IDeviceService deviceService, UploadDeviceDownloadPatchProgressToUserRequest uploadDeviceDownloadPatchProgressToUserRequest)
        {
            try
            {
                Logger.WriteLineInfo($"IDeviceService UploadDeviceDownloadPatchProgressToUserAsync:{JsonSerializer.Serialize(uploadDeviceDownloadPatchProgressToUserRequest)}");
                return deviceService.UploadDeviceDownloadPatchProgressToUserAsync(uploadDeviceDownloadPatchProgressToUserRequest).GetAwaiter().GetResult();
            }
            catch (RpcException rpcExcetpion)
            {
                Logger.WriteLineError($"UploadDeviceDownloadPatchProgressToUserAsync Error,ErrorCode:{rpcExcetpion.ErrorCode},ErrorMsg:{rpcExcetpion.InternalMessage} ");
            }
            catch (Exception ex)
            {
                Logger.WriteLineError($"UploadDeviceDownloadPatchProgressToUserAsync Error,ErrorMsg:{ex}");
            }
            return false;
        }

        internal static bool ResponseRemoteLog(IDeviceService deviceService, RemoteLogResponseRequest remoteLogResponseRequest)
        {
            try
            {
                Logger.WriteLineInfo($"IDeviceService ResponseRemoteLogAsync:{JsonSerializer.Serialize(remoteLogResponseRequest)}");
                return deviceService.ResponseRemoteLogAsync(remoteLogResponseRequest).GetAwaiter().GetResult();
            }
            catch (RpcException rpcExcetpion)
            {
                Logger.WriteLineError($"ResponseRemoteLog Error,ErrorCode:{rpcExcetpion.ErrorCode},ErrorMsg:{rpcExcetpion.InternalMessage} ");
            }
            catch (Exception ex)
            {
                Logger.WriteLineError($"ResponseRemoteLogAsync Error,ErrorMsg:{ex}");
            }
            return false;
        }

        internal static bool UploadDevicePrinter(IDeviceService deviceService, UploadDevicePrinterRequest uploadDevicePrinterRequest)
        {
            try
            {
                Logger.WriteLineInfo($"IDeviceService UploadDevicePrinterAsync:{JsonSerializer.Serialize(uploadDevicePrinterRequest)}");
                return deviceService.UploadDevicePrinterAsync(uploadDevicePrinterRequest).GetAwaiter().GetResult();
            }
            catch (RpcException rpcExcetpion)
            {
                Logger.WriteLineError($"UploadDevicePrinterAsync Error,ErrorCode:{rpcExcetpion.ErrorCode},ErrorMsg:{rpcExcetpion.InternalMessage} ");
            }
            catch (Exception ex)
            {
                Logger.WriteLineError($"UploadDevicePrinterAsync Error,ErrorMsg:{ex}");
            }
            return false;
        }

        internal static bool DeviceRemoteConnectHeartRate(IDeviceService deviceService, RemoteConnectHeartRateRequest remoteConnectHeartRateRequest)
        {
            try
            {
                return deviceService.DeviceRemoteConnectHeartRateAsync(remoteConnectHeartRateRequest).GetAwaiter().GetResult();
            }
            catch (RpcException rpcExcetpion)
            {
                Logger.WriteLineError($"DeviceRemoteConnectHeartRateAsync Error,ErrorCode:{rpcExcetpion.ErrorCode},ErrorMsg:{rpcExcetpion.InternalMessage} ");
            }
            catch (Exception ex)
            {
                Logger.WriteLineError($"DeviceRemoteConnectHeartRateAsync Error,ErrorMsg:{ex}");
            }
            return false;
        }

        internal static bool HeartRate(IDeviceService deviceService, TokenRequest tokenRequest)
        {
            try
            {
                return deviceService.HeartRateAsync(tokenRequest).GetAwaiter().GetResult();
            }
            catch (RpcException rpcExcetpion)
            {
                Logger.WriteLineError($"HeartRateAsync Error,ErrorCode:{rpcExcetpion.ErrorCode},ErrorMsg:{rpcExcetpion.InternalMessage} ");
            }
            catch (Exception ex)
            {
                Logger.WriteLineError($"HeartRateAsync Error,ErrorMsg:{ex}");
            }
            return false;
        }

        internal static string SendResultToClient(IDeviceService deviceService, SendResultToClientRequest sendResultToClientRequest)
        {
            try
            {
                Logger.WriteLineInfo($"IDeviceService SendResultToClientAsync:{JsonSerializer.Serialize(sendResultToClientRequest)}");
                return deviceService.SendResultToClientAsync(sendResultToClientRequest).GetAwaiter().GetResult();
            }
            catch (RpcException rpcExcetpion)
            {
                Logger.WriteLineError($"SendResultToClientAsync Error,ErrorCode:{rpcExcetpion.ErrorCode},ErrorMsg:{rpcExcetpion.InternalMessage} ");
            }
            catch (Exception ex)
            {
                Logger.WriteLineError($"SendResultToClientAsync Error,ErrorMsg:{ex}");
            }
            return "";
        }

        internal static string GetResultFromServer(IDeviceService deviceService, GetResultFromServerRequest getResultFromServerRequest)
        {
            try
            {
                return deviceService.GetResultFromServerAsync(getResultFromServerRequest).GetAwaiter().GetResult();
            }
            catch (RpcException rpcExcetpion)
            {
                Logger.WriteLineError($"GetResultFromServerAsync Error,ErrorCode:{rpcExcetpion.ErrorCode},ErrorMsg:{rpcExcetpion.InternalMessage} ");
            }
            catch (Exception ex)
            {
                Logger.WriteLineError($"GetResultFromServerAsync Error,ErrorMsg:{ex}");
            }
            return "";
        }

        internal static bool DeviceCancelLogDownload(IDeviceService deviceService, DeivceCancelLogDownloadRequest deivceCancelLogDownloadRequest)
        {
            try
            {
                return deviceService.DeviceCancelLogDownloadAsync(deivceCancelLogDownloadRequest).GetAwaiter().GetResult();
            }
            catch (RpcException rpcExcetpion)
            {
                Logger.WriteLineError($"DeviceCancelLogDownloadAsync Error,ErrorCode:{rpcExcetpion.ErrorCode},ErrorMsg:{rpcExcetpion.InternalMessage} ");
            }
            catch (Exception ex)
            {
                Logger.WriteLineError($"DeviceCancelLogDownloadAsync Error,ErrorMsg:{ex}");
            }
            return false;
        }

        internal static ProbeApplicationSettingInfoDTO GetProbeApplicationSetting(IDeviceService deviceService, GetControlParametersRequest getControlParametersRequest)
        {
            try
            {
                return deviceService.GetProbeApplicationSettingAsync(getControlParametersRequest).GetAwaiter().GetResult();
            }
            catch (RpcException rpcExcetpion)
            {
                Logger.WriteLineError($"GetProbeApplicationSettingAsync Error,ErrorCode:{rpcExcetpion.ErrorCode},ErrorMsg:{rpcExcetpion.InternalMessage} ");
            }
            catch (Exception ex)
            {
                Logger.WriteLineError($"GetProbeApplicationSettingAsync Error,ErrorMsg:{ex}");
            }
            return null;
        }

        internal static bool ResponseProbeApplicationSetting(IDeviceService deviceService, ProbeApplicationSettingResultRequest probeApplicationSettingResultRequest)
        {
            try
            {
                Logger.WriteLineInfo($"IDeviceService ResponseProbeApplicationSettingAsync:{JsonSerializer.Serialize(probeApplicationSettingResultRequest)}");
                return deviceService.ResponseProbeApplicationSettingAsync(probeApplicationSettingResultRequest).GetAwaiter().GetResult();
            }
            catch (RpcException rpcExcetpion)
            {
                Logger.WriteLineError($"ResponseProbeApplicationSettingAsync Error,ErrorCode:{rpcExcetpion.ErrorCode},ErrorMsg:{rpcExcetpion.InternalMessage} ");
            }
            catch (Exception ex)
            {
                Logger.WriteLineError($"ResponseProbeApplicationSettingAsync Error,ErrorMsg:{ex}");
            }
            return false;
        }

        #endregion IDeviceService

        #region ILiveConsultationService

        internal static bool AcceptRemoteConnnectionInLiveConsultationService(ILiveConsultationService liveConsultationService, ControlDeviceResponseRequest controlDeviceResponseRequest)
        {
            try
            {
                Logger.WriteLineInfo($"ILiveConsultationService AcceptRemoteConnnectionAsync:{JsonSerializer.Serialize(controlDeviceResponseRequest)}");
                return liveConsultationService.AcceptRemoteConnnectionAsync(controlDeviceResponseRequest).GetAwaiter().GetResult();
            }
            catch (RpcException rpcExcetpion)
            {
                Logger.WriteLineError($"AcceptRemoteConnnectionInLiveConsultationService Error,ErrorCode:{rpcExcetpion.ErrorCode},ErrorMsg:{rpcExcetpion.InternalMessage} ");
            }
            catch (Exception ex)
            {
                Logger.WriteLineError($"AcceptRemoteConnnectionInLiveConsultationService Error,ErrorMsg:{ex}");
            }
            return false;
        }

        internal static LiveConsultationHeartRateResult HeartRate(ILiveConsultationService liveConsultationService, LiveConsultationHeartRateRequest liveConsultationHeartRateRequest)
        {
            try
            {
                return liveConsultationService.HeartRateAsync(liveConsultationHeartRateRequest).GetAwaiter().GetResult();
            }
            catch (RpcException rpcExcetpion)
            {
                Logger.WriteLineError($"LiveConsultation HeartRateAsync Error,ErrorCode:{rpcExcetpion.ErrorCode},ErrorMsg:{rpcExcetpion.InternalMessage} ");
            }
            catch (Exception ex)
            {
                Logger.WriteLineError($"LiveConsultation HeartRateAsync Error,ErrorMsg:{ex}");
            }
            return null;
        }

        #endregion ILiveConsultationService

        #region IRemedicalService

        internal static CreateExaminfoResult CreateExamInfo(IRemedicalService remedicalService, CreateExaminfoRequest createExaminfoRequest)
        {
            try
            {
                Logger.WriteLineInfo($"IRemedicalService CreateExamInfoAsync:{JsonSerializer.Serialize(createExaminfoRequest)}");
                return remedicalService.CreateExamInfoAsync(createExaminfoRequest).GetAwaiter().GetResult();
            }
            catch (RpcException rpcExcetpion)
            {
                Logger.WriteLineError($"CreateExamInfoAsync Error,ErrorCode:{rpcExcetpion.ErrorCode},ErrorMsg:{rpcExcetpion.InternalMessage} ");
            }
            catch (Exception ex)
            {
                Logger.WriteLineError($"CreateExamInfoAsync Error,ErrorMsg:{ex}");
            }
            return null;
        }

        /// <summary>
        ///
        /// </summary>
        /// <param name="remedicalService"></param>
        /// <param name="uploadExamDataRequest"></param>
        /// <returns>0为上传成功，-1为上传失败，大于0时为上传失败的代码</returns>
        internal static ResultInfo UploadExamData(IRemedicalService remedicalService, UploadExamDataRequest uploadExamDataRequest)
        {
            try
            {
                Logger.WriteLineInfo($"IRemedicalService UploadExamDataAsync:{JsonSerializer.Serialize(uploadExamDataRequest)}");
                var result = remedicalService.UploadExamDataAsync(uploadExamDataRequest).GetAwaiter().GetResult();
                return new ResultInfo(result, 0);
            }
            catch (RpcException rpcExcetpion)
            {
                Logger.WriteLineError($"UploadExamDataAsync Error,ErrorCode:{rpcExcetpion.ErrorCode},ErrorMsg:{rpcExcetpion.InternalMessage} ");
                return new ResultInfo(false, rpcExcetpion.ErrorCode);
            }
            catch (Exception ex)
            {
                Logger.WriteLineError($"UploadExamDataAsync Error,ErrorMsg:{ex}");
                return new ResultInfo(false, -1);
            }
        }

        internal static bool DeviceFinishExam(IRemedicalService remedicalService, DeviceFinishExamRequest deviceFinishExamRequest)
        {
            try
            {
                Logger.WriteLineInfo($"IRemedicalService DeviceFinishExamAsync:{JsonSerializer.Serialize(deviceFinishExamRequest)}");
                return remedicalService.DeviceFinishExamAsync(deviceFinishExamRequest).GetAwaiter().GetResult();
            }
            catch (RpcException rpcExcetpion)
            {
                Logger.WriteLineError($"DeviceFinishExamAsync Error,ErrorCode:{rpcExcetpion.ErrorCode},ErrorMsg:{rpcExcetpion.InternalMessage} ");
            }
            catch (Exception ex)
            {
                Logger.WriteLineError($"DeviceFinishExamAsync Error,ErrorMsg:{ex}");
            }
            return false;
        }

        internal static PageResult<QueryExamListItemResult> QueryExamList(IRemedicalService remedicalService, QueryExamListRequest queryExamListRequest)
        {
            try
            {
                Logger.WriteLineInfo($"IRemedicalService QueryExamListAsync:{JsonSerializer.Serialize(queryExamListRequest)}");
                return remedicalService.QueryExamListAsync(queryExamListRequest).GetAwaiter().GetResult();
            }
            catch (RpcException rpcExcetpion)
            {
                Logger.WriteLineError($"QueryExamListAsync Error,ErrorCode:{rpcExcetpion.ErrorCode},ErrorMsg:{rpcExcetpion.InternalMessage} ");
            }
            catch (Exception ex)
            {
                Logger.WriteLineError($"QueryExamListAsync Error,ErrorMsg:{ex}");
            }
            return null;
        }

        internal static QueryExamInfoResult QueryExamInfo(IRemedicalService remedicalService, QueryExamInfoRequest queryExamInfoRequest)
        {
            try
            {
                Logger.WriteLineInfo($"IRemedicalService QueryExamInfoAsync:{JsonSerializer.Serialize(queryExamInfoRequest)}");
                return remedicalService.QueryExamInfoAsync(queryExamInfoRequest).GetAwaiter().GetResult();
            }
            catch (RpcException rpcExcetpion)
            {
                Logger.WriteLineError($"QueryExamInfoAsync Error,ErrorCode:{rpcExcetpion.ErrorCode},ErrorMsg:{rpcExcetpion.InternalMessage} ");
            }
            catch (Exception ex)
            {
                Logger.WriteLineError($"QueryExamInfoAsync Error,ErrorMsg:{ex}");
            }
            return null;
        }

        internal static string GetCollcetingRecordCode(IRemedicalService remedicalService, TokenRequest tokenRequest)
        {
            try
            {
                return remedicalService.GetCollcetingRecordCodeAsync(tokenRequest).GetAwaiter().GetResult();
            }
            catch (RpcException rpcExcetpion)
            {
                Logger.WriteLineError($"LiveConsultation GetCollcetingRecordCodeAsync Error,ErrorCode:{rpcExcetpion.ErrorCode},ErrorMsg:{rpcExcetpion.InternalMessage} ");
            }
            catch (Exception ex)
            {
                Logger.WriteLineError($"LiveConsultation GetCollcetingRecordCodeAsync Error,ErrorMsg:{ex}");
            }
            return null;
        }

        #endregion IRemedicalService

        #region IVinnoServerService

        internal static List<ServerInfoDTO> GetServerInfoList(IVinnoServerService vinnoServerService, QueryServerInfoRequest queryServerInfoRequest)
        {
            try
            {
                return vinnoServerService.GetServerInfoListAsync(queryServerInfoRequest).GetAwaiter().GetResult();
            }
            catch (RpcException rpcExcetpion)
            {
                Logger.WriteLineError($"GetServerInfoListAsync Error,ErrorCode:{rpcExcetpion.ErrorCode},ErrorMsg:{rpcExcetpion.InternalMessage} ");
            }
            catch (Exception ex)
            {
                Logger.WriteLineError($"GetServerInfoListAsync Error,ErrorMsg:{ex}");
            }
            return new List<ServerInfoDTO>();
        }

        internal static EchoResult Echo(IVinnoServerService vinnoServerService)
        {
            try
            {
                return vinnoServerService.EchoAsync().GetAwaiter().GetResult();
            }
            catch (RpcException rpcExcetpion)
            {
                Logger.WriteLineError($"EchoAsync Error,ErrorCode:{rpcExcetpion.ErrorCode},ErrorMsg:{rpcExcetpion.InternalMessage} ");
            }
            catch (HttpRequestException)
            {
                Logger.WriteLineError($"EchoAsync Error:HttpRequestException");
            }
            catch (Exception ex)
            {
                Logger.WriteLineError($"EchoAsync Error,ErrorMsg:{ex}");
            }
            return null;
        }

        #endregion IVinnoServerService

        #region IStorageService

        internal static StorageServiceSettingDTO GetAuthorization(IStorageService storageService, FileServiceRequest fileServiceRequest)
        {
            try
            {
                return storageService.GetAuthorizationAsync(fileServiceRequest).GetAwaiter().GetResult();
            }
            catch (RpcException rpcExcetpion)
            {
                Logger.WriteLineError($"GetAuthorizationAsync Error,ErrorCode:{rpcExcetpion.ErrorCode},ErrorMsg:{rpcExcetpion.InternalMessage} ");
            }
            catch (Exception ex)
            {
                Logger.WriteLineError($"GetAuthorizationAsync Error,ErrorMsg:{ex}");
            }
            return null;
        }

        internal static StorageServiceSettingDTO GetStorageTestUrl(IStorageService storageService, CheckStorageRequest checkStorageRequest)
        {
            try
            {
                return storageService.GetStorageTestUrlAsync(checkStorageRequest).GetAwaiter().GetResult();
            }
            catch (RpcException rpcExcetpion)
            {
                Logger.WriteLineError($"GetStorageTestUrl Error,ErrorCode:{rpcExcetpion.ErrorCode},ErrorMsg:{rpcExcetpion.InternalMessage} ");
            }
            catch (Exception ex)
            {
                Logger.WriteLineError($"GetStorageTestUrl Error,ErrorMsg:{ex}");
            }
            return null;
        }

        #endregion IStorageService

        #region IUpgradeService

        internal static GetUpgradeInfoResult GetUpgradeInfo(IUpgradeService upgradeService, GetUpgradeInfoRequest getUpgradeInfoRequest)
        {
            try
            {
                return upgradeService.GetUpgradeInfoAsync(getUpgradeInfoRequest).GetAwaiter().GetResult();
            }
            catch (RpcException rpcExcetpion)
            {
                Logger.WriteLineError($"GetUpgradeInfoAsync Error,ErrorCode:{rpcExcetpion.ErrorCode},ErrorMsg:{rpcExcetpion.InternalMessage} ");
            }
            catch (Exception ex)
            {
                Logger.WriteLineError($"GetUpgradeInfoAsync Error,ErrorMsg:{ex}");
            }
            return null;
        }

        #endregion IUpgradeService

        #region IEducationService

        internal static LiveHeartRateResult HeartRate(IEducationService educationService, LiveHeartRateRequest liveHeartRateRequest)
        {
            try
            {
                return educationService.HeartRateAsync(liveHeartRateRequest).GetAwaiter().GetResult();
            }
            catch (RpcException rpcExcetpion)
            {
                Logger.WriteLineError($"EducationService HeartRateAsync Error,ErrorCode:{rpcExcetpion.ErrorCode},ErrorMsg:{rpcExcetpion.InternalMessage} ");
            }
            catch (Exception ex)
            {
                Logger.WriteLineError($"EducationService HeartRateAsync Error,ErrorMsg:{ex}");
            }
            return null;
        }

        #endregion IEducationService

        #region IOrganizationService

        internal static OrganizationDTO GetOrganizationByCode(IOrganizationService organizationService, GetOrganizationByCodeRequest getOrganizationByCodeRequest)
        {
            try
            {
                return organizationService.GetOrganizationByCodeAsync(getOrganizationByCodeRequest).GetAwaiter().GetResult();
            }
            catch (RpcException rpcExcetpion)
            {
                Logger.WriteLineError($"LiveConsultation GetOrganizationByCodeAsync Error,ErrorCode:{rpcExcetpion.ErrorCode},ErrorMsg:{rpcExcetpion.InternalMessage} ");
            }
            catch (Exception ex)
            {
                Logger.WriteLineError($"LiveConsultation GetOrganizationByCodeAsync Error,ErrorMsg:{ex}");
            }
            return null;
        }

        #endregion IOrganizationService
    }
}