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

Finding current android device location
orElseThrow (Optional)
Return the contained value, if present, otherwise throw an exception to be created by the provided s
setScale (BigDecimal)
setRequestProperty (URLConnection)
PrintStream (java.io)
Fake signature of an existing Java class.
Random (java.util)
This class provides methods that return pseudo-random values.It is dangerous to seed Random with the
Scanner (java.util)
A parser that parses a text string of primitive types and strings with the help of regular expressio
Stack (java.util)
Stack is a Last-In/First-Out(LIFO) data structure which represents a stack of objects. It enables u
Executor (java.util.concurrent)
An object that executes submitted Runnable tasks. This interface provides a way of decoupling task s
Reference (javax.naming)
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