公司采购 流程flowable例子

• Name: Flowable BPMN 2.0 designer
• Location: http://flowable.org/designer/update/
• 

业务描述：
1. 公司采购，因为办公用品价格高低的问题，需要分级审批，各级的审批资金的高低不一样，高于 500 块钱需要总经理审批！
1. 申请流程：
1. 申请人起草填写申请单（申请办公用品【数据库自带价格】、申请理由、使用人），保存后可立即提交申请；
1. 申请人提交审批，发起流程；
1. 部门经理审批；
1. 流程自动处理，采购金额buyCost大于 500的，自动转到总经理审批，否则直接转到人事部审批；
1. 如果总经理审批或者人事部审批通过，则自动转到财务部归档，否则被打回到申请人处理；
1. 财务归档处理后，流程转到采购部处理，采购部可以根据办公用品是否需要采购进行控制，选择采购办公用品或者人事部发放办公用品，流程转到此两者之一。
1. 如果申请单被打回到申请人，申请人可以再次修改后重新提交审批，也可以选择放弃、到此流程结束。
1. 如果流程走到采购办公用品，那么，采购部人员可以控制此流程，如果办公用品采购回来了，那么流程转到人事部发放办公用品。
1. 当人事部发放办公用品 人事部处理完过后，流程转到领取办公用品，申请人到人事部去领取办公用品，流程到此结束。

    // 使用代码创建工作流需要的23张表
    @Before
    public void createTable() {
        // 工作流引擎的全部配置
        ProcessEngineConfiguration processEngineConfiguration = ProcessEngineConfiguration
                .createStandaloneProcessEngineConfiguration()
                .setJdbcUrl("jdbc:jtds:sqlserver://localhost:1433/msgBoard2")
                .setJdbcUsername("sa")
                .setJdbcPassword("1234")
                .setJdbcDriver("net.sourceforge.jtds.jdbc.Driver")
                .setDatabaseSchemaUpdate(ProcessEngineConfiguration.DB_SCHEMA_UPDATE_TRUE);

        // 工作流的核心对象，ProcessEnginee对象
        processEngine = processEngineConfiguration.buildProcessEngine();
        System.out.println("-----------工作流引擎开启----------");
    }

    /**
     * 部署流程定义
     */
    @Test
    public void deploymentProcessDefinition() {
        //创建核心引擎对象
        Deployment deployment = processEngine.getRepositoryService()
                .createDeployment()
                .name("flowable入门程序2")
                .addClasspathResource("myProcess-test.bpmn20.xml")
                .deploy();
        System.out.println("##########添加部署##########");
        System.out.println("部署ID:" + deployment.getId());
        System.out.println("部署名称：" + deployment.getName());
        findProcessDefinition();
    }

    /**
     * 启动流程实例
     * 使用key值启动
     */
    @Test
    public void startProcessInstance2() {
        // 流程定义的key
        String processDefinitionKey = "myProcess-test";
        ProcessInstance pi = processEngine.getRuntimeService()// 于正在执行的流程实例和执行对象相关的Service
                .startProcessInstanceByKey(processDefinitionKey);// 使用流程定义的key启动流程实例，key对应hellworld.bpmn文件中id的属性值，使用key值启动，默认是按照最新版本的流程定义启动
        System.out.println("流程实例ID:" + pi.getId());// 流程实例ID 101
        System.out.println("流程定义ID:" + pi.getProcessDefinitionId()); // 流程定义ID HelloWorld:1:4
    }

    /**
     * 启动流程实例
     * 使用id值启动
     */
    @Test
    public void startProcessInstance() {
        RuntimeService runtimeService = processEngine.getRuntimeService();//表示正在执行的流程实例和执行对象

        ProcurementVO procurementVO = new ProcurementVO();
        procurementVO.setEmployee("sky");
        procurementVO.setReason("测试用例。。。。。。。。");
        List<Articles> articlesList = new ArrayList<Articles>();
        Articles articles1 = new Articles("文具", 80, 1);
        Articles articles2 = new Articles("电脑", 500, 1);
        articlesList.add(articles1);
        articlesList.add(articles2);
        procurementVO.setArticlesList(articlesList);
        double buyCost = 0;
        for (Articles articles : articlesList) {
            buyCost += (articles.getAmount() * articles.getPrice());
        }
        Map<String, Object> variables = new HashMap<String, Object>();
        variables.put("procurement", procurementVO);
        variables.put("buyCost", buyCost);

        String processDefinitionId = "myProcess-test:1:105003";
        ProcessInstance processInstance =
                runtimeService.startProcessInstanceById(processDefinitionId, variables);
        System.out.println("##########流程开启##########");
        System.out.println("流程实例ID:" + processInstance.getId());
        System.out.println("流程定义ID:" + processInstance.getProcessDefinitionId());
        findTask();
    }

    /**
     * 查询所有的流程定义
     */
    @Test
    public void findProcessDefinition() {
        List<ProcessDefinition> list = processEngine.getRepositoryService()// 与流程定义和部署对象先相关的service
                .createProcessDefinitionQuery()// 创建一个流程定义的查询
                /** 指定查询条件，where条件 */
                // .deploymentId(deploymentId) //使用部署对象ID查询
                // .processDefinitionId(processDefinitionId)//使用流程定义ID查询
                // .processDefinitionNameLike(processDefinitionNameLike)//使用流程定义的名称模糊查询

            /* 排序 */
                .orderByProcessDefinitionVersion().asc()
                // .orderByProcessDefinitionVersion().desc()

            /* 返回的结果集 */
                .list();// 返回一个集合列表，封装流程定义
        // .singleResult();//返回惟一结果集
        // .count();//返回结果集数量
        // .listPage(firstResult, maxResults);//分页查询

        if (list != null && list.size() > 0) {
            for (ProcessDefinition pd : list) {
                System.out.println("流程定义ID:" + pd.getId());// 流程定义的key+版本+随机生成数
                System.out.println("流程定义的名称:" + pd.getName());// 对应helloworld.bpmn文件中的name属性值
                System.out.println("流程定义的key:" + pd.getKey());// 对应helloworld.bpmn文件中的id属性值
                System.out.println("流程定义的版本:" + pd.getVersion());// 当流程定义的key值相同的相同下，版本升级，默认1
                System.out.println("资源名称bpmn文件:" + pd.getResourceName());
                System.out.println("资源名称png文件:" + pd.getDiagramResourceName());
                System.out.println("部署对象ID：" + pd.getDeploymentId());
                System.out.println("是否暂停：" + pd.isSuspended());
                System.out.println("#########################################################");
            }
        } else {
            System.out.println("没有流程正在运行。");
        }
    }

    /**
     * 获取任务
     */
    @Test
    public void getTask() {
        // 与任务相关的service,正在执行的service
        TaskService taskService = processEngine.getTaskService();
        // 任务ID
        String taskId = "85005";

        Task task = taskService.newTask(taskId);
        System.out.println(task.getId() + "    " +
                task.getAssignee() + "    " +
                task.getName() + "    " +
                task.getProcessInstanceId());
        System.out.println("################################");
    }

    /**
     * 设置流程变量
     */
    @Test
    public void setVariables() {
        // 与任务相关的service,正在执行的service
        TaskService taskService = processEngine.getTaskService();

        // 任务ID
        String taskId = "107508";

        Map<String, Object> variables = new HashMap<String, Object>();
//        variables.put("approve", false);
        variables.put("endOut", true);
//        taskService.removeVariable(taskId, "buyCost");
        taskService.complete(taskId, variables);

        System.out.println("设置流程变量成功！");
        findTask();
    }

    /**
     * 删除流程定义(删除key相同的所有不同版本的流程定义)
     */
    @Test
    public void delteProcessDefinitionByKey() {
        // 流程定义的Key
        String processDefinitionKey = "myProcess-test";
        // 先使用流程定义的key查询流程定义，查询出所有的版本
        List<ProcessDefinition> list = processEngine.getRepositoryService()
                .createProcessDefinitionQuery()
                .processDefinitionKey(processDefinitionKey)// 使用流程定义的key查询
                .list();
        // 遍历，获取每个流程定义的部署ID
        if (list != null && list.size() > 0) {
            for (ProcessDefinition pd : list) {
                // 获取部署ID
                String deploymentId = pd.getDeploymentId();
                //      /*
                //       * 不带级联的删除， 只能删除没有启动的流程，如果流程启动，就会抛出异常
                //       */
                //       processEngine.getRepositoryService().deleteDeployment(deploymentId);

                /**
                 * 级联删除 不管流程是否启动，都可以删除
                 */
            System.out.println("删除部署：" + deploymentId);
                processEngine.getRepositoryService().deleteDeployment(
                        deploymentId, true);

            }

        }
    }

    /**
     * 查询流程状态（判断流程正在执行，还是结束）
     */
    @Test
    public void isProcessEnd() {
        String processInstanceId = "25001";
        ProcessInstance pi = processEngine.getRuntimeService()//表示正在执行的流程实例和执行对象
                .createProcessInstanceQuery()//创建流程实例查询
                .processInstanceId(processInstanceId)//使用流程实例ID查询
                .singleResult();

        if (pi == null) {
            System.out.println("流程已经结束");
        } else {
            System.out.println("流程没有结束");
        }
    }

    /**
     * 查询任务
     * --通过流程实例id
     */
    @Test
    public void findTask() {
//        String processInstanceId = "42501";
        List<HistoricTaskInstance> list = processEngine.getHistoryService()//与历史数据（历史表）相关的service
                .createHistoricTaskInstanceQuery()//创建历史任务实例查询
//                .processInstanceId(processInstanceId)
                .orderByHistoricActivityInstanceId().asc()
                .list();

        if (list != null && list.size() > 0) {
            for (HistoricTaskInstance hti : list) {
                System.out.println(hti.getId() + "    " +
                        hti.getAssignee() + "    " +
                        hti.getName() + "    " +
                        hti.getProcessInstanceId() + "   " +
                        hti.getStartTime() + "   " +
                        hti.getEndTime() + "   " +
                        hti.getDurationInMillis());
                System.out.println("################################");
            }
        }
    }

    /**
     * 查询当前人的个人任务
     */
    @Test
    public void findMyPersonTask() {
        String assignee = "sky";
        List<Task> list = processEngine.getTaskService()// 与正在执行的认为管理相关的Service
                .createTaskQuery()// 创建任务查询对象
                .taskAssignee(assignee)// 指定个人认为查询，指定办理人
                .list();

        if (list != null && list.size() > 0) {
            for (Task task : list) {
                System.out.println("任务ID:" + task.getId());
                System.out.println("任务名称:" + task.getName());
                System.out.println("任务的创建时间" + task);
                System.out.println("任务的办理人:" + task.getAssignee());
                System.out.println("流程实例ID:" + task.getProcessInstanceId());
                System.out.println("执行对象ID:" + task.getExecutionId());
                System.out.println("流程定义ID:" + task.getProcessDefinitionId());
                System.out.println("#################################");
            }
        }
    }

    /**
     * 得到实际的 组任务列表
     */
    @Test
    public void findGroupTaskList() {
        String groupName1 = "procurementOfManager";
        String groupName2 = "procurementOfPersonnel";

        TaskService taskService = processEngine.getTaskService();
        List<Task> tasks = taskService.createTaskQuery().taskCandidateGroup(groupName1).list();
        System.out.println(groupName1 + " have " + tasks.size() + " tasks:");
        for (int i = 0; i < tasks.size(); i++) {
            System.out.println((i + 1) + ") " + tasks.get(i).getName());
        }
        System.out.println("#################################################");
        TaskService taskService2 = processEngine.getTaskService();
        List<Task> tasks2 = taskService.createTaskQuery().taskCandidateGroup(groupName2).list();
        System.out.println(groupName2 + " have " + tasks2.size() + " tasks:");
        for (int i = 0; i < tasks2.size(); i++) {
            System.out.println((i + 1) + ") " + tasks2.get(i).getName());
        }
    }