fis_lib_jsonrpc/lib/services/liveConsultation.dart

import 'dart:core';

import 'package:fis_jsonrpc/client_base.dart';
import 'package:fis_common/json_convert.dart';

import 'liveConsultation.m.dart';

import 'notification.m.dart';


class LiveConsultationService extends JsonRpcClientBase {
	LiveConsultationService(
		String host, {
		String serviceName = "ILiveConsultationService",
		Map<String, String>? headers,
		int? timeout,
	}) : super(
						host,
						serviceName,
						headers: headers,
						timeout: timeout,
				) {
		/// 注册响应实体反序列化处理器
		FJsonConvert.setDecoder((map) => OrganizationBaseDTO.fromJson(map));
		FJsonConvert.setDecoder((map) => PageResult<OrganizationExpertDTO>.fromJson(map));
		FJsonConvert.setDecoder((map) => OrganizationExpertDTO.fromJson(map));
		FJsonConvert.setDecoder((map) => PageResult<ConsultationPageDTO>.fromJson(map));
		FJsonConvert.setDecoder((map) => ConsultationPageDTO.fromJson(map));
		FJsonConvert.setDecoder((map) => ExportConsultationDataResult.fromJson(map));
		FJsonConvert.setDecoder((map) => ConsultationDetailDTO.fromJson(map));
		FJsonConvert.setDecoder((map) => ConsultationAssistantDTO.fromJson(map));
		FJsonConvert.setDecoder((map) => ConsultationAssistantDoctorDTO.fromJson(map));
		FJsonConvert.setDecoder((map) => PageResult<ClientPatientInfoBaseDTO>.fromJson(map));
		FJsonConvert.setDecoder((map) => ClientPatientInfoBaseDTO.fromJson(map));
		FJsonConvert.setDecoder((map) => InitiateLiveConsultationResult.fromJson(map));
		FJsonConvert.setDecoder((map) => InviteInLiveConsultationResult.fromJson(map));
		FJsonConvert.setDecoder((map) => CancelInvitingInLiveConsultationResult.fromJson(map));
		FJsonConvert.setDecoder((map) => RejectLiveConsultationResult.fromJson(map));
		FJsonConvert.setDecoder((map) => JoinLiveConsultationResult.fromJson(map));
		FJsonConvert.setDecoder((map) => CancelLiveConsultationResult.fromJson(map));
		FJsonConvert.setDecoder((map) => AcceptLiveConsultationResult.fromJson(map));
		FJsonConvert.setDecoder((map) => LeaveLiveConsultationResult.fromJson(map));
		FJsonConvert.setDecoder((map) => MuteLiveConsultationResult.fromJson(map));
		FJsonConvert.setDecoder((map) => SwitchLiveConsultationVideoResult.fromJson(map));
		FJsonConvert.setDecoder((map) => LiveConsultationHeartRateResult.fromJson(map));
		FJsonConvert.setDecoder((map) => FollowUpVisitDTO.fromJson(map));
		FJsonConvert.setDecoder((map) => ConsultationEvaluateDTO.fromJson(map));
		FJsonConvert.setDecoder((map) => GetEmergencySettingResult.fromJson(map));
		FJsonConvert.setDecoder((map) => ConsultationImagesDTO.fromJson(map));
		FJsonConvert.setDecoder((map) => UserExtendDTO.fromJson(map));
		FJsonConvert.setDecoder((map) => ChangeConsultationResult.fromJson(map));
		FJsonConvert.setDecoder((map) => LiveConsultationMember.fromJson(map));
		FJsonConvert.setDecoder((map) => QueryEmergencyDataResult.fromJson(map));
		FJsonConvert.setDecoder((map) => GetConsultationQualityTypeResult.fromJson(map));
	}

	Future<List<OrganizationBaseDTO>> findParentOrganizationsAsync(FindHigherOrganizationsRequest request) async {
		var rpcRst = await call("FindParentOrganizationsAsync", request);
		var result = (rpcRst as List).map((e)=>OrganizationBaseDTO.fromJson(e as Map<String, dynamic>)).toList();
		return result;
	}

	Future<List<OrganizationBaseDTO>> findGrassRootsOrganizationsAsync(FindGrassRootsOrganizationsRequest request) async {
		var rpcRst = await call("FindGrassRootsOrganizationsAsync", request);
		var result = (rpcRst as List).map((e)=>OrganizationBaseDTO.fromJson(e as Map<String, dynamic>)).toList();
		return result;
	}

	Future<PageResult<OrganizationExpertDTO>> findOrganizationExpertsAsync(FindOrganizationExpertsRequest request) async {
		var rpcRst = await call("FindOrganizationExpertsAsync", request);
		var result = PageResult<OrganizationExpertDTO>.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<String> applyConsultationAsync(ApplyConsultationRequest request) async {
		var rpcRst = await call("ApplyConsultationAsync", request);
		return rpcRst;
	}

	Future<bool> updateConsultationAsync(UpdateConsultationRequest request) async {
		var rpcRst = await call("UpdateConsultationAsync", request);
		return rpcRst;
	}

	Future<bool> improveConsultationInfoAsync(ImproveConsultationInfoRequest request) async {
		var rpcRst = await call("ImproveConsultationInfoAsync", request);
		return rpcRst;
	}

	Future<List<OrganizationExpertDTO>> findAssistantExpertsAsync(FindAssistantExpertsRequest request) async {
		var rpcRst = await call("FindAssistantExpertsAsync", request);
		var result = (rpcRst as List).map((e)=>OrganizationExpertDTO.fromJson(e as Map<String, dynamic>)).toList();
		return result;
	}

	Future<PageResult<ConsultationPageDTO>> findConsultationsByPageAsync(FindConsultationByPageRequest request) async {
		var rpcRst = await call("FindConsultationsByPageAsync", request);
		var result = PageResult<ConsultationPageDTO>.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<ExportConsultationDataResult> exportConsultationsAsync(ExportConsultationsRequest request) async {
		var rpcRst = await call("ExportConsultationsAsync", request);
		var result = ExportConsultationDataResult.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<ConsultationDetailDTO> findConsultationDetailAsync(FindConsultationDetailRequest request) async {
		var rpcRst = await call("FindConsultationDetailAsync", request);
		var result = ConsultationDetailDTO.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<bool> approvalConsultationAsync(ApprovalConsultationRequest request) async {
		var rpcRst = await call("ApprovalConsultationAsync", request);
		return rpcRst;
	}

	Future<bool> rejectApplyConsultationAsync(RejectApplyConsultationRequest request) async {
		var rpcRst = await call("RejectApplyConsultationAsync", request);
		return rpcRst;
	}

	Future<bool> revokeConsultationAsync(RevokeConsultationRequest request) async {
		var rpcRst = await call("RevokeConsultationAsync", request);
		return rpcRst;
	}

	Future<bool> deleteConsultationAsync(DeleteConsultationRequest request) async {
		var rpcRst = await call("DeleteConsultationAsync", request);
		return rpcRst;
	}

	Future<bool> updateConsultationFilesInfoAsync(UpdateConsultationFilesInfoRequest request) async {
		var rpcRst = await call("UpdateConsultationFilesInfoAsync", request);
		return rpcRst;
	}

	Future<List<ConsultationAssistantDTO>> findOrganizationAssistantsAsync(FindOrganizationAssistantsRequest request) async {
		var rpcRst = await call("FindOrganizationAssistantsAsync", request);
		var result = (rpcRst as List).map((e)=>ConsultationAssistantDTO.fromJson(e as Map<String, dynamic>)).toList();
		return result;
	}

	Future<List<ConsultationAssistantDoctorDTO>> findOrganizationAssistantDoctorsAsync(FindOrganizationAssistantDoctorsRequest request) async {
		var rpcRst = await call("FindOrganizationAssistantDoctorsAsync", request);
		var result = (rpcRst as List).map((e)=>ConsultationAssistantDoctorDTO.fromJson(e as Map<String, dynamic>)).toList();
		return result;
	}

	Future<bool> updateMyOrganizationAssistantAsync(UpdateMyOrganizationAssistantRequest request) async {
		var rpcRst = await call("UpdateMyOrganizationAssistantAsync", request);
		return rpcRst;
	}

	Future<PageResult<ClientPatientInfoBaseDTO>> findConsultationPatientAsync(FindConsultationPatientPageRequest request) async {
		var rpcRst = await call("FindConsultationPatientAsync", request);
		var result = PageResult<ClientPatientInfoBaseDTO>.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<List<ConsultationPageDTO>> findCanSwitchConsultationsAsync(FindCanSwitchConsultationsRequest request) async {
		var rpcRst = await call("FindCanSwitchConsultationsAsync", request);
		var result = (rpcRst as List).map((e)=>ConsultationPageDTO.fromJson(e as Map<String, dynamic>)).toList();
		return result;
	}

	Future<InitiateLiveConsultationResult> initiateLiveConsultationAsync(InitiateLiveConsultationRequest request) async {
		var rpcRst = await call("InitiateLiveConsultationAsync", request);
		var result = InitiateLiveConsultationResult.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<InviteInLiveConsultationResult> inviteInLiveConsultationAsync(InviteInLiveConsultationRequest request) async {
		var rpcRst = await call("InviteInLiveConsultationAsync", request);
		var result = InviteInLiveConsultationResult.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<CancelInvitingInLiveConsultationResult> cancelInvitingInLiveConsultationAsync(CancelInvitingInLiveConsultationRequest request) async {
		var rpcRst = await call("CancelInvitingInLiveConsultationAsync", request);
		var result = CancelInvitingInLiveConsultationResult.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<RejectLiveConsultationResult> rejectInviteLiveConsultationAsync(RejectLiveConsultationRequest request) async {
		var rpcRst = await call("RejectInviteLiveConsultationAsync", request);
		var result = RejectLiveConsultationResult.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<JoinLiveConsultationResult> joinInLiveConsultationAsync(JoinLiveConsultationRequest request) async {
		var rpcRst = await call("JoinInLiveConsultationAsync", request);
		var result = JoinLiveConsultationResult.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<CancelLiveConsultationResult> cancelLiveConsultationAsync(CancelLiveConsultationRequest request) async {
		var rpcRst = await call("CancelLiveConsultationAsync", request);
		var result = CancelLiveConsultationResult.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<AcceptLiveConsultationResult> acceptLiveConsultationAsync(AcceptLiveConsultationRequest request) async {
		var rpcRst = await call("AcceptLiveConsultationAsync", request);
		var result = AcceptLiveConsultationResult.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<RejectLiveConsultationResult> rejectLiveConsultationAsync(RejectLiveConsultationRequest request) async {
		var rpcRst = await call("RejectLiveConsultationAsync", request);
		var result = RejectLiveConsultationResult.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<JoinLiveConsultationResult> joinLiveConsultationAsync(JoinLiveConsultationRequest request) async {
		var rpcRst = await call("JoinLiveConsultationAsync", request);
		var result = JoinLiveConsultationResult.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<LeaveLiveConsultationResult> leaveLiveConsultationAsync(LeaveLiveConsultationRequest request) async {
		var rpcRst = await call("LeaveLiveConsultationAsync", request);
		var result = LeaveLiveConsultationResult.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<MuteLiveConsultationResult> muteLiveConsultationAsync(MuteLiveConsultationRequest request) async {
		var rpcRst = await call("MuteLiveConsultationAsync", request);
		var result = MuteLiveConsultationResult.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<SwitchLiveConsultationVideoResult> switchLiveConsultationVideoAsync(SwitchLiveConsultationVideoRequest request) async {
		var rpcRst = await call("SwitchLiveConsultationVideoAsync", request);
		var result = SwitchLiveConsultationVideoResult.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<LiveConsultationHeartRateResult> heartRateAsync(LiveConsultationHeartRateRequest request) async {
		var rpcRst = await call("HeartRateAsync", request);
		var result = LiveConsultationHeartRateResult.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<bool> sendInteractiveBoardDataAsync(SendInteractiveBoardDataRequest request) async {
		var rpcRst = await call("SendInteractiveBoardDataAsync", request);
		return rpcRst;
	}

	Future<bool> addFollowUpVisitInfoAsync(AddFollowUpVisitInfoRequest request) async {
		var rpcRst = await call("AddFollowUpVisitInfoAsync", request);
		return rpcRst;
	}

	Future<bool> deleteFollowUpVisitInfoAsync(DeleteFollowUpVisitInfoRequest request) async {
		var rpcRst = await call("DeleteFollowUpVisitInfoAsync", request);
		return rpcRst;
	}

	Future<bool> updateFollowUpVisitInfoAsync(UpdateFollowUpVisitInfoRequest request) async {
		var rpcRst = await call("UpdateFollowUpVisitInfoAsync", request);
		return rpcRst;
	}

	Future<List<FollowUpVisitDTO>> getFollowUpVisitInfoAsync(GetFollowUpVisitInfoRequest request) async {
		var rpcRst = await call("GetFollowUpVisitInfoAsync", request);
		var result = (rpcRst as List).map((e)=>FollowUpVisitDTO.fromJson(e as Map<String, dynamic>)).toList();
		return result;
	}

	Future<FollowUpVisitDTO> getFollowUpVisitInfoDetailAsync(GetFollowUpVisitInfoDetailRequest request) async {
		var rpcRst = await call("GetFollowUpVisitInfoDetailAsync", request);
		var result = FollowUpVisitDTO.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<bool> setNeedFollowUpVisitAsync(SetNeedFollowUpVisitRequest request) async {
		var rpcRst = await call("SetNeedFollowUpVisitAsync", request);
		return rpcRst;
	}

	Future<bool> addConsultationEvaluateAsync(AddConsultationEvaluateRequest request) async {
		var rpcRst = await call("AddConsultationEvaluateAsync", request);
		return rpcRst;
	}

	Future<bool> deleteConsultationEvaluateAsync(DeleteConsultationEvaluateRequest request) async {
		var rpcRst = await call("DeleteConsultationEvaluateAsync", request);
		return rpcRst;
	}

	Future<bool> updateConsultationEvaluateAsync(UpdateConsultationEvaluateRequest request) async {
		var rpcRst = await call("UpdateConsultationEvaluateAsync", request);
		return rpcRst;
	}

	Future<ConsultationEvaluateDTO> getConsultationEvaluateDetailAsync(GetConsultationEvaluateRequest request) async {
		var rpcRst = await call("GetConsultationEvaluateDetailAsync", request);
		var result = ConsultationEvaluateDTO.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<List<String>> findScanPositionsAsync(TokenRequest request) async {
		var rpcRst = await call("FindScanPositionsAsync", request);
		var result = (rpcRst as List).cast<String>().toList();
		return result;
	}

	Future<bool> acceptInvitationAsync(AcceptInvitationRequest request) async {
		var rpcRst = await call("AcceptInvitationAsync", request);
		return rpcRst;
	}

	Future<String> applyEmergencyTreatment(ApplyEmergencyTreatmentRequest request) async {
		var rpcRst = await call("ApplyEmergencyTreatment", request);
		return rpcRst;
	}

	Future<GetEmergencySettingResult> getEmergencySettingAsync(GetEmergencySettingRequest request) async {
		var rpcRst = await call("GetEmergencySettingAsync", request);
		var result = GetEmergencySettingResult.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<bool> controlParameterAsync(ControlDeviceParameterInConsultationRequest request) async {
		var rpcRst = await call("ControlParameterAsync", request);
		return rpcRst;
	}

	Future<UserStatusEnum> getUserStatusAsync(GetUserStatusRequest request) async {
		var rpcRst = await call("GetUserStatusAsync", request);
		var result = UserStatusEnum.values.firstWhere((e) => e.index == rpcRst);
		return result;
	}

	Future<List<ConsultationImagesDTO>> getConsultationFilesAsync(FindConsultationDetailRequest request) async {
		var rpcRst = await call("GetConsultationFilesAsync", request);
		var result = (rpcRst as List).map((e)=>ConsultationImagesDTO.fromJson(e as Map<String, dynamic>)).toList();
		return result;
	}

	Future<List<UserExtendDTO>> getInviteableUserListAsync(GetInviteableUserListRequest request) async {
		var rpcRst = await call("GetInviteableUserListAsync", request);
		var result = (rpcRst as List).map((e)=>UserExtendDTO.fromJson(e as Map<String, dynamic>)).toList();
		return result;
	}

	Future<ChangeConsultationResult> changeConsultationAsync(ChangeConsultationRequest request) async {
		var rpcRst = await call("ChangeConsultationAsync", request);
		var result = ChangeConsultationResult.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<LiveConsultationMember> deviceJoinInLiveConsultationAsync(JoinLiveConsultationRequest request) async {
		var rpcRst = await call("DeviceJoinInLiveConsultationAsync", request);
		var result = LiveConsultationMember.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<QueryEmergencyDataResult> queryEmergencyDataAsync(TokenRequest request) async {
		var rpcRst = await call("QueryEmergencyDataAsync", request);
		var result = QueryEmergencyDataResult.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<bool> acceptRemoteConnnectionAsync(ControlDeviceResponseRequest request) async {
		var rpcRst = await call("AcceptRemoteConnnectionAsync", request);
		return rpcRst;
	}

	Future<bool> syncBatchConsultationAsync(SyncBatchConsultationRequest syncBatchConsultationRequest) async {
		var rpcRst = await call("SyncBatchConsultationAsync", syncBatchConsultationRequest);
		return rpcRst;
	}

	Future<GetConsultationQualityTypeResult> getConsultationReportQualityTypeAsync(GetConsultationReportQualityTypeRequest request) async {
		var rpcRst = await call("GetConsultationReportQualityTypeAsync", request);
		var result = GetConsultationQualityTypeResult.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<bool> addConsultationReportQualityAsync(AddConsultationReportQualityRequest request) async {
		var rpcRst = await call("AddConsultationReportQualityAsync", request);
		return rpcRst;
	}

	Future<bool> modifyConsultationReportQualityAsync(ModifyConsultationReportQualityRequest request) async {
		var rpcRst = await call("ModifyConsultationReportQualityAsync", request);
		return rpcRst;
	}

	Future<bool> deleteConsultationReportQualityAsync(DeleteConsultationReportQualityRequest request) async {
		var rpcRst = await call("DeleteConsultationReportQualityAsync", request);
		return rpcRst;
	}

}