fis_lib_jsonrpc/lib/services/remedical.dart

import 'dart:core';

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

import 'remedical.m.dart';

import 'liveConsultation.m.dart';
import 'recordInfo.m.dart';
import 'organization.m.dart';
import 'patient.m.dart';


class RemedicalService extends JsonRpcClientBase {
	RemedicalService(
		String host, {
		String serviceName = "IRemedicalService",
		Map<String, String>? headers,
		int? timeout,
	}) : super(
						host,
						serviceName,
						headers: headers,
						timeout: timeout,
				) {
		/// 注册响应实体反序列化处理器
		FJsonConvert.setDecoder((map) => CreateExaminfoResult.fromJson(map));
		FJsonConvert.setDecoder((map) => UploadExamDataForOldVersionResult.fromJson(map));
		FJsonConvert.setDecoder((map) => RemedicalInfoDTO.fromJson(map));
		FJsonConvert.setDecoder((map) => RemedicalListResult.fromJson(map));
		FJsonConvert.setDecoder((map) => PageResult<RemedicalListResult>.fromJson(map));
		FJsonConvert.setDecoder((map) => DataItemDTO.fromJson(map));
		FJsonConvert.setDecoder((map) => OrganizationSettingResult.fromJson(map));
		FJsonConvert.setDecoder((map) => QueryReservationResult.fromJson(map));
		FJsonConvert.setDecoder((map) => PageResult<QueryExamInfoResult>.fromJson(map));
		FJsonConvert.setDecoder((map) => QueryExamInfoResult.fromJson(map));
		FJsonConvert.setDecoder((map) => MeasureApplicationDTO.fromJson(map));
		FJsonConvert.setDecoder((map) => CommentItemResultDTO.fromJson(map));
		FJsonConvert.setDecoder((map) => PresetCommentItemResultDTO.fromJson(map));
		FJsonConvert.setDecoder((map) => MeasureSystemSettingDTO.fromJson(map));
		FJsonConvert.setDecoder((map) => ExportRemedicalDataResult.fromJson(map));
		FJsonConvert.setDecoder((map) => GetFileCompressInfoResult.fromJson(map));
		FJsonConvert.setDecoder((map) => PageResult<QueryReferralRecordPageDTO>.fromJson(map));
		FJsonConvert.setDecoder((map) => QueryReferralRecordPageDTO.fromJson(map));
		FJsonConvert.setDecoder((map) => OrganizationDTO.fromJson(map));
		FJsonConvert.setDecoder((map) => ClientPatientInfoDTO.fromJson(map));
		FJsonConvert.setDecoder((map) => ReferralRecordDetailDTO.fromJson(map));
		FJsonConvert.setDecoder((map) => PageResult<GetRecordsPageDTO>.fromJson(map));
		FJsonConvert.setDecoder((map) => GetRecordsPageDTO.fromJson(map));
		FJsonConvert.setDecoder((map) => ReportDTO.fromJson(map));
		FJsonConvert.setDecoder((map) => QueryShareExamPageResult.fromJson(map));
		FJsonConvert.setDecoder((map) => RemedicalAISelectedInfoDTO.fromJson(map));
	}

	Future<CreateExaminfoResult> createExamInfoAsync(CreateExaminfoRequest request) async {
		var rpcRst = await call("CreateExamInfoAsync", request);
		var result = CreateExaminfoResult.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<UploadExamDataForOldVersionResult> uploadExamDataForOldVersionAsync(UploadExamDataRequest request) async {
		var rpcRst = await call("UploadExamDataForOldVersionAsync", request);
		var result = UploadExamDataForOldVersionResult.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<bool> uploadExamDataAsync(UploadExamDataRequest request) async {
		var rpcRst = await call("UploadExamDataAsync", request);
		return rpcRst;
	}

	Future<RemedicalInfoDTO> findRemedicalByCodeAsync(FindRemedicalByCodeRequest request) async {
		var rpcRst = await call("FindRemedicalByCodeAsync", request);
		var result = RemedicalInfoDTO.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<bool> addToRemedicalDiagnosisAsync(AddToRemedicalDiagnosisRequest request) async {
		var rpcRst = await call("AddToRemedicalDiagnosisAsync", request);
		return rpcRst;
	}

	Future<bool> addToRemedicalDiagnosisJumpQueueAsync(AddToRemedicalDiagnosisRequest request) async {
		var rpcRst = await call("AddToRemedicalDiagnosisJumpQueueAsync", request);
		return rpcRst;
	}

	Future<RemedicalListResult> getRemedicalListByRecordInfoAsync(QueryRecordRequest request) async {
		var rpcRst = await call("GetRemedicalListByRecordInfoAsync", request);
		var result = RemedicalListResult.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<PageResult<RemedicalListResult>> getRemedicalListPagesAsync(GetRecordsPageRequest request) async {
		var rpcRst = await call("GetRemedicalListPagesAsync", request);
		var result = PageResult<RemedicalListResult>.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<List<DataItemDTO>> queryDropdownListAsync(QueryDropdownListReuqest request) async {
		var rpcRst = await call("QueryDropdownListAsync", request);
		var result = (rpcRst as List).map((e)=>DataItemDTO.fromJson(e as Map<String, dynamic>)).toList();
		return result;
	}

	Future<OrganizationSettingResult> getOrganizationSettingAsync(GetUserOrganizationSettingRequest request) async {
		var rpcRst = await call("GetOrganizationSettingAsync", request);
		var result = OrganizationSettingResult.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<QueryReservationResult> queryReservationAsync(QueryReservationRequest request) async {
		var rpcRst = await call("QueryReservationAsync", request);
		var result = QueryReservationResult.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<bool> pushFinshExamNotificationToClientAsync(PushFinishExamNotifyToClientRequest request) async {
		var rpcRst = await call("PushFinshExamNotificationToClientAsync", request);
		return rpcRst;
	}

	Future<bool> deviceFinishExamAsync(DeviceFinishExamRequest request) async {
		var rpcRst = await call("DeviceFinishExamAsync", request);
		return rpcRst;
	}

	Future<PageResult<QueryExamInfoResult>> queryExamListAsync(QueryExamListRequest request) async {
		var rpcRst = await call("QueryExamListAsync", request);
		var result = PageResult<QueryExamInfoResult>.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<QueryExamInfoResult> queryExamInfoAsync(QueryExamInfoRequest request) async {
		var rpcRst = await call("QueryExamInfoAsync", request);
		var result = QueryExamInfoResult.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<String> getCollcetingRecordCodeAsync(TokenRequest request) async {
		var rpcRst = await call("GetCollcetingRecordCodeAsync", request);
		return rpcRst;
	}

	Future<MeasureApplicationDTO> getMeasureApplicationAsync(GetMeasureApplicationRequest request) async {
		var rpcRst = await call("GetMeasureApplicationAsync", request);
		var result = MeasureApplicationDTO.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<CommentItemResultDTO> getCommentsByApplicationAsync(GetCommentsByApplicationRequest request) async {
		var rpcRst = await call("GetCommentsByApplicationAsync", request);
		var result = CommentItemResultDTO.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<PresetCommentItemResultDTO> getPresetCommentsAsync(GetPresetCommentsRequest request) async {
		var rpcRst = await call("GetPresetCommentsAsync", request);
		var result = PresetCommentItemResultDTO.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<String> getReportElementByLanguageAsync(GetReportElementByLanguageRequest request) async {
		var rpcRst = await call("GetReportElementByLanguageAsync", request);
		return rpcRst;
	}

	Future<bool> saveUserDefinedCommentsAsync(SaveUserDefinedCommentsRequest request) async {
		var rpcRst = await call("SaveUserDefinedCommentsAsync", request);
		return rpcRst;
	}

	Future<bool> resetUserCommentsAsync(ResetUserCommentsRequest request) async {
		var rpcRst = await call("ResetUserCommentsAsync", request);
		return rpcRst;
	}

	Future<bool> saveUserDefinedMeasureApplicationAsync(SaveUserDefinedMeasureApplicationRequest request) async {
		var rpcRst = await call("SaveUserDefinedMeasureApplicationAsync", request);
		return rpcRst;
	}

	Future<MeasureSystemSettingDTO> getMeasureSystemSettingAsync(GetMeasureSystemSettingRequest request) async {
		var rpcRst = await call("GetMeasureSystemSettingAsync", request);
		var result = MeasureSystemSettingDTO.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<bool> saveMeasureSystemSettingAsync(SaveMeasureSystemSettingRequest request) async {
		var rpcRst = await call("SaveMeasureSystemSettingAsync", request);
		return rpcRst;
	}

	Future<ExportRemedicalDataResult> exportRemedicalDataAsync(ExportRemedicalDataRequest request) async {
		var rpcRst = await call("ExportRemedicalDataAsync", request);
		var result = ExportRemedicalDataResult.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<String> findCacheByCodeAsync(FindCacheByCodeRequest request) async {
		var rpcRst = await call("FindCacheByCodeAsync", request);
		return rpcRst;
	}

	Future<GetFileCompressInfoResult> getFileCompressInfoAsync(GetFileCompressInfoRequest request) async {
		var rpcRst = await call("GetFileCompressInfoAsync", request);
		var result = GetFileCompressInfoResult.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<String> applyReferralRecordAsync(CreateReferralRecordRequest request) async {
		var rpcRst = await call("ApplyReferralRecordAsync", request);
		return rpcRst;
	}

	Future<String> modifyReferralRecordAsync(ModifyReferralRecordRequest request) async {
		var rpcRst = await call("ModifyReferralRecordAsync", request);
		return rpcRst;
	}

	Future<PageResult<QueryReferralRecordPageDTO>> queryReferralRecordListAsync(QueryReferralRecordListRequest request) async {
		var rpcRst = await call("QueryReferralRecordListAsync", request);
		var result = PageResult<QueryReferralRecordPageDTO>.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<bool> auditReferralRecordAsync(AuditReferralRecordRequest request) async {
		var rpcRst = await call("AuditReferralRecordAsync", request);
		return rpcRst;
	}

	Future<bool> withdrawReferralRecordAsync(WithdrawReferralRecordRequest request) async {
		var rpcRst = await call("WithdrawReferralRecordAsync", request);
		return rpcRst;
	}

	Future<List<OrganizationDTO>> queryReferralOrganizationsAsync(ReferralOrganizationsQueryRequest request) async {
		var rpcRst = await call("QueryReferralOrganizationsAsync", request);
		var result = (rpcRst as List).map((e)=>OrganizationDTO.fromJson(e as Map<String, dynamic>)).toList();
		return result;
	}

	Future<ClientPatientInfoDTO> queryReferralPatientByCodeAsync(QueryReferralPatientByCodeRequest request) async {
		var rpcRst = await call("QueryReferralPatientByCodeAsync", request);
		var result = ClientPatientInfoDTO.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<List<ReferralRecordDetailDTO>> findPatientReferralRecordAsync(FindPatientReferralRecordRequest request) async {
		var rpcRst = await call("FindPatientReferralRecordAsync", request);
		var result = (rpcRst as List).map((e)=>ReferralRecordDetailDTO.fromJson(e as Map<String, dynamic>)).toList();
		return result;
	}

	Future<List<ReferralRecordDetailDTO>> findReferralInRecordAsync(FindReferralInRecordRequest request) async {
		var rpcRst = await call("FindReferralInRecordAsync", request);
		var result = (rpcRst as List).map((e)=>ReferralRecordDetailDTO.fromJson(e as Map<String, dynamic>)).toList();
		return result;
	}

	Future<PageResult<RemedicalListResult>> queryReferralRemedicalListPagesAsync(QueryReferralRecordsPageRequest request) async {
		var rpcRst = await call("QueryReferralRemedicalListPagesAsync", request);
		var result = PageResult<RemedicalListResult>.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<PageResult<GetRecordsPageDTO>> queryReferralRecordInfoPagesAsync(QueryReferralRecordsPageRequest request) async {
		var rpcRst = await call("QueryReferralRecordInfoPagesAsync", request);
		var result = PageResult<GetRecordsPageDTO>.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<List<ReportDTO>> queryReferralExamReportsAsync(QueryReferralExamReportRequest request) async {
		var rpcRst = await call("QueryReferralExamReportsAsync", request);
		var result = (rpcRst as List).map((e)=>ReportDTO.fromJson(e as Map<String, dynamic>)).toList();
		return result;
	}

	Future<List<ReportDTO>> queryReferralPatientReportsAsync(QueryReferralPatientByCodeRequest request) async {
		var rpcRst = await call("QueryReferralPatientReportsAsync", request);
		var result = (rpcRst as List).map((e)=>ReportDTO.fromJson(e as Map<String, dynamic>)).toList();
		return result;
	}

	Future<RemedicalListResult> queryReferralRemedicalListByRecordInfoAsync(QueryReferralExamReportRequest request) async {
		var rpcRst = await call("QueryReferralRemedicalListByRecordInfoAsync", request);
		var result = RemedicalListResult.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<QueryShareExamPageResult> queryShareExamPageAsync(QueryShareExamPageRequest request) async {
		var rpcRst = await call("QueryShareExamPageAsync", request);
		var result = QueryShareExamPageResult.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<bool> batchExportMeasureResultAsync(BatchExportMeasureResultRequest request) async {
		var rpcRst = await call("BatchExportMeasureResultAsync", request);
		return rpcRst;
	}

	Future<String> getRemedicalDiagnosisDataAsync(GetRemedicalDiagnosisDataRequest request) async {
		var rpcRst = await call("GetRemedicalDiagnosisDataAsync", request);
		return rpcRst;
	}

	Future<List<RemedicalAISelectedInfoDTO>> getPatientAISelectedInfosAsync(GetPatientAISelectedInfosRequest request) async {
		var rpcRst = await call("GetPatientAISelectedInfosAsync", request);
		var result = (rpcRst as List).map((e)=>RemedicalAISelectedInfoDTO.fromJson(e as Map<String, dynamic>)).toList();
		return result;
	}

	Future<RemedicalAISelectedInfoDTO> getRemedicalAISelectedInfoAsync(GetRemedicalAISelectedInfoRequest request) async {
		var rpcRst = await call("GetRemedicalAISelectedInfoAsync", request);
		var result = RemedicalAISelectedInfoDTO.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<bool> saveRemedicalAISelectedInfoAsync(SaveRemedicalAISelectedInfoRequest request) async {
		var rpcRst = await call("SaveRemedicalAISelectedInfoAsync", request);
		return rpcRst;
	}

	Future<bool> syncBatchRemedicalRecordsAsync(SyncBatchRemedicalRecordRequest request) async {
		var rpcRst = await call("SyncBatchRemedicalRecordsAsync", request);
		return rpcRst;
	}

	Future<bool> syncBatchUploadRemedicalDatasAsync(SyncBatchUploadRemedicalDatasRequest request) async {
		var rpcRst = await call("SyncBatchUploadRemedicalDatasAsync", request);
		return rpcRst;
	}

	Future<bool> syncBatchAIResultAsync(SyncBatchAIResultRequest request) async {
		var rpcRst = await call("SyncBatchAIResultAsync", request);
		return rpcRst;
	}

	Future<bool> syncBatchCarotidResultAsync(SyncBatchCarotidResultRequest request) async {
		var rpcRst = await call("SyncBatchCarotidResultAsync", request);
		return rpcRst;
	}

	Future<String> doConvertToVid(LabFileInfoRequest labFileInfo) async {
		var rpcRst = await call("DoConvertToVid", labFileInfo);
		return rpcRst;
	}

	Future<List<DiagnosisOrganEnum>> findDeviceDiagnosisAsync(FindDeviceDiagnosisRequest request) async {
		var rpcRst = await call("FindDeviceDiagnosisAsync", request);
		var result = (rpcRst as List).map((e)=>DiagnosisOrganEnum.values.firstWhere((i) => i.index == e)).toList();
		return result;
	}

	Future<bool> addToVidProcessQueueAsync(AddToVidProcessQueueRequest request) async {
		var rpcRst = await call("AddToVidProcessQueueAsync", request);
		return rpcRst;
	}

	Future<QueryShareExamPageResult> queryShareImagesPlayUrlAsync(QueryShareImagesPlayUrlRequest request) async {
		var rpcRst = await call("QueryShareImagesPlayUrlAsync", request);
		var result = QueryShareExamPageResult.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<String> remedicalConnectAsync(TokenRequest request) async {
		var rpcRst = await call("RemedicalConnectAsync", request);
		return rpcRst;
	}

}