import org.kie.server.api.model.ServiceResponse; //导入依赖的package包/类
@GET
@Path(KieMLConstants.URI_GET_MODELS)
public Response getModels(@PathParam(CONTAINER_ID) String containerId) {
	Response response;
	try {
		ServiceResponse<ModelList> result = kieMLServicesBase.getModels(containerId);
		if (result.getType() == ServiceResponse.ResponseType.SUCCESS) {
			response = Response.ok(result).build();
		} else {
			response = Response.status(Status.NOT_FOUND).build();
		}
	} catch (Exception e) {
		logger.warn("Unexpected error retrieving Model List. Message: '{}'", e.getMessage(), e);
		response = Response.serverError().type("text/plain").entity("Error retrieving model list: " + e.getMessage()).build();
	}
	return response;
}
 

import org.kie.server.api.model.ServiceResponse; //导入依赖的package包/类
@GET
@Path(KieMLConstants.URI_GET_MODEL)
public Response getModel(@PathParam(CONTAINER_ID) String containerId, @PathParam(KieMLConstants.PARAM_MODEL_ID) String modelId) {
	Response response;
	try {
		ServiceResponse<Model> result = kieMLServicesBase.getModel(containerId, modelId);
		if (result.getType() == ServiceResponse.ResponseType.SUCCESS) {
			response=  Response.ok(result).build();
		} else {
			response = Response.status(Status.NOT_FOUND).build();
		}
	} catch (Exception e) {
		logger.warn("Unexpected error Model. Message: '{}'", e.getMessage(), e);
		response = Response.serverError().type("text/plain").entity("Unexpected error Model: " + e.getMessage()).build();
	}
	return response;
}
 

import org.kie.server.api.model.ServiceResponse; //导入依赖的package包/类
public Measure processRules(@Body Measure measure) {
	
	KieServicesConfiguration config = KieServicesFactory.newRestConfiguration(
			kieHost, kieUser,
			kiePassword);
	
	Set<Class<?>> jaxBClasses = new HashSet<Class<?>>();
	jaxBClasses.add(Measure.class);
	
	config.addJaxbClasses(jaxBClasses);
	config.setMarshallingFormat(MarshallingFormat.JAXB);
	RuleServicesClient client = KieServicesFactory.newKieServicesClient(config)
			.getServicesClient(RuleServicesClient.class);

       List<Command<?>> cmds = new ArrayList<Command<?>>();
	KieCommands commands = KieServices.Factory.get().getCommands();
	cmds.add(commands.newInsert(measure));
	
    GetObjectsCommand getObjectsCommand = new GetObjectsCommand();
    getObjectsCommand.setOutIdentifier("objects");

	
	cmds.add(commands.newFireAllRules());
	cmds.add(getObjectsCommand);
	BatchExecutionCommand myCommands = CommandFactory.newBatchExecution(cmds,
			"DecisionTableKS");
	ServiceResponse<ExecutionResults> response = client.executeCommandsWithResults("iot-ocp-businessrules-service", myCommands);
			
	List responseList = (List) response.getResult().getValue("objects");
	
	Measure responseMeasure = (Measure) responseList.get(0);
	
	return responseMeasure;

}
 

import org.kie.server.api.model.ServiceResponse; //导入依赖的package包/类
@Test
public void executeCommands() {
	System.out.println("== Sending commands to the server ==");
	RuleServicesClient rulesClient = kieServicesClient
			.getServicesClient(RuleServicesClient.class);
	KieCommands commandsFactory = KieServices.Factory.get().getCommands();
	Command<?> insert = commandsFactory.newInsert("Some String OBJ");
	Command<?> fireAllRules = commandsFactory.newFireAllRules();
	Command<?> batchCommand = commandsFactory.newBatchExecution(Arrays
			.asList(insert, fireAllRules));
	ServiceResponse<ExecutionResults> executeResponse = rulesClient
			.executeCommandsWithResults(RULES_CONTAINER, batchCommand);
	if (executeResponse.getType() == ResponseType.SUCCESS) {
		System.out.println("Commands executed with success! Response: ");
		System.out.println(executeResponse.getResult());
	} else {
		System.out.println("Error executing rules. Message: ");
		System.out.println(executeResponse.getMsg());
	}
}
 

import org.kie.server.api.model.ServiceResponse; //导入依赖的package包/类
@Test
public void executeCommands() {
	System.out.println("== Sending commands to the server ==");
	RuleServicesClient rulesClient = kieServicesClient
			.getServicesClient(RuleServicesClient.class);
	KieCommands commandsFactory = KieServices.Factory.get().getCommands();
	Command<?> insert = commandsFactory.newInsert("Some String OBJ");
	Command<?> fireAllRules = commandsFactory.newFireAllRules();
	Command<?> batchCommand = commandsFactory.newBatchExecution(Arrays
			.asList(insert, fireAllRules));
	ServiceResponse<ExecutionResults> executeResponse = rulesClient.executeCommandsWithResults(RULES_CONTAINER, batchCommand);
	if (executeResponse.getType() == ResponseType.SUCCESS) {
		System.out.println("Commands executed with success! Response: ");
		System.out.println(executeResponse.getResult());
	} else {
		System.out.println("Error executing rules. Message: ");
		System.out.println(executeResponse.getMsg());
	}
}
 

import org.kie.server.api.model.ServiceResponse; //导入依赖的package包/类
@GET
@Path(KieMLConstants.URI_KIEML_CONTAINERS)
public Response listContainers(){
	Response response;		
	try {
		ServiceResponse<KieContainerResourceList> result = kieMLServicesBase.listContainers();
		response =  Response.ok(result).build();
	} catch (Exception e) {
		logger.warn("Unexpected error retrieving container List. Message: '{}'", e.getMessage(), e);
		response = Response.serverError().type("text/plain").entity("Unexpected error retrieving container list: " + e.getMessage()).build();
	}
	return response;
   }
 

import org.kie.server.api.model.ServiceResponse; //导入依赖的package包/类
@POST
@Path(KieMLConstants.URI_PREDICTION)
@Consumes({  MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML })
public Response predict(@javax.ws.rs.core.Context HttpHeaders headers, @PathParam(CONTAINER_ID) String containerId,
		@PathParam(KieMLConstants.PARAM_MODEL_ID) String modelId, String inputPayload) {
	String contentType = getContentType(headers).split(";")[0];
	try {
		Input input = marshallerHelper.unmarshal(containerId, inputPayload, contentType, Input.class);
		ServiceResponse<Result> result = kieMLServicesBase.predict(containerId, modelId, input);
		return Response.ok(result).build();
	} catch (Exception e) {
		logger.warn("Unexpected error running prediction. Message: '{}'", e.getMessage(), e);
		return Response.serverError().type("text/plain").entity("Unexpected error running prediction: " + e.getMessage()).build();
	}
}
 

import org.kie.server.api.model.ServiceResponse; //导入依赖的package包/类
public ServiceResponse<KieContainerResourceList> listContainers() {
	List<KieContainerResource> containersList = containers.keySet().stream()
					.map(context::getContainer)
					.map(KieContainerInstance::getResource)
					.collect(Collectors.toList());
	KieContainerResourceList list = new KieContainerResourceList(containersList);
	return new ServiceResponse<KieContainerResourceList>(ResponseType.SUCCESS, "Containers using KieML extension", list);
}
 

import org.kie.server.api.model.ServiceResponse; //导入依赖的package包/类
@Override
public ServiceResponse<Result> predict(String containerId, String modelId, Input input) {
	String uri = String.join("/", 
			baseUrl,
			KieMLConstants.URI_BASE.replaceFirst("\\{" + KieMLConstants.PARAM_CONTAINER_ID + "\\}", containerId),
			KieMLConstants.URI_PREDICTION.replaceAll("\\{" + KieMLConstants.PARAM_MODEL_ID + "\\}", modelId)
	);
	String body = marshaller.marshall(input);
	return makeHttpPostRequestAndCreateServiceResponse(uri, body, Result.class, new HashMap<>());
}
 

import org.kie.server.api.model.ServiceResponse; //导入依赖的package包/类
@Override
public ServiceResponse<ModelList> getModelList(String containerId) {
	String uri = String.join("/", 
			baseUrl,
			KieMLConstants.URI_BASE.replaceFirst("\\{" + KieMLConstants.PARAM_CONTAINER_ID + "\\}", containerId),
			KieMLConstants.URI_GET_MODELS
	);
	return makeHttpGetRequestAndCreateServiceResponse(uri, ModelList.class);
}
 

import org.kie.server.api.model.ServiceResponse; //导入依赖的package包/类
@Override
public ServiceResponse<Model> getModel(String containerId, String modelId) {
	String uri = String.join("/", 
			baseUrl,
			KieMLConstants.URI_BASE.replaceFirst("\\{" + KieMLConstants.PARAM_CONTAINER_ID + "\\}", containerId),
			KieMLConstants.URI_GET_MODEL.replaceAll("\\{" + KieMLConstants.PARAM_MODEL_ID + "\\}", modelId)
	);
	return makeHttpGetRequestAndCreateServiceResponse(uri, Model.class);
}
 

import org.kie.server.api.model.ServiceResponse; //导入依赖的package包/类
public Greeting extractResult(ServiceResponse<ExecutionResults> response) {
    ExecutionResults res = response.getResult();
    Greeting greeting = null;
    if (res != null) {
        QueryResults queryResults = (QueryResults) res.getValue("greetings");
        for (QueryResultsRow queryResult : queryResults) {
            greeting = (Greeting) queryResult.get("greeting");
            break;
        }
    }

    return greeting;
}
 

import org.kie.server.api.model.ServiceResponse; //导入依赖的package包/类
public Object execute(Command command, String containerId) {
	BatchExecutionHelperProviderImpl batchExecutionHelperProviderImpl = new BatchExecutionHelperProviderImpl();
	XStream xstream = batchExecutionHelperProviderImpl
			.newXStreamMarshaller();
	String payload = xstream.toXML(command);
	LOG.debug("payload=" + payload);
	ServiceResponse<String> serviceResponse = kieServicesClient
			.executeCommands(containerId, payload);
	if (serviceResponse.getType().equals(ResponseType.FAILURE)) {
		throw new RuntimeException(serviceResponse.getMsg());
	}
	String response = serviceResponse.getResult();
	LOG.debug("response=" + response);
	return xstream.fromXML(response);
}
 

import org.kie.server.api.model.ServiceResponse; //导入依赖的package包/类
@Test
public void listCapabilities() {
	ServiceResponse<KieServerInfo> r = kieServicesClient.getServerInfo();
	r.getType();
	KieServerInfo serverInfo = kieServicesClient.getServerInfo()
			.getResult();
	System.out.println("== Server capabilities: ==");
	for (String capability : serverInfo.getCapabilities()) {
		System.out.print(" " + capability);
	}
	System.out.println();
}
 

import org.kie.server.api.model.ServiceResponse; //导入依赖的package包/类
@Test
public void disposeAndCreateContainer() {
	System.out.println("== Disposing and creating containers ==");
	List<KieContainerResource> kieContainers = kieServicesClient
			.listContainers().getResult().getContainers();
	if (kieContainers.size() == 0) {
		System.out.println("No containers available...");
		return;
	}
	KieContainerResource container = kieContainers.get(0);
	String containerId = container.getContainerId();
	ServiceResponse<Void> responseDispose = kieServicesClient
			.disposeContainer(containerId);
	if (responseDispose.getType() == ResponseType.FAILURE) {
		System.out
				.println("Error disposing " + containerId + ". Message: ");
		System.out.println(responseDispose.getMsg());
		return;
	}
	System.out.println("Success Disposing container " + containerId);
	System.out.println("Trying to recreate the container...");
	ServiceResponse<KieContainerResource> createResponse = kieServicesClient
			.createContainer(containerId, container);
	if (createResponse.getType() == ResponseType.FAILURE) {
		System.out.println("Error creating " + containerId + ". Message: ");
		System.out.println(responseDispose.getMsg());
		return;
	}
	System.out.println("Container recreated with success!");
}
 

import org.kie.server.api.model.ServiceResponse; //导入依赖的package包/类
@Test
public void executeCommands() {
	System.out.println("== Sending commands to the server ==");
	RuleServicesClient rulesClient = kieServicesClient
			.getServicesClient(RuleServicesClient.class);
	KieCommands commandsFactory = KieServices.Factory.get().getCommands();
	Command<?> insert = commandsFactory.newInsert("Some String OBJ");
	Command<?> fireAllRules = commandsFactory.newFireAllRules();
	Command<?> batchCommand = commandsFactory.newBatchExecution(Arrays
			.asList(insert, fireAllRules));
	ServiceResponse<String> executeResponse = rulesClient.executeCommands(RULES_CONTAINER, batchCommand);
	if (executeResponse.getType() == ResponseType.SUCCESS) {
		System.out.println("Commands executed with success! Response: ");
		System.out.println(executeResponse.getResult());
	} else {
		System.out.println("Error executing rules. Message: ");
		System.out.println(executeResponse.getMsg());
	}
}
 

import org.kie.server.api.model.ServiceResponse; //导入依赖的package包/类
public ServiceResponse<ModelList> getModels(String containerId) {
	checkContainer(containerId);
	return new ServiceResponse<ModelList>(ResponseType.SUCCESS, "Model List",
			containers.get(containerId).modelsList());
}
 

import org.kie.server.api.model.ServiceResponse; //导入依赖的package包/类
public ServiceResponse<Model> getModel(String containerId, String modelId) {
	checkContainer(containerId);
	return containers.get(containerId).modelsList().getModels().stream().filter(m -> m.getId().equals(modelId))
			.map(m -> new ServiceResponse<Model>(ResponseType.SUCCESS, "Found model", m)).findFirst()
			.orElse(new ServiceResponse<Model>(ResponseType.FAILURE, "Model Not found: " + modelId));
}
 

import org.kie.server.api.model.ServiceResponse; //导入依赖的package包/类
public ServiceResponse<Result> predict(String containerId, String modelId, Input input); 

import org.kie.server.api.model.ServiceResponse; //导入依赖的package包/类
public ServiceResponse<ModelList> getModelList(String containerId);