How to use org.drools.definition.process

  private static String createMessage(final Process process) {
    return process.getName() + " cannot be integrated";
  }
}

private void addNodesInfo(List<DiagramNodeInfo> nodeInfos, Node[] nodes, String prefix) {
  for (Node node: nodes) {
    nodeInfos.add(new DiagramNodeInfo(
      prefix + node.getId(),
      (Integer) node.getMetaData().get("x"),
      (Integer) node.getMetaData().get("y"),
      (Integer) node.getMetaData().get("width"),
      (Integer) node.getMetaData().get("height")));
    if (node instanceof NodeContainer) {
      addNodesInfo(nodeInfos, ((NodeContainer) node).getNodes(), prefix + node.getId() + ":");
    }
  }
}

/**
 * Add a rule flow to this package.
 */
public void addProcess( Process process ) {
  if (this.ruleFlows == Collections.EMPTY_MAP) {
    this.ruleFlows = new HashMap<String, Process>();
  }
  this.ruleFlows.put( process.getId(),
            process );
}

public static ProcessDefinitionRef processDefinition(Process process) {
  long version = 0;
  try {
    version = new Long(process.getVersion());
  } catch (NumberFormatException e) {
    // Do nothing, keep version 0
  }
  ProcessDefinitionRef result = new ProcessDefinitionRef(
    process.getId(), process.getName(), version);
  result.setPackageName(process.getPackageName());
  result.setDeploymentId("N/A");
  return result;
}

@Test
public void testProcessDefinition(){
  org.drools.definition.process.Process process = CommandDelegate.getProcess("Minimal");
  ProcessDefinitionRef processDefinitionRef = Transform.processDefinition(process);
  assertEquals(processDefinitionRef.getId(),process.getId());
  assertEquals(processDefinitionRef.getPackageName(),process.getPackageName());
  assertEquals(processDefinitionRef.getName(),process.getName());
}

public void visitWorkflowProcess(final WorkflowProcess oldDefinition) {
  String oldProcessId = oldDefinition.getId();
  boolean found = false;
  for (org.drools.definition.process.Process process: newPkg.getProcesses()) {
    if (oldProcessId.equals(process.getId())) {
      found = true;
      break;
    }
  }
  if (!found){
    listener.debug("BinaryResourceDiffProducerImpl: Process "+oldProcessId+" is not present anymore. Adding to removed list.");
    this.removedDefinitions.add(oldDefinition);
    return;
  }
}

private String createNodeId(NodeInstance nodeInstance) {
  Node node = nodeInstance.getNode();
  if (node == null) {
    return "";
  }
  String nodeId = "" + node.getId();
  NodeContainer nodeContainer = node.getNodeContainer();
  while (nodeContainer != null) {
    if (nodeContainer instanceof Node) {
      node = (Node) nodeContainer;
      nodeContainer = node.getNodeContainer();
      // TODO fix this filter out hidden compositeNode inside ForEach node
      if (!(nodeContainer.getClass().getName().endsWith("ForEachNode"))) {
        nodeId = node.getId() + ":" + nodeId;
      }
    } else {
      break;
    }
  }
  return nodeId;
}

public void removeProcess( final String id ) {
  Process process = this.processes.get( id );
  if (process == null) {
    throw new IllegalArgumentException( "Process '" + id + "' does not exist for this Rule Base." );
  }
  this.eventSupport.fireBeforeProcessRemoved( process );
  lock();
  try {
    this.processes.remove( id );
    this.pkgs.get(process.getPackageName()).removeRuleFlow(id);
  } finally {
    unlock();
  }
  this.eventSupport.fireAfterProcessRemoved( process );
}

@Override
public String getCurrentNodeName() {
  WorkflowProcessInstance process = (WorkflowProcessInstance) ksession.getProcessInstance(this.processInstanceId);
  long nodeId = process.getNodeInstances().iterator().next().getNodeId();
  return ((WorkflowProcess) this.kbase.getProcess(this.processId)).getNode(nodeId).getName();
}

  private void overrideReSource( Package pkg, Resource res ) {
    for ( Rule r : pkg.getRules() ) {
      if ( isSwappable( r.getResource(), res ) ) {
        r.setResource( res );
      }
    }
    for ( TypeDeclaration d : pkg.getTypeDeclarations().values() ) {
      if ( isSwappable( d.getResource(), res ) ) {
        d.setResource( res );
      }
    }
    for ( Function f : pkg.getFunctions().values() ) {
      if ( isSwappable( f.getResource(), res ) ) {
        f.setResource( res );
      }
    }
    for ( Process p : pkg.getRuleFlows().values() ) {
      if  ( isSwappable( p.getResource(), res ) ) {
        p.setResource( res );
      }
    }
//        for ( WindowDeclaration w : pkg.getWindowDeclarations().values() ) {
//            if ( isSwappable( w.getResource(), res ) ) {
//                w.setResource( res );
//            }
//        }
  }

List<DiagramNodeInfo> nodeList = new ArrayList<DiagramNodeInfo>();
if (process instanceof WorkflowProcess) {
  addNodesInfo(nodeList, ((WorkflowProcess) process).getNodes(), "id=");

public void addProcess( final Process process ) {
  // XXX: could use a synchronized(processes) here.
  this.eventSupport.fireBeforeProcessAdded( process );
  lock();
  try {
    this.processes.put( process.getId(),
              process );
  } finally {
    unlock();
  }
  this.eventSupport.fireAfterProcessAdded( process );
}

public static Process getProcessByName(String name) {
  KnowledgeBase kbase = getSession().getKnowledgeBase();
  for (KnowledgePackage kpackage: kbase.getKnowledgePackages()) {
    for (Process process: kpackage.getProcesses()) {
      if (name.equals(process.getName())) {
        return process;
      }
    }
  }
  return null;
}

public String getCurrentNodeName() {
  StatefulKnowledgeSession ksession = this.getKnowledgeSession();
  try{
    WorkflowProcessInstance process = (WorkflowProcessInstance) ksession.getProcessInstance(this.processInstanceId);
    long nodeId = process.getNodeInstances().iterator().next().getNodeId();
    return ((WorkflowProcess) this.kbase.getProcess(this.processId)).getNode(nodeId).getName();
  } finally{
    ksession.dispose();
  }
}

public static Process getProcess(String processId) {
  KnowledgeBase kbase = getSession().getKnowledgeBase();
  for (KnowledgePackage kpackage: kbase.getKnowledgePackages()) {
    for (Process process: kpackage.getProcesses()) {
      if (processId.equals(process.getId())) {
        return process;
      }
    }
  }
  return null;
}

@Test
public void testGetProcesses() {
  List<Process> processes = CommandDelegate.getProcesses();
  boolean minimalProcessFound = false;
  for( Process process : processes ) { 
    if( "Minimal Process".equals(process.getName()) ) {
      minimalProcessFound = true;
    }
  }
  assertTrue( minimalProcessFound );
}

@Test
public void testGetProcessByName(){
  assertEquals("Minimal", CommandDelegate.getProcessByName("Minimal Process").getId());
}

@Test
public void testGetProcess() {
  assertEquals("Minimal Process" , CommandDelegate.getProcess("Minimal").getName());
}

  Process process = (Process) kd;
  this.listener.debug( "KnowledgeAgent removing Process=" + process );
  this.kbase.removeProcess( process.getId() );
} else if ( kd instanceof TypeDeclaration ) {

taskData.setProcessInstanceId(workItem.getProcessInstanceId());
if (session != null && session.getProcessInstance(workItem.getProcessInstanceId()) != null) {
  taskData.setProcessId(session.getProcessInstance(workItem.getProcessInstanceId()).getProcess().getId());