activiti 当前任务的下一个节点

/**
     * 
     * @Description (下一个任务节点信息)
     * @author feizhou
     * @Date 2018年4月13日下午5:40:23
     * @version 1.0.0
     * @param activityImpl
     *            流程节点信息
     * @param activityId
     *            当前流程节点Id信息
     * @param variables
     *            流程变量
     * @param processInstanceId
     *            流程实例ID
     * @return
     */
    public TaskDefinition nextTaskDefinition(ActivityImpl activityImpl, String activityId,
            Map<String, Object> variables, String processInstanceId) {

        PvmActivity ac = null;

        // 如果遍历节点为用户任务并且节点不是当前节点信息
        if ("userTask".equals(activityImpl.getProperty("type")) && !activityId.equals(activityImpl.getId())) {
            // 获取该节点下一个节点信息
            TaskDefinition taskDefinition = ((UserTaskActivityBehavior) activityImpl.getActivityBehavior())
                    .getTaskDefinition();
            return taskDefinition;

        } else if (!"endEvent".equals(activityImpl.getProperty("type"))) {
            // 当前节点是不结束节点的情况

            // 获取节点所有流向线路信息
            List<PvmTransition> outTransitions = activityImpl.getOutgoingTransitions();
            List<PvmTransition> outTransitionsTemp = null;
            for (PvmTransition tr : outTransitions) {
                // 这里遍历的当然节点所有流程线的的终点节点
                ac = tr.getDestination(); // 获取线路的终点节点
                // 如果流向线路为排他网关
                if ("exclusiveGateway".equals(ac.getProperty("type"))) {
                    outTransitionsTemp = ac.getOutgoingTransitions();

                    // 如果排他网关只有一条线路信息
                    if (outTransitionsTemp.size() == 1) {
                        return nextTaskDefinition((ActivityImpl) outTransitionsTemp.get(0).getDestination(), activityId,
                                variables, processInstanceId);
                    } else if (outTransitionsTemp.size() > 1) { // 如果排他网关有多条线路信息

                        ActivityImpl nextActivityImpl = getNextActivityImplByLineCondition(outTransitionsTemp,
                                variables);
                        return nextTaskDefinition(nextActivityImpl, activityId, variables, processInstanceId);

                    }
                } else if ("userTask".equals(ac.getProperty("type"))) {// 下一个节点是用户任务
                    Boolean currenLineConditionResule = getCurrenLineConditionResule(tr, variables);
                    if (currenLineConditionResule) {
                        return ((UserTaskActivityBehavior) ((ActivityImpl) ac).getActivityBehavior())
                                .getTaskDefinition();
                    }
                }

            }
        }
        return null;
    }

/**
     * 
     * @Description (判断当前流程线是否满足流程参数条件)
     * @author feizhou
     * @Date 2018年4月13日下午6:32:16
     * @version 1.0.0
     * @param outTransition
     * @param variables
     * @return
     */
    public Boolean getCurrenLineConditionResule(PvmTransition outTransition, Map<String, Object> variables) {

        boolean stringtoBoolean = true;
        Object conStr = outTransition.getProperty("conditionText"); // 获取线路判断条件信息
        // s: ${money>1000 or price >12}
        // variables (money=1100)
        // variables (price=100)
        // 去掉${和}
        String ElStr = "";
        if (conStr != null) {// 有条件
            ElStr = String.valueOf(conStr);
            ElStr = ElStr.substring(2, ElStr.length() - 1);
            try {
                stringtoBoolean = StringUtil.StringtoBoolean(ElStr, variables);
            } catch (ScriptException e) {
                e.printStackTrace();
            }
            return stringtoBoolean;
        } else {// 没有条件
            return stringtoBoolean;
        }
    }

/**
     * 
     * @Description (如果是排他网关判断,获取排他网关对应的用户任务节点)
     * @author feizhou
     * @Date 2018年4月13日下午4:41:55
     * @version 1.0.0
     * @param outTransitionsTemp
     * @param variables
     * @return
     */
    public ActivityImpl getNextActivityImplByLineCondition(List<PvmTransition> outTransitionsTemp,
            Map<String, Object> variables) {

        for (PvmTransition tr1 : outTransitionsTemp) {
            Object conStr = tr1.getProperty("conditionText"); // 获取线路判断条件信息
            // s: ${money>1000 or price >12}
            // variables (money=1100)
            // variables (price=100)
            // 去掉${和}
            String ElStr = "";
            if (conStr != null) {// 有条件
                ElStr = String.valueOf(conStr);
                ElStr = ElStr.substring(2, ElStr.length() - 1);
                try {
                    boolean stringtoBoolean = StringUtil.StringtoBoolean(ElStr, variables);
                    if (stringtoBoolean) {
                        return (ActivityImpl) tr1.getDestination();
                    }
                } catch (ScriptException e) {
                    continue;
                }
            } else {// 没有条件
                return (ActivityImpl) tr1.getDestination();
            }
        }
        return null;
    }

/**
 * 
 * @Description (字符串表达式计算逻辑值)
 * @author feizhou
 * @Date 2018年4月13日下午2:30:28  
 * @version 1.0.0
 * @param str
 * @param var
 * @return
 * @throws ScriptException
 */
public static boolean StringtoBoolean(String str, Map<String,Object> var) throws ScriptException {
     ScriptEngineManager manager = new ScriptEngineManager();
     ScriptEngine engine = manager.getEngineByName("js");
     Set<String> keys = var.keySet();
     for (String key : keys) {
         engine.put(key,var.get(key));
    }
     str= str.replaceAll(" or ", " || ").replaceAll(" and ", " && ");
     Object result = engine.eval(str);
    return Boolean.parseBoolean(String.valueOf(result));

}