import org.kie.internal.command.CommandFactory; //导入依赖的package包/类
@SuppressWarnings("unchecked")
public List<String> determineWorkgroups(TaskTemplate taskTemplate, TaskInstance taskInstance) throws StrategyException {
    KieBase knowledgeBase = getKnowledgeBase();

    StatelessKieSession knowledgeSession = knowledgeBase.newStatelessKieSession();

    List<Object> facts = new ArrayList<Object>();
    facts.add(getParameters());
    knowledgeSession.setGlobal("taskTemplate", taskTemplate);
    knowledgeSession.setGlobal("taskInstance", taskInstance);
    knowledgeSession.setGlobal("now", new Date());

    knowledgeSession.execute(CommandFactory.newInsertElements(facts));

    return taskInstance.getWorkgroups();
}
 

import org.kie.internal.command.CommandFactory; //导入依赖的package包/类
@Override
@SuppressWarnings("unchecked")
public Date determineDueDate(TaskTemplate taskTemplate) throws StrategyException {

    TaskInstance taskInstanceVO = new TaskInstance();  // for holding values

    // execute rules only once (results are stored in taskInstanceVO)
    KieBase knowledgeBase = getKnowledgeBase();
    StatelessKieSession knowledgeSession = knowledgeBase.newStatelessKieSession();

    List<Object> facts = new ArrayList<Object>();
    facts.add(getParameters());
    knowledgeSession.setGlobal("taskTemplate", taskTemplate);
    knowledgeSession.setGlobal("taskInstance", taskInstanceVO);

    knowledgeSession.execute(CommandFactory.newInsertElements(facts));

    return Date.from(taskInstanceVO.getDue());
}
 

import org.kie.internal.command.CommandFactory; //导入依赖的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.internal.command.CommandFactory; //导入依赖的package包/类
/**
 *
 */
public void start() throws Exception {

    for (int i = 0; i < 10; i++) {
        Customer customer = customer();
        logger.info("------------------- START ------------------\n"
                + " KieSession fireAllRules. {}", customer);

        List<Command<?>> commands = new ArrayList<Command<?>>();

        commands.add(CommandFactory.newInsert(customer, "customer"));
        commands.add(CommandFactory.newFireAllRules("num-rules-fired"));

        ExecutionResults results = ksession.execute(CommandFactory
                .newBatchExecution(commands));

        int fired = Integer.parseInt(results.getValue("num-rules-fired")
                .toString());

        customer = (Customer)results.getValue("customer");

        logger.info("After rule rules-fired={} {} \n"
                        + "------------------- STOP ---------------------", fired,
                customer);
    }
}
 

import org.kie.internal.command.CommandFactory; //导入依赖的package包/类
/** insert 2 facts into session, then launch query command with one argument */
@Test
public void testQuery() throws Exception {
    KieSession session = getKieSession();

    initializeTemplate(session);

    List<Person> persons = new ArrayList<Person>();
    persons.add(new Person("john", "john", 25));
    persons.add(new Person("sarah", "john", 35));

    session.execute(CommandFactory.newInsertElements(persons));
    assertEquals(2, session.getFactCount());

    QueryResults results = query("people over the age of x", new Object[] {30});
    assertNotNull(results);
}
 

import org.kie.internal.command.CommandFactory; //导入依赖的package包/类
@Test
public void testExecutionResults() throws JAXBException {
    JAXBContext jaxbContext = getJaxbContext();

    KnowledgeBase kbase = KnowledgeBaseFactory.newKnowledgeBase();
    StatefulKnowledgeSession ksession = kbase.newStatefulKnowledgeSession();

    List<Command> commands = new ArrayList<Command>();
    commands.add(CommandFactory.newInsert(new Person("darth", 105), "p"));
    commands.add(CommandFactory.newFireAllRules());

    ExecutionResults res1 = ksession.execute(CommandFactory.newBatchExecution(commands));

    Marshaller marshaller = jaxbContext.createMarshaller();
    marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, Boolean.TRUE);
    ByteArrayOutputStream baos = new ByteArrayOutputStream();
    marshaller.marshal(res1, baos);

    // note it's using xsi:type
    logger.debug(new String(baos.toByteArray()));

    Unmarshaller unmarshaller = jaxbContext.createUnmarshaller();
    ExecutionResults res2 = (ExecutionResults)unmarshaller.unmarshal(new StringReader(baos.toString()));
}
 

import org.kie.internal.command.CommandFactory; //导入依赖的package包/类
@SuppressWarnings("unchecked")
@Override
public Object execute(Asset rulesAsset, Operand input) throws ExecutionException {

    ClassLoader cloudClassLoader = null;
    if (input.getContext() != null && input.getContext().getPackage() != null)
        cloudClassLoader = input.getContext().getPackage().getCloudClassLoader();
    if (cloudClassLoader == null) // fall back to rules asset pkg classloader
        cloudClassLoader = PackageCache.getPackage(rulesAsset.getPackageName()).getCloudClassLoader();

    KnowledgeBaseAsset kbAsset = DroolsKnowledgeBaseCache
            .getKnowledgeBaseAsset(rulesAsset.getName(), null, null, cloudClassLoader);
    if (kbAsset == null) {
        throw new ExecutionException("Cannot load KnowledgeBase asset: "
                + rulesAsset.getPackageName() + "/" + rulesAsset.getLabel());
    }

    KieBase knowledgeBase = kbAsset.getKnowledgeBase();

    StatelessKieSession kSession = knowledgeBase.newStatelessKieSession();

    List<Object> facts = new ArrayList<Object>();
    if (input.getInput() != null) {
        facts.add(input.getInput()); // direct access
        if (input.getInput() instanceof Jsonable)
            facts.add(((Jsonable)input.getInput()).getJson());
    }

    kSession.setGlobal("operand", input);
    kSession.execute(CommandFactory.newInsertElements(facts));
    return input.getResult();
}
 

import org.kie.internal.command.CommandFactory; //导入依赖的package包/类
@SuppressWarnings("unchecked")
public String getSubTaskPlan(TaskRuntimeContext masterTaskContext) throws StrategyException {
    TaskInstance masterTaskInstance = masterTaskContext.getTaskInstance();
    KieBase knowledgeBase = getKnowledgeBase();

    StatelessKieSession knowledgeSession = knowledgeBase.newStatelessKieSession();

    List<Object> facts = new ArrayList<Object>();
    facts.add(getParameters());
    knowledgeSession.setGlobal("masterTaskInstance", masterTaskInstance);
    SubTaskPlan subTaskPlan = new SubTaskPlan();
    knowledgeSession.setGlobal("subTaskPlan", subTaskPlan);
    knowledgeSession.setGlobal("now", new Date());

    knowledgeSession.execute(CommandFactory.newInsertElements(facts));
    try {
        String planXml = marshalJaxb(subTaskPlan);
        if (logger.isDebugEnabled()) {
            logger.debug("SubTask plan XML: " + planXml);
        }
        return planXml;
    }
    catch (Exception ex) {
        throw new StrategyException(ex.getMessage(), ex);
    }

}
 

import org.kie.internal.command.CommandFactory; //导入依赖的package包/类
@Override
public void fireAllRules() {
    FireAllRulesCommand fireAllRulesCommand = new FireAllRulesCommand();
    fireAllRulesCommand.setOutIdentifier(IDENTIFIER_NUMBER_OF_FIRED_RULES);
    commands.add(fireAllRulesCommand);
    ExecutionResults executionResults = kSession.execute(CommandFactory.newBatchExecution(commands));
    this.numberOfFiredRules = (Integer) executionResults.getValue(IDENTIFIER_NUMBER_OF_FIRED_RULES);
}
 

import org.kie.internal.command.CommandFactory; //导入依赖的package包/类
@Override
public void insert(Object... objects) {
    if (objects != null) {
        for (Object object : objects) {
            if (object != null) {
                commands.add(CommandFactory.newInsert(object));
            }
        }
    }
}
 

import org.kie.internal.command.CommandFactory; //导入依赖的package包/类
public void insertAndFireAll(Exchange exchange) {
    final Message in = exchange.getIn();
    final Object body = in.getBody();

    final List<Command<?>> commands = new ArrayList<Command<?>>(2);
    commands.add(CommandFactory.newInsert(body));
    commands.add(CommandFactory.newFireAllRules());

    Command<?> batch = CommandFactory.newBatchExecution(commands);
    in.setBody(batch);
}
 

import org.kie.internal.command.CommandFactory; //导入依赖的package包/类
/**
 * Create commands for Drools engine.
 *
 * @param body {@link org.apache.camel.Exchange}
 */
public Command<ExecutionResults> insertAndFireAll(final Customer body) {

    Command<?> insert = CommandFactory.newInsert(body, "customer");

    @SuppressWarnings("unchecked")
    Command<ExecutionResults> batch = CommandFactory
            .newBatchExecution(Arrays.asList(insert));

    return batch;
}
 

import org.kie.internal.command.CommandFactory; //导入依赖的package包/类
/** build json query command and send it to drools */
private QueryResults query(String queryName, Object[] args) {
    Command command = CommandFactory.newQuery("persons", queryName, args);
    String queryStr = template.requestBody("direct:marshall", command, String.class);

    String json = template.requestBody("direct:test-session", queryStr, String.class);
    ExecutionResults res = (ExecutionResults)template.requestBody("direct:unmarshall", json);
    return (QueryResults)res.getValue("persons");
}
 

import org.kie.internal.command.CommandFactory; //导入依赖的package包/类
@Test
public void testSessionInsert() throws Exception {
    Person person = new Person();
    person.setName("Mauricio");

    InsertObjectCommand cmd = (InsertObjectCommand)CommandFactory.newInsert(person, "salaboy");

    ExecutionResults response = (ExecutionResults)template.requestBody("direct:test-with-session", cmd);
    assertTrue("Expected valid ExecutionResults object", response != null);
    assertTrue("ExecutionResults missing expected fact", response.getFactHandle("salaboy") != null);
    assertTrue("ExecutionResults missing expected fact", response.getFactHandle("salaboy") instanceof FactHandle);
}
 

import org.kie.internal.command.CommandFactory; //导入依赖的package包/类
@Test
public void testNoSessionInsert() throws Exception {
    Person person = new Person();
    person.setName("Mauricio");

    InsertObjectCommand cmd = (InsertObjectCommand)CommandFactory.newInsert(person, "salaboy");

    ExecutionResults response = (ExecutionResults)template.requestBodyAndHeader("direct:test-no-session", cmd, KieComponent.KIE_LOOKUP, "ksession1");
    assertTrue("Expected valid ExecutionResults object", response != null);
    assertTrue("ExecutionResults missing expected fact", response.getFactHandle("salaboy") != null);
}
 

import org.kie.internal.command.CommandFactory; //导入依赖的package包/类
@Test
public void testSessionBatchExecutionCommand() throws Exception {
    Person john = new Person();
    john.setName("John Smith");

    List<Command> commands = new ArrayList<Command>();
    commands.add(CommandFactory.newInsert(john, "john"));
    BatchExecutionCommand batchExecutionCommand = CommandFactory.newBatchExecution(commands);

    ExecutionResults response = (ExecutionResults)template.requestBody("direct:test-with-session", batchExecutionCommand);
    assertTrue("Expected valid ExecutionResults object", response != null);
    assertTrue("ExecutionResults missing expected fact", response.getFactHandle("john") != null);
    assertTrue("ExecutionResults missing expected fact", response.getFactHandle("john") instanceof FactHandle);
}
 

import org.kie.internal.command.CommandFactory; //导入依赖的package包/类
@Test
public void testSessionBatchExecutionCommandWithHeader() throws Exception {

    MockEndpoint mockResult = context.getEndpoint("mock:resultWithHeader", MockEndpoint.class);

    String headerName = "testHeaderName";
    String headerValue = "testHeaderValue";

    Person john = new Person();
    john.setName("John Smith");

    List<Command> commands = new ArrayList<Command>();
    commands.add(CommandFactory.newInsert(john, "john"));
    BatchExecutionCommand batchExecutionCommand = CommandFactory.newBatchExecution(commands);

    Map<String, Object> headers = new HashMap<String, Object>();
    headers.put(headerName, headerValue);

    // set mock expectations
    mockResult.expectedMessageCount(1);
    mockResult.expectedHeaderReceived(headerName, headerValue);

    // do test
    template.requestBodyAndHeaders("direct:test-with-session-withHeader", batchExecutionCommand, headers);

    ExecutionResults response = mockResult.getReceivedExchanges().get(0).getIn().getBody(ExecutionResults.class);

    assertTrue("Expected valid ExecutionResults object", response != null);
    assertTrue("ExecutionResults missing expected fact", response.getFactHandle("john") != null);
    assertTrue("ExecutionResults missing expected fact", response.getFactHandle("john") instanceof FactHandle);

    mockResult.assertIsSatisfied();
}
 

import org.kie.internal.command.CommandFactory; //导入依赖的package包/类
@Test
public void testSessionGetObject() throws Exception {
    FactHandle factHandle = DefaultFactHandle.createFromExternalFormat(handle);
    GetObjectCommand cmd = (GetObjectCommand)CommandFactory.newGetObject(factHandle);
    cmd.setOutIdentifier("rider");

    ExecutionResults response = (ExecutionResults)template.requestBody("direct:test-with-session", cmd);
    assertTrue("Expected valid ExecutionResults object", response != null);
    assertTrue("ExecutionResults missing expected object", response.getValue("rider") != null);
    assertTrue("FactHandle object not of expected type", response.getValue("rider") instanceof Person);
    assertEquals("Hadrian", ((Person)response.getValue("rider")).getName());
}
 

import org.kie.internal.command.CommandFactory; //导入依赖的package包/类
@Test
public void testSessionInsert() throws Exception {
    Person person = new Person();
    person.setName("Mauricio");

    InsertObjectCommand cmd = (InsertObjectCommand)CommandFactory.newInsert(person, "salaboy");
    ExecutionResults response = (ExecutionResults)template.requestBody("direct:test-no-marshal", cmd);
    assertTrue("Expected valid ExecutionResults object", response != null);
    assertTrue("ExecutionResults missing expected fact", response.getFactHandle("salaboy") != null);
}
 

import org.kie.internal.command.CommandFactory; //导入依赖的package包/类
/** bz771203
 * creates batch-execution command with insert. Marshalls it to XML
 * and send to drools */
@Test
public void testInsert() throws Exception {
    Person p = new Person("Alice", "spicy meals", 30);
    List<Command> commands = new ArrayList<Command>();
    commands.add(CommandFactory.newInsert(p, "tempPerson"));
    BatchExecutionCommand command = CommandFactory.newBatchExecution(commands);
    String xmlCommand = template.requestBody("direct:marshall", command, String.class);

    String xml = template.requestBody("direct:test-session", xmlCommand, String.class);
    ExecutionResults res = (ExecutionResults)template.requestBody("direct:unmarshall", xml);

    Object o = res.getFactHandle("tempPerson");
    assertTrue("returned String instead of FactHandle instance", o instanceof FactHandle);
}