fis_lib_jsonrpc/lib/services/management.dart

import 'dart:core';

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

import 'management.m.dart';

class ManagementService extends JsonRpcClientBase {
	ManagementService(
		String host, {
		String serviceName = "IManagementService",
		Map<String, String>? headers,
		int? timeout,
	}) : super(
						host,
						serviceName,
						headers: headers,
						timeout: timeout,
				) {
		/// 注册响应实体反序列化处理器
		FJsonConvert.setDecoder((map) => PageCollection<AdminAccountInfo>.fromJson(map));
		FJsonConvert.setDecoder((map) => AdminAccountInfo.fromJson(map));
		FJsonConvert.setDecoder((map) => PageCollection<UserInfo>.fromJson(map));
		FJsonConvert.setDecoder((map) => UserInfo.fromJson(map));
		FJsonConvert.setDecoder((map) => PageCollection<ReportInfo>.fromJson(map));
		FJsonConvert.setDecoder((map) => ReportInfo.fromJson(map));
		FJsonConvert.setDecoder((map) => PageCollection<RecordInfo>.fromJson(map));
		FJsonConvert.setDecoder((map) => RecordInfo.fromJson(map));
		FJsonConvert.setDecoder((map) => PageCollection<DeviceData>.fromJson(map));
		FJsonConvert.setDecoder((map) => DeviceData.fromJson(map));
		FJsonConvert.setDecoder((map) => PageCollection<PatientInfo>.fromJson(map));
		FJsonConvert.setDecoder((map) => PatientInfo.fromJson(map));
		FJsonConvert.setDecoder((map) => PageCollection<MenuInfo>.fromJson(map));
		FJsonConvert.setDecoder((map) => MenuInfo.fromJson(map));
	}

	Future<String> adminLogin(String adminName,String passwd) async {
		var rpcRst = await call("AdminLogin", [adminName,passwd]);
		return rpcRst;
	}

	Future<bool> modifyAdminAccountAsync(String sessionId,String adminCode,AdminAccountInfo adminAccountInfo) async {
		var rpcRst = await call("ModifyAdminAccountAsync", [sessionId,adminCode,adminAccountInfo]);
		return rpcRst;
	}

	Future<bool> createAdminAccountAsync(String sessionId,AdminAccountInfo adminAccountInfo,String extensionData) async {
		var rpcRst = await call("CreateAdminAccountAsync", [sessionId,adminAccountInfo,extensionData]);
		return rpcRst;
	}

	Future<PageCollection<AdminAccountInfo>> getAdminAccountPagesAsync(String sessionId,String keyword,int page,int limit) async {
		var rpcRst = await call("GetAdminAccountPagesAsync", [sessionId,keyword,page,limit]);
		var result = PageCollection<AdminAccountInfo>.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<bool> removeAdminAccountAsync(String sessionId,String adminCode) async {
		var rpcRst = await call("RemoveAdminAccountAsync", [sessionId,adminCode]);
		return rpcRst;
	}

	Future<AdminAccountInfo> findAdminAccountByCodeAsync(String sessionId,String adminCode) async {
		var rpcRst = await call("FindAdminAccountByCodeAsync", [sessionId,adminCode]);
		var result = AdminAccountInfo.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<bool> modifyUserAccountAsync(String sessionId,String userCode,UserInfo userInfo) async {
		var rpcRst = await call("ModifyUserAccountAsync", [sessionId,userCode,userInfo]);
		return rpcRst;
	}

	Future<bool> createUserAccountAsync(String sessionId,UserInfo userInfo,String extensionData) async {
		var rpcRst = await call("CreateUserAccountAsync", [sessionId,userInfo,extensionData]);
		return rpcRst;
	}

	Future<PageCollection<UserInfo>> getUserAccountPagesAsync(String sessionId,String keyword,int page,int limit) async {
		var rpcRst = await call("GetUserAccountPagesAsync", [sessionId,keyword,page,limit]);
		var result = PageCollection<UserInfo>.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<bool> removeUserAccountAsync(String sessionId,String userCode) async {
		var rpcRst = await call("RemoveUserAccountAsync", [sessionId,userCode]);
		return rpcRst;
	}

	Future<UserInfo> findUserAccountByCodeAsync(String sessionId,String userCode) async {
		var rpcRst = await call("FindUserAccountByCodeAsync", [sessionId,userCode]);
		var result = UserInfo.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<bool> modifyReportAsync(String sessionId,String reportCode,ReportInfo reportInfo) async {
		var rpcRst = await call("ModifyReportAsync", [sessionId,reportCode,reportInfo]);
		return rpcRst;
	}

	Future<bool> createReportAsync(String sessionId,ReportInfo reportInfo,String extensionData) async {
		var rpcRst = await call("CreateReportAsync", [sessionId,reportInfo,extensionData]);
		return rpcRst;
	}

	Future<PageCollection<ReportInfo>> getReportPagesAsync(String sessionId,String keyword,int page,int limit) async {
		var rpcRst = await call("GetReportPagesAsync", [sessionId,keyword,page,limit]);
		var result = PageCollection<ReportInfo>.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<bool> removeReportAsync(String sessionId,String reportCode) async {
		var rpcRst = await call("RemoveReportAsync", [sessionId,reportCode]);
		return rpcRst;
	}

	Future<ReportInfo> findReportByCodeAsync(String sessionId,String reportCode) async {
		var rpcRst = await call("FindReportByCodeAsync", [sessionId,reportCode]);
		var result = ReportInfo.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<bool> modifyRecordAsync(String sessionId,String recordCode,RecordInfo recordInfo) async {
		var rpcRst = await call("ModifyRecordAsync", [sessionId,recordCode,recordInfo]);
		return rpcRst;
	}

	Future<bool> createRecordAsync(String sessionId,RecordInfo recordInfo,String extensionData) async {
		var rpcRst = await call("CreateRecordAsync", [sessionId,recordInfo,extensionData]);
		return rpcRst;
	}

	Future<PageCollection<RecordInfo>> getRecordPagesAsync(String sessionId,String keyword,int page,int limit) async {
		var rpcRst = await call("GetRecordPagesAsync", [sessionId,keyword,page,limit]);
		var result = PageCollection<RecordInfo>.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<bool> removeRecordAsync(String sessionId,String recordCode) async {
		var rpcRst = await call("RemoveRecordAsync", [sessionId,recordCode]);
		return rpcRst;
	}

	Future<RecordInfo> findRecordByCodeAsync(String sessionId,String recordCode) async {
		var rpcRst = await call("FindRecordByCodeAsync", [sessionId,recordCode]);
		var result = RecordInfo.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<bool> modifyDeviceDataAsync(String sessionId,String deviceDataCode,DeviceData deviceData) async {
		var rpcRst = await call("ModifyDeviceDataAsync", [sessionId,deviceDataCode,deviceData]);
		return rpcRst;
	}

	Future<bool> createDeviceDataAsync(String sessionId,DeviceData deviceData,String extensionData) async {
		var rpcRst = await call("CreateDeviceDataAsync", [sessionId,deviceData,extensionData]);
		return rpcRst;
	}

	Future<PageCollection<DeviceData>> getDeviceDataPagesAsync(String sessionId,String keyword,int page,int limit) async {
		var rpcRst = await call("GetDeviceDataPagesAsync", [sessionId,keyword,page,limit]);
		var result = PageCollection<DeviceData>.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<bool> removeDeviceDataAsync(String sessionId,String deviceDataCode) async {
		var rpcRst = await call("RemoveDeviceDataAsync", [sessionId,deviceDataCode]);
		return rpcRst;
	}

	Future<DeviceData> findDeviceDataByCodeAsync(String sessionId,String deviceDataCode) async {
		var rpcRst = await call("FindDeviceDataByCodeAsync", [sessionId,deviceDataCode]);
		var result = DeviceData.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<bool> modifyPatientAsync(String sessionId,String patientCode,PatientInfo patientInfo) async {
		var rpcRst = await call("ModifyPatientAsync", [sessionId,patientCode,patientInfo]);
		return rpcRst;
	}

	Future<bool> createPatientAsync(String sessionId,PatientInfo patientInfo,String extensionData) async {
		var rpcRst = await call("CreatePatientAsync", [sessionId,patientInfo,extensionData]);
		return rpcRst;
	}

	Future<PageCollection<PatientInfo>> getPatientPagesAsync(String sessionId,String keyword,int page,int limit) async {
		var rpcRst = await call("GetPatientPagesAsync", [sessionId,keyword,page,limit]);
		var result = PageCollection<PatientInfo>.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<bool> removePatientAsync(String sessionId,String patientCode) async {
		var rpcRst = await call("RemovePatientAsync", [sessionId,patientCode]);
		return rpcRst;
	}

	Future<PatientInfo> findPatientByCodeAsync(String sessionId,String patientCode) async {
		var rpcRst = await call("FindPatientByCodeAsync", [sessionId,patientCode]);
		var result = PatientInfo.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<bool> modifyMenuAsync(String sessionId,String menuCode,MenuInfo menuInfo) async {
		var rpcRst = await call("ModifyMenuAsync", [sessionId,menuCode,menuInfo]);
		return rpcRst;
	}

	Future<bool> createMenuAsync(String sessionId,MenuInfo menuInfo,String extensionData) async {
		var rpcRst = await call("CreateMenuAsync", [sessionId,menuInfo,extensionData]);
		return rpcRst;
	}

	Future<PageCollection<MenuInfo>> getMenuPagesAsync(String sessionId,String keyword,int page,int limit) async {
		var rpcRst = await call("GetMenuPagesAsync", [sessionId,keyword,page,limit]);
		var result = PageCollection<MenuInfo>.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<bool> removeMenuAsync(String sessionId,String menuCode) async {
		var rpcRst = await call("RemoveMenuAsync", [sessionId,menuCode]);
		return rpcRst;
	}

	Future<MenuInfo> findMenuByCodeAsync(String sessionId,String menuCode) async {
		var rpcRst = await call("FindMenuByCodeAsync", [sessionId,menuCode]);
		var result = MenuInfo.fromJson(rpcRst as Map<String, dynamic>);
		return result;
	}

	Future<bool> confirm(String sessionId,String identityApplyCode) async {
		var rpcRst = await call("Confirm", [sessionId,identityApplyCode]);
		return rpcRst;
	}

	Future<bool> reject(String sessionId,String identityApplyCode) async {
		var rpcRst = await call("Reject", [sessionId,identityApplyCode]);
		return rpcRst;
	}

	Future<bool> addFrontAuthorityGroups(String sessionId,FrontAuthorityGroupInfo frontAuthorityGroupInfo,String extensionData) async {
		var rpcRst = await call("AddFrontAuthorityGroups", [sessionId,frontAuthorityGroupInfo,extensionData]);
		return rpcRst;
	}

	Future<bool> deleteFrontAuthorityGroups(String sessionId,String frontAuthorityGroupCode) async {
		var rpcRst = await call("DeleteFrontAuthorityGroups", [sessionId,frontAuthorityGroupCode]);
		return rpcRst;
	}

	Future<bool> updateFrontAuthorityGroups(String sessionId,String frontAuthorityGroupCode,FrontAuthorityGroupInfo frontAuthorityGroupInfo,String extensionData) async {
		var rpcRst = await call("UpdateFrontAuthorityGroups", [sessionId,frontAuthorityGroupCode,frontAuthorityGroupInfo,extensionData]);
		return rpcRst;
	}

}