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 'recordInfo.m.dart';
import 'organization.m.dart';
import 'authentication.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) => 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<QueryExamListItemResult>.fromJson(map));
		FJsonConvert.setDecoder((map) => QueryExamListItemResult.fromJson(map));
		FJsonConvert.setDecoder((map) => QueryExamInfoResult.fromJson(map));
		FJsonConvert.setDecoder((map) => PageResult<ThesaurusDTO>.fromJson(map));
		FJsonConvert.setDecoder((map) => ThesaurusDTO.fromJson(map));
		FJsonConvert.setDecoder((map) => ThesaurusItemDTO.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<bool> uploadExamDataAsync(UploadExamDataRequest request) async {
		var rpcRst = await call("UploadExamDataAsync", 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> autoUploadExamDataAsync(TokenRequest request) async {
		var rpcRst = await call("AutoUploadExamDataAsync", request);
		return rpcRst;
	}

	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<bool> addThesaurusAsync(AddThesaurusRequest request) async {
		var rpcRst = await call("AddThesaurusAsync", 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<QueryExamListItemResult>> queryExamListAsync(QueryExamListRequest request) async {
		var rpcRst = await call("QueryExamListAsync", request);
		var result = PageResult<QueryExamListItemResult>.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<bool> updateThesaurusUserCodeAsync(UpdateThesaurusUserCodeRequest request) async {
		var rpcRst = await call("UpdateThesaurusUserCodeAsync", request);
		return rpcRst;
	}

	Future<bool> deleteThesaurusUserCodeAsync(DeleteThesaurusUserCodeRequest request) async {
		var rpcRst = await call("DeleteThesaurusUserCodeAsync", 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<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<bool> saveUserDefinedMeasureItemsAsync(SaveUserDefinedMeasureItemsRequest request) async {
		var rpcRst = await call("SaveUserDefinedMeasureItemsAsync", request);
		return rpcRst;
	}

	Future<bool> saveUserDefinedCommentItemsAsync(SaveUserDefinedCommentItemsRequest request) async {
		var rpcRst = await call("SaveUserDefinedCommentItemsAsync", request);
		return rpcRst;
	}

	Future<bool> resetUserDefinedMeasureItemsAsync(TokenRequest request) async {
		var rpcRst = await call("ResetUserDefinedMeasureItemsAsync", request);
		return rpcRst;
	}

	Future<bool> resetUserDefinedCommentItemsAsync(TokenRequest request) async {
		var rpcRst = await call("ResetUserDefinedCommentItemsAsync", request);
		return rpcRst;
	}

}