fis_lib_jsonrpc/lib/services/report.dart

import 'dart:core';

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

import 'report.m.dart';

import 'remedical.m.dart';
import 'liveConsultation.m.dart';


class ReportService extends JsonRpcClientBase {
	ReportService(
		String host, {
		String serviceName = "IReportService",
		Map<String, String>? headers,
		int? timeout,
	}) : super(
						host,
						serviceName,
						headers: headers,
						timeout: timeout,
				) {
		/// 注册响应实体反序列化处理器
		FJsonConvert.setDecoder((map) => ReportTemplateDTO.fromJson(map));
		FJsonConvert.setDecoder((map) => ReportDTO.fromJson(map));
		FJsonConvert.setDecoder((map) => ReportLabelDTO.fromJson(map));
		FJsonConvert.setDecoder((map) => ShareDTO.fromJson(map));
		FJsonConvert.setDecoder((map) => PageResult<ReportTemplateDTO>.fromJson(map));
		FJsonConvert.setDecoder((map) => PageResult<ThesaurusDTO>.fromJson(map));
		FJsonConvert.setDecoder((map) => ThesaurusDTO.fromJson(map));
		FJsonConvert.setDecoder((map) => ThesaurusItemDTO.fromJson(map));
		FJsonConvert.setDecoder((map) => ThesaurusAllDTO.fromJson(map));
		FJsonConvert.setDecoder((map) => ReportPreviewDTO.fromJson(map));
		FJsonConvert.setDecoder((map) => ExportThesaurusTemplateResult.fromJson(map));
		FJsonConvert.setDecoder((map) => DeviceExamReportDTO.fromJson(map));
	}

	Future<ReportTemplateDTO> findReportTemplateByCodeAsync(FindReportTemplateByCodeRequest request) async {
		var rpcRst = await call("FindReportTemplateByCodeAsync", request);
		var result = ReportTemplateDTO.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<ReportDTO> findReportByCodeAsync(FindReportByCodeRequest request) async {
		var rpcRst = await call("FindReportByCodeAsync", request);
		var result = ReportDTO.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

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

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

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

	Future<List<ReportLabelDTO>> findReportLabelsAsync(FindReportLabelsRequest request) async {
		var rpcRst = await call("FindReportLabelsAsync", request);
		var result = (rpcRst as List).map((e)=>ReportLabelDTO.fromJson(e as Map<String, dynamic>)).toList();
		return result;
	}

	Future<ShareDTO> findShareContentAsync(FindShareContentRequest request) async {
		var rpcRst = await call("FindShareContentAsync", request);
		var result = ShareDTO.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<String> addReportAsync(AddReportRequest request) async {
		var rpcRst = await call("AddReportAsync", request);
		return rpcRst;
	}

	Future<bool> modifyReportAsync(ModifyReportRequest request) async {
		var rpcRst = await call("ModifyReportAsync", request);
		return rpcRst;
	}

	Future<bool> modifyReportLabelsAsync(ModifyReportLabelsRequest request) async {
		var rpcRst = await call("ModifyReportLabelsAsync", request);
		return rpcRst;
	}

	Future<bool> shareReportBySmsAsync(ShareReportBySmsRequest request) async {
		var rpcRst = await call("ShareReportBySmsAsync", request);
		return rpcRst;
	}

	Future<bool> shareReportByEmailAsync(ShareReportByEmailRequest request) async {
		var rpcRst = await call("ShareReportByEmailAsync", request);
		return rpcRst;
	}

	Future<String> copyPersonalReportTemplateAsync(CopyReportTemplateRequest request) async {
		var rpcRst = await call("CopyPersonalReportTemplateAsync", request);
		return rpcRst;
	}

	Future<String> copyOrgReportTemplateAsync(CopyOrgReportTemplateRequest request) async {
		var rpcRst = await call("CopyOrgReportTemplateAsync", request);
		return rpcRst;
	}

	Future<PageResult<ReportTemplateDTO>> getReportTemplatePageAsync(FindReportTemplatePagesRequest request) async {
		var rpcRst = await call("GetReportTemplatePageAsync", request);
		var result = PageResult<ReportTemplateDTO>.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<PageResult<ReportTemplateDTO>> getOrgReportTemplatePageAsync(FindReportTemplatePagesRequest request) async {
		var rpcRst = await call("GetOrgReportTemplatePageAsync", request);
		var result = PageResult<ReportTemplateDTO>.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<String> addReportTemplateAsync(AddReportTemplateRequest request) async {
		var rpcRst = await call("AddReportTemplateAsync", request);
		return rpcRst;
	}

	Future<bool> updateReportTemplateAsync(UpdateReportTemplateRequest request) async {
		var rpcRst = await call("UpdateReportTemplateAsync", request);
		return rpcRst;
	}

	Future<bool> removeReportTemplateAsync(RemoveReportTemplateRequest request) async {
		var rpcRst = await call("RemoveReportTemplateAsync", request);
		return rpcRst;
	}

	Future<String> addOrgReportTemplateAsync(AddReportTemplateRequest request) async {
		var rpcRst = await call("AddOrgReportTemplateAsync", request);
		return rpcRst;
	}

	Future<bool> removeOrgReportTemplateAsync(RemoveReportTemplateRequest request) async {
		var rpcRst = await call("RemoveOrgReportTemplateAsync", request);
		return rpcRst;
	}

	Future<bool> addThesaurusAsync(AddThesaurusRequest request) async {
		var rpcRst = await call("AddThesaurusAsync", request);
		return rpcRst;
	}

	Future<bool> updateThesaurusAsync(UpdateThesaurusRequest request) async {
		var rpcRst = await call("UpdateThesaurusAsync", request);
		return rpcRst;
	}

	Future<bool> addOrgThesaurusAsync(AddThesaurusRequest request) async {
		var rpcRst = await call("AddOrgThesaurusAsync", request);
		return rpcRst;
	}

	Future<bool> addThesaurusClassifyAsync(AddThesaurusClassifyRequest request) async {
		var rpcRst = await call("AddThesaurusClassifyAsync", request);
		return rpcRst;
	}

	Future<bool> addThesaurusContentAsync(AddThesaurusContentRequest request) async {
		var rpcRst = await call("AddThesaurusContentAsync", request);
		return rpcRst;
	}

	Future<bool> updateThesaurusClassifyAsync(UpdateThesaurusClassifyRequest request) async {
		var rpcRst = await call("UpdateThesaurusClassifyAsync", request);
		return rpcRst;
	}

	Future<bool> updateThesaurusContentAsync(UpdateThesaurusContentRequest request) async {
		var rpcRst = await call("UpdateThesaurusContentAsync", request);
		return rpcRst;
	}

	Future<bool> removeThesaurusAsync(RemoveThesaurusRequest request) async {
		var rpcRst = await call("RemoveThesaurusAsync", request);
		return rpcRst;
	}

	Future<bool> removeOrgThesaurusAsync(RemoveThesaurusRequest request) async {
		var rpcRst = await call("RemoveOrgThesaurusAsync", request);
		return rpcRst;
	}

	Future<bool> removeThesaurusItemAsync(RemoveThesaurusItemRequest request) async {
		var rpcRst = await call("RemoveThesaurusItemAsync", request);
		return rpcRst;
	}

	Future<PageResult<ThesaurusDTO>> getThesaurusPageAsync(GetThesaurusPageRequest request) async {
		var rpcRst = await call("GetThesaurusPageAsync", request);
		var result = PageResult<ThesaurusDTO>.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<PageResult<ThesaurusDTO>> getOrgThesaurusPageAsync(GetThesaurusPageRequest request) async {
		var rpcRst = await call("GetOrgThesaurusPageAsync", request);
		var result = PageResult<ThesaurusDTO>.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<List<ThesaurusItemDTO>> getThesaurusItemsAsync(GetThesaurusItemsRequest request) async {
		var rpcRst = await call("GetThesaurusItemsAsync", request);
		var result = (rpcRst as List).map((e)=>ThesaurusItemDTO.fromJson(e as Map<String, dynamic>)).toList();
		return result;
	}

	Future<ThesaurusItemDTO> getThesaurusItemByCodeAsync(GetThesaurusItemByCodeRequest request) async {
		var rpcRst = await call("GetThesaurusItemByCodeAsync", request);
		var result = ThesaurusItemDTO.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<List<ThesaurusItemDTO>> getThesaurusClassifyByParentCodeAsync(GetThesaurusClassifyByParentCodeRequest request) async {
		var rpcRst = await call("GetThesaurusClassifyByParentCodeAsync", request);
		var result = (rpcRst as List).map((e)=>ThesaurusItemDTO.fromJson(e as Map<String, dynamic>)).toList();
		return result;
	}

	Future<List<ThesaurusItemDTO>> getThesaurusContentByParentCodeAsync(GetThesaurusContentByParentCodeRequest request) async {
		var rpcRst = await call("GetThesaurusContentByParentCodeAsync", request);
		var result = (rpcRst as List).map((e)=>ThesaurusItemDTO.fromJson(e as Map<String, dynamic>)).toList();
		return result;
	}

	Future<bool> copyPersonalThesaurusAsync(CopyThesaurusRequest request) async {
		var rpcRst = await call("CopyPersonalThesaurusAsync", request);
		return rpcRst;
	}

	Future<bool> copyOrgThesaurusAsync(CopyOrgThesaurusRequest request) async {
		var rpcRst = await call("CopyOrgThesaurusAsync", request);
		return rpcRst;
	}

	Future<ThesaurusAllDTO> getDefaultThesaurusContentAsync(GetDefaultThesaurusContentRequest request) async {
		var rpcRst = await call("GetDefaultThesaurusContentAsync", request);
		var result = ThesaurusAllDTO.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<bool> setUserDefaultThesaurusAsync(SetUserDefaultThesaurusRequest request) async {
		var rpcRst = await call("SetUserDefaultThesaurusAsync", request);
		return rpcRst;
	}

	Future<bool> retryPushReportRecordsAsync(RetryPushReportRecordsByCodesRequest request) async {
		var rpcRst = await call("RetryPushReportRecordsAsync", request);
		return rpcRst;
	}

	Future<String> findReportPreviewImageAsync(FindReportPreviewImageRequest request) async {
		var rpcRst = await call("FindReportPreviewImageAsync", request);
		return rpcRst;
	}

	Future<ReportPreviewDTO> convertVitalReportPreviewImageAsync(ConvertVitalReportPreviewImageRequest request) async {
		var rpcRst = await call("ConvertVitalReportPreviewImageAsync", request);
		var result = ReportPreviewDTO.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<String> findReportShareUrlAsync(FindReportShareUrlRequest request) async {
		var rpcRst = await call("FindReportShareUrlAsync", request);
		return rpcRst;
	}

	Future<ReportTemplateDTO> getDefaultReportTemplateContentAsync(GetDefaultReportTemplateContentRequest request) async {
		var rpcRst = await call("GetDefaultReportTemplateContentAsync", request);
		var result = ReportTemplateDTO.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<bool> setUserDefaultReportTemplateAsync(SetUserDefaultReportTemplateRequest request) async {
		var rpcRst = await call("SetUserDefaultReportTemplateAsync", request);
		return rpcRst;
	}

	Future<bool> createReportTemplatePreviewAsync(GetReportTemplateDBRequest request) async {
		var rpcRst = await call("CreateReportTemplatePreviewAsync", request);
		return rpcRst;
	}

	Future<bool> checkReportTemplateName(UpdateReportTemplateRequest request) async {
		var rpcRst = await call("CheckReportTemplateName", request);
		return rpcRst;
	}

	Future<bool> refreshReportPosterFromDb(RefreshReportPosterRequest request) async {
		var rpcRst = await call("RefreshReportPosterFromDb", request);
		return rpcRst;
	}

	Future<bool> syncBatchReportInfoAsync(SyncBatchReportInfoRequest request) async {
		var rpcRst = await call("SyncBatchReportInfoAsync", request);
		return rpcRst;
	}

	Future<bool> saveReportPreviewAsync(FindReportByCodeRequest request) async {
		var rpcRst = await call("SaveReportPreviewAsync", request);
		return rpcRst;
	}

	Future<bool> importThesaurusAsync(ImportThesaurusInfoRequest request) async {
		var rpcRst = await call("ImportThesaurusAsync", request);
		return rpcRst;
	}

	Future<ExportThesaurusTemplateResult> exportThesaurusAsync(FindThesaurusByCodeRequest request) async {
		var rpcRst = await call("ExportThesaurusAsync", request);
		var result = ExportThesaurusTemplateResult.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<List<DeviceExamReportDTO>> getDeviceExamReportsAsync(GetDeviceExamReportsRequest request) async {
		var rpcRst = await call("GetDeviceExamReportsAsync", request);
		var result = (rpcRst as List).map((e)=>DeviceExamReportDTO.fromJson(e as Map<String, dynamic>)).toList();
		return result;
	}

	Future<DeviceExamReportDTO> getDeviceExamReportByCodeAsync(GetDeviceExamReportByCodeRequest request) async {
		var rpcRst = await call("GetDeviceExamReportByCodeAsync", request);
		var result = DeviceExamReportDTO.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

}