fis_lib_jsonrpc/lib/services/aIDiagnosis.dart

import 'dart:core';

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

import 'aIDiagnosis.m.dart';

import 'liveConsultation.m.dart';


class AIDiagnosisService extends JsonRpcClientBase {
	AIDiagnosisService(
		String host, {
		String serviceName = "IAIDiagnosisService",
		Map<String, String>? headers,
		int? timeout,
	}) : super(
						host,
						serviceName,
						headers: headers,
						timeout: timeout,
				) {
		/// 注册响应实体反序列化处理器
		FJsonConvert.setDecoder((map) => DiagnosisImageResult.fromJson(map));
		FJsonConvert.setDecoder((map) => CarotidResultDTO.fromJson(map));
		FJsonConvert.setDecoder((map) => CreateCarotidSurfaceImagesResult.fromJson(map));
		FJsonConvert.setDecoder((map) => DiagnosisReportResult.fromJson(map));
		FJsonConvert.setDecoder((map) => GetDiagnosisConclusionResult.fromJson(map));
		FJsonConvert.setDecoder((map) => GetDiagnosisEnumItemsResult.fromJson(map));
		FJsonConvert.setDecoder((map) => DiagnosisKeyPointDTO.fromJson(map));
		FJsonConvert.setDecoder((map) => ContourAndKeyPointsAfterDragResult.fromJson(map));
		FJsonConvert.setDecoder((map) => MinimumDistanceToContourPointsResult.fromJson(map));
		FJsonConvert.setDecoder((map) => ContourMergeResult.fromJson(map));
	}

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

	Future<DiagnosisImageResult> diagnosisImageAsync(DiagnosisImageRequest request) async {
		var rpcRst = await call("DiagnosisImageAsync", request);
		var result = DiagnosisImageResult.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<DiagnosisImageResult> getDiagnosisImageResultByAIResultAsync(GetDiagnosisImageResultByAIResultRequest request) async {
		var rpcRst = await call("GetDiagnosisImageResultByAIResultAsync", request);
		var result = DiagnosisImageResult.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<CarotidResultDTO> getCarotidResultAsync(GetCarotidResultRequest request) async {
		var rpcRst = await call("GetCarotidResultAsync", request);
		var result = CarotidResultDTO.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<CreateCarotidSurfaceImagesResult> createCarotidSurfaceImagesAsync(CreateCarotidSurfaceImagesRequest request) async {
		var rpcRst = await call("CreateCarotidSurfaceImagesAsync", request);
		var result = CreateCarotidSurfaceImagesResult.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<DiagnosisReportResult> diagnosisReportAsync(DiagnosisReportRequest request) async {
		var rpcRst = await call("DiagnosisReportAsync", request);
		var result = DiagnosisReportResult.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<GetDiagnosisConclusionResult> getDiagnosisConclusionAsync(GetDiagnosisConclusionRequest request) async {
		var rpcRst = await call("GetDiagnosisConclusionAsync", request);
		var result = GetDiagnosisConclusionResult.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<GetDiagnosisEnumItemsResult> getDiagnosisEnumItemsAsync(GetDiagnosisEnumItemsRequest request) async {
		var rpcRst = await call("GetDiagnosisEnumItemsAsync", request);
		var result = GetDiagnosisEnumItemsResult.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<List<DiagnosisKeyPointDTO>> getKeyPointsOfContourAsync(GetKeyPointsOfContourRequest request) async {
		var rpcRst = await call("GetKeyPointsOfContourAsync", request);
		var result = (rpcRst as List).map((e)=>DiagnosisKeyPointDTO.fromJson(e as Map<String, dynamic>)).toList();
		return result;
	}

	Future<List<int>> affectedKeyPointsByDragActionAsync(AffectedKeyPointsByDragActionRequest request) async {
		var rpcRst = await call("AffectedKeyPointsByDragActionAsync", request);
		var result = (rpcRst as List).cast<int>().toList();
		return result;
	}

	Future<ContourAndKeyPointsAfterDragResult> contourAndKeyPointsAfterDragAsync(ContourAndKeyPointsAfterDragRequest request) async {
		var rpcRst = await call("ContourAndKeyPointsAfterDragAsync", request);
		var result = ContourAndKeyPointsAfterDragResult.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<MinimumDistanceToContourPointsResult> minimumDistanceToContourPointsAsync(MinimumDistanceToContourPointsRequest request) async {
		var rpcRst = await call("MinimumDistanceToContourPointsAsync", request);
		var result = MinimumDistanceToContourPointsResult.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<ContourMergeResult> contourMergeAsync(ContourMergeRequest request) async {
		var rpcRst = await call("ContourMergeAsync", request);
		var result = ContourMergeResult.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

}