org.jbpm.workflow.core.node.RuleSetNode java code examples

Add the Codota plugin to your IDE and get smart completions

private void myMethod () {
 Point p =new Point(x, y)
new Point()
MouseEvent e;e.getPoint()
Smart code suggestions by Tabnine
}

private void postProcessNodes(RuleFlowProcess process, NodeContainer container, ProcessBuildData buildData, ExtensibleXmlParser parser) {
  for (Node node : container.getNodes()) {
    if (node instanceof SubProcessNode) {
      Map<String, String> processes = (Map<String, String>) buildData.getMetaData("ProcessElements");
      if (processes != null) {
        SubProcessNode subprocessNode = (SubProcessNode) node;
        subprocessNode.setProcessId(processes.getOrDefault(subprocessNode.getProcessId(), subprocessNode.getProcessId()));    
      }
    } else if (node instanceof RuleSetNode) {
      Map<String, Decision> decisions = (Map<String, Decision>) buildData.getMetaData("DecisionElements");
      RuleSetNode ruleSetNode = (RuleSetNode) node;
      if (decisions != null && decisions.containsKey(ruleSetNode.getRuleFlowGroup())) {
        Decision decision = decisions.get(ruleSetNode.getRuleFlowGroup());
        ruleSetNode.setRuleFlowGroup(null);
        ruleSetNode.setLanguage(RuleSetNode.DMN_LANG);
        ruleSetNode.setNamespace((String) parser.getNamespaceURI(decision.getNamespace()));
        ruleSetNode.setModel(decision.getModel());
        ruleSetNode.setDecision(decision.getDecision());
      }
    }
    if (node instanceof NodeContainer) {                
      postProcessNodes(process, (NodeContainer) node, buildData, parser);
    }
  }
}

protected Node createNode() {
  return new RuleSetNode();
}

public void writeNode(Node node, StringBuilder xmlDump, int metaDataType) {
  RuleSetNode ruleSetNode = (RuleSetNode) node;
  writeNode("businessRuleTask", ruleSetNode, xmlDump, metaDataType);
  if (ruleSetNode.getRuleFlowGroup() != null) {
    xmlDump.append("g:ruleFlowGroup=\"" + XmlBPMNProcessDumper.replaceIllegalCharsAttribute(ruleSetNode.getRuleFlowGroup()) + "\" " + EOL);
  }
  
  xmlDump.append(" implementation=\"" + XmlBPMNProcessDumper.replaceIllegalCharsAttribute(ruleSetNode.getLanguage()) + "\" >" + EOL);        
  
  writeExtensionElements(ruleSetNode, xmlDump);
  writeIO(ruleSetNode, xmlDump);
  endNode("businessRuleTask", xmlDump);
}

protected void handleNode(final Node node,
             final Element element,
             final String uri,
             final String localName,
             final ExtensibleXmlParser parser) throws SAXException {
  super.handleNode(node, element, uri, localName, parser);
  String decisionRef = element.getAttribute("decisionRef");
  if (decisionRef == null) {
    throw new IllegalArgumentException("Decision information is mandatory");
  }
  RuleSetNode ruleSetNode = (RuleSetNode) node;
  ruleSetNode.setRuleFlowGroup(decisionRef);
  ruleSetNode.setLanguage(RuleSetNode.DRL_LANG);
  ruleSetNode.setNamespace((String) ruleSetNode.removeParameter(NAMESPACE_PROP));
  ruleSetNode.setModel((String) ruleSetNode.removeParameter(MODEL_PROP));
  ruleSetNode.setDecision((String) ruleSetNode.removeParameter(DECISION_PROP));
  Map<String, String> inputs = new HashMap<>();
  Map<String, String> outputs = new HashMap<>();
  Map<String, String> inputTypes = new HashMap<>();
  Map<String, String> outputTypes = new HashMap<>();
  loadDataInputsAndOutputs(element, inputs, outputs, inputTypes, outputTypes, parser);
  ruleSetNode.setMetaData("DataInputs", inputTypes);
  ruleSetNode.setMetaData("DataOutputs", outputTypes);
  for (Entry<String, String> entry : inputs.entrySet()) {
    ruleSetNode.addInAssociation(new DataAssociation(entry.getValue(), entry.getKey(), Collections.emptyList(), null));
  }
  for (Entry<String, String> entry : outputs.entrySet()) {
    ruleSetNode.addOutAssociation(new DataAssociation(entry.getKey(), entry.getValue(), Collections.emptyList(), null));
  }
}

String ruleFlowGroup = element.getAttribute("ruleFlowGroup");
if (ruleFlowGroup != null) {
  ruleSetNode.setRuleFlowGroup(ruleFlowGroup);
  language = RuleSetNode.DRL_LANG;
ruleSetNode.setLanguage(language);
ruleSetNode.setNamespace((String) ruleSetNode.removeParameter(NAMESPACE_PROP));
ruleSetNode.setModel((String) ruleSetNode.removeParameter(MODEL_PROP));
ruleSetNode.setDecision((String) ruleSetNode.removeParameter(DECISION_PROP));

assertThat(decisionTask.getName()).isEqualTo("call my decision");
assertThat(decisionTask.getLanguage()).isEqualTo(RuleSetNode.DMN_LANG);
assertThat(decisionTask.getRuleFlowGroup()).isNull();
assertThat(decisionTask.getNamespace()).isEqualTo("http://www.trisotech.com/definitions/_0020_vacation_days");
assertThat(decisionTask.getModel()).isEqualTo("_0020_vacation_days");
assertThat(decisionTask.getDecision()).isEqualTo("Total Vacation Days");
assertThat(decisionTask.getInAssociations()).hasSize(0);        
assertThat(decisionTask.getOutAssociations()).hasSize(0);

assertThat(decisionTask.getLanguage()).isEqualTo(RuleSetNode.DRL_LANG);
assertThat(decisionTask.getName()).isEqualTo("Make a decision");
assertThat(decisionTask.getRuleFlowGroup()).isEqualTo("decisionName");
assertThat(decisionTask.getInAssociations()).hasSize(1);
assertThat(decisionTask.getInAssociations().get(0).getSources()).hasSize(1);
assertThat(decisionTask.getInAssociations().get(0).getSources().get(0)).isEqualTo("caseFile_invoice");
assertThat(decisionTask.getInAssociations().get(0).getTarget()).isEqualTo("toApprove");   
assertThat(decisionTask.getOutAssociations()).hasSize(1);
assertThat(decisionTask.getOutAssociations().get(0).getSources()).hasSize(1);
assertThat(decisionTask.getOutAssociations().get(0).getSources().get(0)).isEqualTo("decided");
assertThat(decisionTask.getOutAssociations().get(0).getTarget()).isEqualTo("caseFile_invoice");

} else if (node instanceof RuleSetNode) {
  final RuleSetNode ruleSetNode = (RuleSetNode) node;
  if (ruleSetNode.getFrom() == null && !acceptsNoIncomingConnections(node)) {
    addErrorMessage(process,
            node,
  if (ruleSetNode.getTo() == null && !acceptsNoOutgoingConnections(node)) {
    addErrorMessage(process,
            node,
  final String language = ruleSetNode.getLanguage();
    final String ruleFlowGroup = ruleSetNode.getRuleFlowGroup();
    if (ruleFlowGroup == null || "".equals(ruleFlowGroup)) {
      addErrorMessage(process,
    final String namespace = ruleSetNode.getNamespace();
    if (namespace == null || "".equals(namespace)) {
      addErrorMessage(process,
    final String model = ruleSetNode.getModel();
    if (model == null || "".equals(model)) {
      addErrorMessage(process,
  if (ruleSetNode.getTimers() != null) {
    for (Timer timer : ruleSetNode.getTimers().keySet()) {
      validateTimer(timer,
             node,

process.addNode(actionNode);
RuleSetNode ruleSetNode = new RuleSetNode();
ruleSetNode.setName("action");
ruleSetNode.setMetaData("x", 1);
ruleSetNode.setMetaData("y", 2);
ruleSetNode.setMetaData("width", 3);
ruleSetNode.setMetaData("height", 4);
ruleSetNode.setRuleFlowGroup("ruleFlowGroup");
Timer timer = new Timer();
timer.setDelay("100");
timer.setPeriod("100");
action = new DroolsConsequenceAction("dialect", "consequence");
ruleSetNode.addTimer(timer, action);
timer = new Timer();
timer.setDelay("200");
timer.setPeriod("200");
action = new DroolsConsequenceAction("dialect", "consequence");
ruleSetNode.addTimer(timer, action);
process.addNode(ruleSetNode);

Map<String, Object> inputs = evaluateParameters(ruleSetNode);
if (ruleSetNode.isDMN()) {
  String namespace = resolveVariable(ruleSetNode.getNamespace());
  String model = resolveVariable(ruleSetNode.getModel());
  String decision = resolveVariable(ruleSetNode.getDecision());
  setRuleFlowGroup(resolveRuleFlowGroup(ruleSetNode.getRuleFlowGroup()));

public void writeNode(Node node, StringBuilder xmlDump, boolean includeMeta) {
  RuleSetNode ruleSetNode = (RuleSetNode) node;
  writeNode("ruleSet", ruleSetNode, xmlDump, includeMeta);
  String ruleFlowGroup = ruleSetNode.getRuleFlowGroup();
  if (ruleFlowGroup != null) {
    xmlDump.append("ruleFlowGroup=\"" + ruleFlowGroup + "\" ");
  }
  if (ruleSetNode.getTimers() != null || (includeMeta && containsMetaData(ruleSetNode))) {
    xmlDump.append(">\n");
    if (ruleSetNode.getTimers() != null) {
      writeTimers(ruleSetNode.getTimers(), xmlDump);
    }
    if (includeMeta) {
      writeMetaData(ruleSetNode, xmlDump);
    }
    endNode("ruleSet", xmlDump);
  } else {
    endNode(xmlDump);
  }
}

public String getRuleFlowGroup() {
  if (ruleFlowGroup == null || ruleFlowGroup.trim().length() == 0) {
    ruleFlowGroup = getRuleSetNode().getRuleFlowGroup();
  }
  return ruleFlowGroup;
}

public void handleNode(final Node node, final Element element, final String uri,
    final String localName, final ExtensibleXmlParser parser)
    throws SAXException {
  super.handleNode(node, element, uri, localName, parser);
  RuleSetNode ruleSetNode = (RuleSetNode) node;
  String ruleFlowGroup = element.getAttribute("ruleFlowGroup");
  if (ruleFlowGroup != null && ruleFlowGroup.length() > 0) {
    ruleSetNode.setRuleFlowGroup(ruleFlowGroup);
  }
}

protected Map<String, Object> evaluateParameters(RuleSetNode ruleSetNode) {
  Map<String, Object> replacements = new HashMap<String, Object>();
  for (Iterator<DataAssociation> iterator = ruleSetNode.getInAssociations().iterator(); iterator.hasNext(); ) {
    DataAssociation association = iterator.next();
    if (association.getTransformation() != null) {
        } catch (Throwable t) {
          logger.error("Could not find variable scope for variable {}", association.getSources().get(0));
          logger.error("when trying to execute RuleSetNode {}", ruleSetNode.getName());
          logger.error("Continuing without setting parameter.");
  for (Map.Entry<String, Object> entry: ruleSetNode.getParameters().entrySet()) {
    if (entry.getValue() instanceof String) {

@Override
public void build(Process process, ProcessDescr processDescr, ProcessBuildContext context, Node node) {
  super.build(process, processDescr, context, node);
  WorkflowProcess wfProcess = (WorkflowProcess) process;
  Map<String, Object> parameters = new HashMap<String, Object>();
  parameters.put("imports", wfProcess.getImports());
  parameters.put("classloader", context.getConfiguration().getClassLoader());
  
  for (DataAssociation dataAssociation: ((RuleSetNode) node).getInAssociations()) {
    Transformation transformation = dataAssociation.getTransformation();
    if (transformation != null) {				
      
      DataTransformer transformer = DataTransformerRegistry.get().find(transformation.getLanguage());
      transformation.setCompiledExpression(transformer.compile(transformation.getExpression(), parameters));
      
    }
  }
  
  for (DataAssociation dataAssociation: ((RuleSetNode) node).getOutAssociations()) {
    Transformation transformation = dataAssociation.getTransformation();
    if (transformation != null) {
      
      DataTransformer transformer = DataTransformerRegistry.get().find(transformation.getLanguage());
      transformation.setCompiledExpression(transformer.compile(transformation.getExpression(), parameters));
      
    }
  }
}

private void processOutputs(Map<String, Object> objects) {
  RuleSetNode ruleSetNode = getRuleSetNode();
  if (ruleSetNode != null) {
    for (Iterator<DataAssociation> iterator = ruleSetNode.getOutAssociations().iterator(); iterator.hasNext(); ) {
      DataAssociation association = iterator.next();
      if (association.getTransformation() != null) {

  subNode = subNode.getNextSibling();
ruleSetNode.addInAssociation(new DataAssociation(
    source,
    dataInputs.get(target), assignments, transformation));
  if (nl.getLength() > 1) {
    ruleSetNode.setParameter(dataInputs.get(to), subSubNode.getTextContent());
    return;
  } else if (nl.getLength() == 0) {
    result = nl.item(0);
  ruleSetNode.setParameter(dataInputs.get(to), result);

public RuleSetNodeFactory timer(String delay, String period, String dialect, String action) {
  Timer timer = new Timer();
  timer.setDelay(delay);
  timer.setPeriod(period);
  getRuleSetNode().addTimer(timer, new DroolsConsequenceAction(dialect, action));
  return this;
}

  subNode = subNode.getNextSibling();
ruleSetNode.addOutAssociation(new DataAssociation(dataOutputs.get(source), target, assignments, transformation));

assertThat(decisionTask.getName()).isEqualTo("call my decision");
assertThat(decisionTask.getLanguage()).isEqualTo(RuleSetNode.DMN_LANG);
assertThat(decisionTask.getRuleFlowGroup()).isNull();
assertThat(decisionTask.getNamespace()).isEqualTo("http://www.trisotech.com/definitions/_0020_vacation_days");
assertThat(decisionTask.getModel()).isEqualTo("_0020_vacation_days");
assertThat(decisionTask.getDecision()).isEqualTo("Total Vacation Days");
assertThat(decisionTask.getInAssociations()).hasSize(0);        
assertThat(decisionTask.getOutAssociations()).hasSize(0);

Javadoc

Default implementation of a RuleSet node.

Most used methods

Popular in Java

Start an intent from android
getSupportFragmentManager (FragmentActivity)
getApplicationContext (Context)
notifyDataSetChanged (ArrayAdapter)
File (java.io)
An "abstract" representation of a file system entity identified by a pathname. The pathname may be a
Date (java.sql)
A class which can consume and produce dates in SQL Date format. Dates are represented in SQL as yyyy
Dictionary (java.util)
Note: Do not use this class since it is obsolete. Please use the Map interface for new implementatio
Enumeration (java.util)
A legacy iteration interface.New code should use Iterator instead. Iterator replaces the enumeration
Stream (java.util.stream)
A sequence of elements supporting sequential and parallel aggregate operations. The following exampl
Location (org.springframework.beans.factory.parsing)
Class that models an arbitrary location in a Resource.Typically used to track the location of proble
Top 17 Plugins for Android Studio

How to useRuleSetNode in org.jbpm.workflow.core.node

Best Java code snippets using org.jbpm.workflow.core.node.RuleSetNode (Showing top 20 results out of 315)

How to use
RuleSetNode
in
org.jbpm.workflow.core.node