[jBPM Users] - BusinessCalendarImpl throws null pointer exception
by joshsiaw
=== Environment ==============================
- jBPM Version : 4.2
- Database : MySql 5.0.67
- JDK : 1.6.0_16
- Container : 1.6.0_16
- Configuration : default jbpm.cfg.xml copied from Examples project
- Libraries : default jBPM 4.2 libraries
=== Process ==================================
| <?xml version="1.0" encoding="UTF-8"?>
|
| <process name="test" xmlns="http://jbpm.org/4.0/jpdl">
| <start g="193,63,48,48" name="start1">
| <transition to="Inspection"/>
| </start>
| <task assignee="valTech1" g="170,141,92,52" name="Inspection" duedate="10 business hours">
| <transition to="Verify Inspection Report" name="timeout" g="11,-7">
| </transition>
| </task>
| <task assignee="svt" g="147,224,136,52" name="Verify Inspection Report">
| <transition to="Valuation"/>
| </task>
| <task assignee="avo" g="171,316,92,52" name="Valuation">
| <transition to="Certify Valuation"/>
| </task>
| <task assignee="vo" g="165,397,106,52" name="Certify Valuation">
| <transition to="Billing"/>
| </task>
| <task assignee="clerk" g="173,478,92,52" name="Billing">
| <transition to="end1"/>
| </task>
| <end g="194,558,48,48" name="end1"/>
| </process>
|
=== API ===================================
| Task task = jbpmServices.getTaskService().createTaskQuery().processDefinitionId("test-1").activityName("Inspection").uniqueResult();
| Calendar cal = Calendar.getInstance();
| BusinessCalendarImpl businessCalendar = new BusinessCalendarImpl();
| Duration duration = new Duration("10 business days");
| Date date = businessCalendar.add(cal.getTime(), duration);
| task.setDuedate(date);
|
=== Stacktrace ==============================
anonymous wrote :
| Exception in thread "main" java.lang.NullPointerException
| at org.jbpm.pvm.internal.cal.BusinessCalendarImpl.findDay(BusinessCalendarImpl.java:154)
| at org.jbpm.pvm.internal.cal.BusinessCalendarImpl.findDayPart(BusinessCalendarImpl.java:160)
| at org.jbpm.pvm.internal.cal.BusinessCalendarImpl.add(BusinessCalendarImpl.java:78)
| at eval.tester.tester.testTaskDueDate(tester.java:56)
| at eval.tester.tester.main(tester.java:39)
|
=== Debug logs ==============================
Fails at this point:
| protected Day findDay(Date date) {
| Calendar calendar = createCalendar();
| calendar.setTime(date);
| int weekDayIndex = calendar.get(Calendar.DAY_OF_WEEK);
| return days[weekDayIndex];
| }
|
=== Problem description =========================
BusinessCalendarImpl throws null pointer exception. Looking through the code it looks like its caused by the days[] being null. Am I using it correctly? Any help would be appreciated.
View the original post : http://www.jboss.org/index.html?module=bb&op=viewtopic&p=4266251#4266251
Reply to the post : http://www.jboss.org/index.html?module=bb&op=posting&mode=reply&p=4266251
16 years, 4 months
[jBPM Users] - Re: [JBPM4] Is there a way to create subprocess programatica
by sushantgupta402
Hi ZP,
Really sorry for not sending you this earlier. I had the files ready but somehow just couldn't send it to you. Here is the outline of what I did. Where-ever I wanted the fork functionality I have created a simple node and added the following as the handler "CustomNodeHandlerFork.java" and where ever I needed join I added "CustomNodeHandlerJoin.java" as the handler. Above 2 handler are the modified form of the "ForkActivity" and "JoinActivity" class of JBPMv4. Below is the code:
=================================================
| import java.util.ArrayList;
| import java.util.List;
|
| import org.jbpm.api.Execution;
| import org.jbpm.api.activity.ActivityExecution;
| import org.jbpm.jpdl.internal.activity.JpdlActivity;
| import org.jbpm.pvm.internal.model.Activity;
| import org.jbpm.pvm.internal.model.ActivityImpl;
| import org.jbpm.pvm.internal.model.Condition;
| import org.jbpm.pvm.internal.model.ExecutionImpl;
| import org.jbpm.pvm.internal.model.Transition;
| import org.jbpm.pvm.internal.model.TransitionImpl;
|
|
| public class CustomNodeHandler extends JpdlActivity {
|
| private static final long serialVersionUID = 1L;
|
| public void execute(ActivityExecution execution) {
| execute((ExecutionImpl)execution);
| }
|
| public void execute(ExecutionImpl execution) {
| Activity activity = execution.getActivity();
| List<ExecutionImpl> listOfExecution = new ArrayList();
| int noOfTrantisions = Integer.parseInt(JBPMTransientStorage.getTransientVariable(execution.getId(),"noOfTrantisionsFromNode").toString());
| // evaluate the conditions and find the transitions that should be forked
| List<Transition> forkingTransitions = new ArrayList<Transition>();
| for(int i=0 ; i < noOfTrantisions-1 ; i++) {
| forkingTransitions.add(activity.getOutgoingTransitions().get(0));
| }
| List<Transition> outgoingTransitions = activity.getOutgoingTransitions();
| for (Transition transition: outgoingTransitions) {
| Condition condition = transition.getCondition();
| if ( (condition==null)
| || (condition.evaluate(execution))
| ) {
| forkingTransitions.add(transition);
| }
| }
|
| // if no outgoing transitions should be forked,
| if (forkingTransitions.size()==0) {
| // end this execution
| execution.end();
|
| // if there is exactly 1 transition to be taken, just use the incoming execution
| } else if (forkingTransitions.size()==1) {
| execution.take(forkingTransitions.get(0));
|
| // if there are more transitions
| } else {
| ExecutionImpl concurrentRoot = null;
| if (Execution.STATE_ACTIVE_ROOT.equals(execution.getState())) {
| concurrentRoot = execution;
| execution.setState(Execution.STATE_INACTIVE_CONCURRENT_ROOT);
| execution.setActivity(null);
| } else if (Execution.STATE_ACTIVE_CONCURRENT.equals(execution.getState())) {
| concurrentRoot = execution.getParent();
| }
|
| for (Transition transition: forkingTransitions) {
| // launch a concurrent path of execution
| String childExecutionName = transition.getName();
| ExecutionImpl concurrentExecution = concurrentRoot.createExecution(childExecutionName);
| concurrentExecution.setActivity(activity);
| concurrentExecution.setState(Execution.STATE_ACTIVE_CONCURRENT);
| concurrentExecution.take(transition);
| listOfExecution.add(concurrentExecution.getSubProcessInstance());
| if (concurrentRoot.isEnded()) {
| break;
| }
| }
| JBPMTransientStorage.setTransientVariable(execution.getId(),"LIST_OF_EXECUTIONS", listOfExecution);
| }
| }
| }
| =================================================
| import java.util.ArrayList;
| import java.util.List;
|
| import org.hibernate.LockMode;
| import org.hibernate.Session;
| import org.jbpm.api.Execution;
| import org.jbpm.api.JbpmException;
| import org.jbpm.api.activity.ActivityExecution;
| import org.jbpm.jpdl.internal.activity.JpdlActivity;
| import org.jbpm.pvm.internal.env.Environment;
| import org.jbpm.pvm.internal.model.Activity;
| import org.jbpm.pvm.internal.model.ExecutionImpl;
| import org.jbpm.pvm.internal.model.Transition;
|
|
| public class CustomNodeHandlerJoin extends JpdlActivity {
|
| private static final long serialVersionUID = 1L;
|
| int multiplicity = -1;
| LockMode lockMode = LockMode.UPGRADE;
|
| public void execute(ActivityExecution execution) {
| execute((ExecutionImpl)execution);
| }
|
| public void execute(ExecutionImpl execution) {
| Activity activity = execution.getActivity();
| // if this is a single, non concurrent root
| if (Execution.STATE_ACTIVE_ROOT.equals(execution.getState())) {
| // just pass through
| Transition transition = activity.getDefaultOutgoingTransition();
| if (transition==null) {
| throw new JbpmException("join must have an outgoing transition");
| }
| execution.take(transition);
| } else if (Execution.STATE_ACTIVE_CONCURRENT.equals(execution.getState())) {
| // force version increment in the parent execution
| Session session = Environment.getFromCurrent(Session.class);
| session.lock(execution.getParent(), lockMode);
| execution.setState(Execution.STATE_INACTIVE_JOIN);
| execution.waitForSignal();
| ExecutionImpl concurrentRoot = execution.getParent();
| List<ExecutionImpl> joinedExecutions = getJoinedExecutions(concurrentRoot, activity);
| if (isComplete(joinedExecutions, activity, concurrentRoot)) {
| endJoinedExecutions(joinedExecutions);
| ExecutionImpl outgoingExecution = null;
| if (concurrentRoot.getExecutions().size()==0) {
| outgoingExecution = concurrentRoot;
| outgoingExecution.setState(Execution.STATE_ACTIVE_ROOT);
| } else {
| outgoingExecution = concurrentRoot.createExecution();
| outgoingExecution.setState(Execution.STATE_ACTIVE_CONCURRENT);
| }
| execution.setActivity(activity, outgoingExecution);
| Transition transition = activity.getDefaultOutgoingTransition();
| if (transition==null) {
| throw new JbpmException("join must have an outgoing transition");
| }
| outgoingExecution.take(transition);
| }
| } else {
| throw new JbpmException("invalid execution state");
| }
| }
|
| protected boolean isComplete(List<ExecutionImpl> joinedExecutions, Activity activity, ExecutionImpl concurrentRoot) {
| int nbrOfExecutionsToJoin = multiplicity;
| if (multiplicity==-1) {
| nbrOfExecutionsToJoin = getActiveExecutions(concurrentRoot).size();
| }
| return joinedExecutions.size()==nbrOfExecutionsToJoin;
| }
|
| protected List<ExecutionImpl> getJoinedExecutions(ExecutionImpl concurrentRoot, Activity activity) {
| List<ExecutionImpl> joinedExecutions = new ArrayList<ExecutionImpl>();
| List concurrentExecutions = (List)concurrentRoot.getExecutions();
| for (ExecutionImpl concurrentExecution: (List<ExecutionImpl>)concurrentExecutions) {
| if ( (Execution.STATE_INACTIVE_JOIN.equals(concurrentExecution.getState()))
| && (concurrentExecution.getActivity()==activity)
| ) {
| joinedExecutions.add(concurrentExecution);
| }
| }
| return joinedExecutions;
| }
| protected List<ExecutionImpl> getActiveExecutions(ExecutionImpl concurrentRoot) {
| List<ExecutionImpl> activeExecutions = new ArrayList<ExecutionImpl>();
| List concurrentExecutions = (List)concurrentRoot.getExecutions();
| for (ExecutionImpl concurrentExecution: (List<ExecutionImpl>)concurrentExecutions) {
| // if ( !concurrentExecution.isEnded()) {
| activeExecutions.add(concurrentExecution);
| //}
| }
| return activeExecutions;
| }
| protected void endJoinedExecutions(List<ExecutionImpl> joinedExecutions) {
| for (ExecutionImpl joinedExecution: joinedExecutions) {
| joinedExecution.end();
| }
| }
|
| public void setMultiplicity(int multiplicity) {
| this.multiplicity = multiplicity;
| }
| public void setLockMode(LockMode lockMode) {
| this.lockMode = lockMode;
| }
| }
| =================================================
| import java.util.HashMap;
| import java.util.Map;
|
| public class JBPMTransientStorage {
| private static ThreadLocal storage = new ThreadLocal();
| //private static Map executionContextMap = new HashMap();
|
| public static void setTransientVariable(String executionId,String key,Object value){
| Object obj = storage.get();
| System.out.println("The object in thread local == "+obj+" while setting key == "+key);
| Map executionContextMap = (null != obj?(Map)obj:new HashMap());
|
| if(executionContextMap.containsKey(executionId)){
| HashMap contextSpecificMap = (HashMap) executionContextMap.get(executionId);
| contextSpecificMap.put(key, value);
| }else{
| Map contextSpecificMap = new HashMap();
| contextSpecificMap.put(key, value);
| executionContextMap.put(executionId, contextSpecificMap);
| }
| storage.set(null);
| storage.set(executionContextMap);
|
| }
|
| public static Object getTransientVariable(String executionId,String key){
| Map executionContextMap = (Map) storage.get();
| Object value = ((Map)executionContextMap.get(executionId)).get(key);
| return value;
| }
|
| public static void clear(){
| storage.set(null);
| }
| }
| =================================================
View the original post : http://www.jboss.org/index.html?module=bb&op=viewtopic&p=4266212#4266212
Reply to the post : http://www.jboss.org/index.html?module=bb&op=posting&mode=reply&p=4266212
16 years, 4 months