How to use

Process

in

org.drools.definition.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;
}

/**
 * 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 );
}

@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());
}

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

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 );
}

  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 );
//            }
//        }
  }

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;
  }
}

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 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 );
}

@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 );
}

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 testGetProcess() {
  assertEquals("Minimal Process" , CommandDelegate.getProcess("Minimal").getName());
}

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

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

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

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