jbpm4.4函数的应用

<pre name="code" class="java">

 /**
     * 获取所有部署的流程列表
     * 
     * @return 部署的流程列表
     * @author zhangming
     */
    @Override
    public List<ProcessInstance> getProcessInstances() {
        return executionService.createProcessInstanceQuery().list();
    }

<pre name="code" class="java">/**
     * 动态创建流转驳回
     * 
     * @param taskId
     *            任务ID
     * @author zhangming
     */
    @Override
    public void rollback(String taskId) {
        /** 开启环境 不影响事务 只会对本次流转有效 */
        // EnvironmentImpl envImpl = ((EnvironmentFactory) processEngine)
        // .openEnvironment();

        /** 任务 */

        Task task = taskService.getTask(taskId);
        /** 要去的节点名 */
        String activityName = "leave";
        /** 获取流转实例对象 */
        ExecutionImpl e = (ExecutionImpl) executionService
                .findExecutionById(task.getExecutionId());
        /** 根据流转对象获取当前流转所在的节点 */
        ActivityImpl activity = e.getActivity();
        /** 通过节点获取该节点所对应的流转实例 */
        ProcessDefinitionImpl processDefinitionImpl = activity
                .getProcessDefinition();
        /** 根据节点名查找出目标的节点 */
        ActivityImpl destActivityImpl = processDefinitionImpl
                .findActivity(activityName);
        /** 根据当前节点创建一个流转 */
        TransitionImpl transactionImpl = activity.createOutgoingTransition();
        /** 设置该流转的当前节点 */
        transactionImpl.setSource(activity);
        /** 设置该流转的目标节点 */
        transactionImpl.setDestination(destActivityImpl);
        /** 为该流转起名 */
        transactionImpl.setName("temp");

        /** 关闭这个环境已保证事务正常 */
        // envImpl.close();

        /** 将该任务提交当这个流转中去 */
        taskService.completeTask(task.getId(), transactionImpl.getName());
    }

<pre name="code" class="java"> /**
     * 删除流程实例 只能删除流程实例和任务表相关数据，历史表中的数据无法删除
     * 
     * @param processId
     *            流程实例ID
     * @author zhangming
     */
    @Override
    public void deleteProcessInstance(String processId) {
        ProcessInstance p = executionService.findProcessInstanceById(processId);
        if (p == null) {
            return;
        }
        executionService.deleteProcessInstance(processId);
    }

<pre name="code" class="java">/**
     * 将任务流转到指定名字的流程outcome中去，并携带参数,携带提交意见
     * 
     * @param taskId
     *            任务ID
     * @param outcome
     *            下个节点的name
     * @param map
     *            map参数
     * @param comment
     *            执行任务的意见
     * @param userId
     *            操作人员
     * @param taskName
     *            任务名称
     * @return ResultData返回结果集合
     * @author zjs
     */
    @Override
    public ResultData complateTask(String taskId, String outcome,
            Map<String, Object> map, String comment, String userId,
            String taskName) {
        if (map != null) {
            taskService.setVariables(taskId, map);
        }
        String stmp = null;
        if (taskName != null) {
            stmp = taskName + "&";
        }
        if (null != comment) {
            stmp = taskName + "&" + comment;
        }
        if (null != stmp) {
            taskService.addTaskComment(taskId, stmp);// 保存意见
        }
        if (userId != null) {
            taskService.assignTask(taskId, userId); // 操作人员
        }
        ResultData rsData = new ResultData();
        try {
            taskService.completeTask(taskId, outcome); // 执行任务并调转到指定的任务
            rsData.setSuccess(true);
        }
        catch (JbpmException e) {
            rsData.setSuccess(false);
            rsData.setResultMessage(MessageUtil.getMessage("ticm.jbpm.003"));
        }
        return rsData;
    }

<pre name="code" class="java"> /**
     * 查看流程图片数据流
     * 
     * @param id
     *            实例ID
     * @return 文件数据流
     * @author zjs
     */
    @Override
    public InputStream findPicInputStream(String id) {
        ProcessInstance processInstance = executionService
                .findProcessInstanceById(id);
        String processDefinitionId = processInstance.getProcessDefinitionId();
        ProcessDefinition processDefinition = repositoryService
                .createProcessDefinitionQuery().processDefinitionId(
                        processDefinitionId).uniqueResult();

        System.out.println("processDefinition:  " + processDefinition);
        System.out.println("DeploymentId:  "
                + processDefinition.getDeploymentId());
        String deployid = processDefinition.getDeploymentId();

        InputStream inputStream = null;

        Set<String> set = repositoryService.getResourceNames(deployid);
        for (String s : set) {
            String type = s.substring(s.length() - 3, s.length());
            if (type.equals(FlowFileType.PNG))// 如果为图片格式
            {
                inputStream = repositoryService
                        .getResourceAsStream(deployid, s);
            }
            else {
                inputStream = repositoryService
                        .getResourceAsStream(deployid, s);
            }
        }

        return inputStream;
    }

<pre name="code" class="java"> /**
     * 根据用户获取历史已经完成的任务
     * 
     * @param username
     *            用户名
     * @return 历史完成的任务list
     * @author zhangming
     */
    @Override
    public List<HistoryTask> getHistoryTaskList(String username) {
        List<HistoryTask> list = new ArrayList<HistoryTask>();
        List<HistoryTask> listTask = historyService.createHistoryTaskQuery()
                .assignee(username).list();
        for (HistoryTask task : listTask) {
            if (task.getState() != null) {
                // 过滤没有完成的任务
                if (task.getState().equals("completed")) {
                    list.add(task);
                }
            }
        }
        return list;
    }

<pre name="code" class="java">/**
     * 根据流程实例ID 获取当前任务节点名称
     * 
     * @param processId
     *            流程实例ID
     * @return 返回当前任务节点名称
     * @author zhangming
     */
    @Override
    public String getCurrectAcvitityName(String processId) {

        Set<String> names = executionService.createProcessInstanceQuery()
                .processInstanceId(processId).uniqueResult()
                .findActiveActivityNames();
        String taskName = null;
        for (String s : names) {
            taskName = s;
        }
        // String taskName = executionService.createProcessInstanceQuery()
        // .processInstanceId(processId).uniqueResult()
        // .findActiveActivityNames().toString();
        return taskName;
    }

<pre name="code" class="java">/**
     * 根据流程实例ID，获取当前任务ID
     * 
     * @param processId
     *            流程实例ID
     * @return 任务ID
     * @author zhangming
     */
    @Override
    public String getCurrectTaskId(String processId) {
        List<Task> list = taskService.createTaskQuery().executionId(processId)
                .list();
        String taskID = "";
        if (list.size() > 0) {
            for (Task task : list) {
                taskID = task.getId();
            }
        }

        return taskID;
    }

 判断当前流程是否结束
     * 
     * @param processId
     *            流程实例ID
     * @return 该流程是否结束
     * @author zhangming
     */
    @Override
    public boolean isProcessEnd(String processId) {
        boolean res = false;
        List<HistoryProcessInstance> list = historyService
                .createHistoryProcessInstanceQuery().list();
        for (HistoryProcessInstance h : list) {
            if (h.getProcessInstanceId().equals(processId)) {
                if (h.getState().equals("ended")) {
                    res = true;
                    break;
                }
                else {
                    res = false;
                }
            }
            else {
                res = false;
            }
        }

        return res;
    }

 /**
     * 根据部署流程ID获取到流程定义中所有的节点信息。该方法只要流程文件已经部署方可查询
     * 注意：此方法是API官方遍历XML文件，所以请注意节点的在XML文件中的位置。
     * 
     * @param processID
     *            流程部署ID
     * @return Activity对象 的子类。 该对象包含所有节点名称，所有节点类型
     * @author zhangming
     */
    @Override
    public List<? extends Activity> getAllNodes(String processID) {
        ProcessDefinition definition = repositoryService
                .createProcessDefinitionQuery().deploymentId(processID)
                .uniqueResult();

        ProcessDefinitionImpl definitionimpl = (ProcessDefinitionImpl) definition;

        List<? extends Activity> list = definitionimpl.getActivities();
        return list;
    }

<pre name="code" class="java"> /**
     * 根据部署流程ID和流程定义中的节点名称，获取到该节点的Transition流转的name
     * 
     * @param processID
     *            流程部署ID
     * @param nodeName
     *            流程部署文件中节点的名称。该节点可以是任意类型的节点
     * @return Transition对象，该对象包含节点的Transition流转的name(使用getName方法获取)。
     *         如果没有找到该节点的Transition返回null
     * @author zhangming
     */
    @Override
    public List<? extends Transition> findTransitionNames(String processID,
            String nodeName) {
        List<? extends Activity> listActivity = getAllNodes(processID);
        for (Activity activity : listActivity) {
            if (activity.getName().equals(nodeName)) {
                return activity.getOutgoingTransitions();
            }
        }
        return null;
    }