Java --- 云尚办公之员工端审批

目录

一、员工端审批

---

一、员工端审批

 查询审批分类和对应的审批模板：

后端接口：

service实现类

 @Override
    public List<ProcessType> findProcessType() {
        //查询所有审批分类
        List<ProcessType> list = baseMapper.selectList(null);
        //遍历审批分类集合
        for (ProcessType processType:list){
            //根据审批分类id查询对应审批模板
            LambdaQueryWrapper<ProcessTemplate> wrapper = new LambdaQueryWrapper<>();
            wrapper.eq(ProcessTemplate::getProcessTypeId,processType.getId());
            List<ProcessTemplate> processTemplateList = processTemplateService.list(wrapper);
            processType.setProcessTemplateList(processTemplateList);
        }
        return list;
    }

controller层

@ApiOperation("查询审批分类与所属审批模板")
    @GetMapping("/findProcessType")
    public Result findProcessType(){
        List<ProcessType> list = processTypeService.findProcessType();
        return Result.ok(list);
    }

前端项目整合：

报错信息：

解决办法：

 使用 npm run serve 命令启动

 更改配置：

访问测试：

审批申请：

后端接口：

@ApiOperation("获取审批模板数据")
    @GetMapping("/getProcessTemplate/{processTemplateId}")
    public Result getProcessTemplate(@PathVariable Long processTemplateId) {
        return Result.ok(processTemplateService.getById(processTemplateId));
    }

前端：

启动流程实例：

后端：

public class LoginUserInfoHelper {
    private static ThreadLocal<Long> userId = new ThreadLocal<Long>();
    private static ThreadLocal<String> username = new ThreadLocal<String>();

    public static void setUserId(Long _userId) {
        userId.set(_userId);
    }
    public static Long getUserId() {
        return userId.get();
    }
    public static void removeUserId() {
        userId.remove();
    }
    public static void setUsername(String _username) {
        username.set(_username);
    }
    public static String getUsername() {
        return username.get();
    }
    public static void removeUsername() {
        username.remove();
    }
}

 service层

    //启动流程
    @Override
    public void startUp(ProcessFormVo processFormVo) {
        //根据当前用户id获取用户信息
        SysUser sysUser = sysUserService.getById(LoginUserInfoHelper.getUserId());
        //根据审批模板id把模板信息查询
        ProcessTemplate processTemplate = processTemplateService.getById(processFormVo.getProcessTemplateId());
        //将提交信息保存
        Process process = new Process();
        BeanUtils.copyProperties(processFormVo,process);
        String workNo = System.currentTimeMillis() + "";
        process.setProcessCode(workNo);
        process.setUserId(LoginUserInfoHelper.getUserId());
        process.setFormValues(processFormVo.getFormValues());
        process.setTitle(sysUser.getName() + "发起" + processTemplate.getName() + "申请");
        process.setStatus(1);
        baseMapper.insert(process);
        //启动流程实例
        //流程定义key
        String processDefinitionKey = processTemplate.getProcessDefinitionKey();
        //业务key
        Long id = process.getId();
        //流程参数
        String formValues = processFormVo.getFormValues();
        JSONObject jsonObject = JSON.parseObject(formValues);
        JSONObject formData = jsonObject.getJSONObject("formData");
        //遍历formData，封装到map集合
        HashMap<String , Object> map = new HashMap<>();
        for (Map.Entry<String ,Object> entry : formData.entrySet()){
            map.put(entry.getKey(),entry.getValue());
        }
        HashMap<String , Object> varMap = new HashMap<>();
        varMap.put("data",map);
        ProcessInstance processInstance = runtimeService.startProcessInstanceByKey(processDefinitionKey, String.valueOf(id), varMap);
        //查询下一个审批人
        List<Task> tasks = this.getCurrentTaskList(processInstance.getId());
        ArrayList<String> list = new ArrayList<>();
        for (Task task:tasks){
            String assigneeName = task.getAssignee();
            SysUser user = sysUserService.findUserByUserName(assigneeName);
            String name = user.getName();
            list.add(name);
            //TODO 推送消息，后续使用微信推送
        }
        process.setProcessInstanceId(processInstance.getId());
        process.setDescription("等待" + StringUtils.join(list.toArray(),",")  + "审批");
        //业务和流程关联
       baseMapper.updateById(process);
    }
   //当前任务列表
    private List<Task> getCurrentTaskList(String  id) {
        List<Task> list = taskService.createTaskQuery().processInstanceId(id).list();
        return list;
    }

controller层

  @ApiOperation("启动流程实例")
    @PostMapping("/startUp")
    public Result startUp(@RequestBody ProcessFormVo processFormVo){
         processService.startUp(processFormVo);
         return Result.ok();
    }

提交记录：

service层：

public interface OaProcessRecordService extends IService<ProcessRecord> {
       void record(Long processId,Integer status,String description);
}

service实现类：

@Service
public class OaProcessRecordServiceImpl extends ServiceImpl<OaProcessRecordMapper, ProcessRecord> implements OaProcessRecordService {
    @Autowired
    private SysUserService sysUserService;
    @Override
    public void record(Long processId, Integer status, String description) {
        SysUser sysUser = sysUserService.findUserByUserName(LoginUserInfoHelper.getUsername());
        ProcessRecord processRecord = new ProcessRecord();
        processRecord.setProcessId(processId);
        processRecord.setStatus(status);
        processRecord.setDescription(description);
        processRecord.setOperateUser(sysUser.getName());
        processRecord.setOperateUserId(sysUser.getId());
        baseMapper.insert(processRecord);
    }
}

待处理列表：

//待处理
    @Override
    public IPage<ProcessVo> findPending(Page<Process> processPage) {
        //封装查询条件
        TaskQuery desc = taskService.createTaskQuery()
                .taskAssignee(LoginUserInfoHelper.getUsername())
                .orderByTaskCreateTime()
                .desc();
        int start = (int) ((processPage.getCurrent() -1)*processPage.getSize());
        int size = (int) processPage.getSize();
        List<Task> tasks = desc.listPage(start, size);
        ArrayList<ProcessVo> arrayList = new ArrayList<>();
        for (Task task:tasks){
            //从task获取流程实例id
            String processInstanceId = task.getProcessInstanceId();
            //根据流程实例id获取实例对象
            ProcessInstance processInstance = runtimeService.createProcessInstanceQuery().processInstanceId(processInstanceId).singleResult();
            //从流程实例里获取业务key
            String businessKey = processInstance.getBusinessKey();
            if (businessKey == null){
                continue;
            }
            //根据业务key获取process对象
            Process process = baseMapper.selectById(businessKey);
            ProcessVo processVo = new ProcessVo();
            //拷贝复制
            BeanUtils.copyProperties(process,processVo);
            processVo.setTaskId(task.getId());
            arrayList.add(processVo);
        }
        //封装返回IPage对象
        IPage<ProcessVo> processVoPage = new Page<>(processPage.getCurrent(),processPage.getSize(),desc.count());
        processVoPage.setRecords(arrayList);
        return processVoPage;
    }

controller：

 @ApiOperation("待处理列表")
    @GetMapping("/findPending/{page}/{limit}")
    public Result findPending(@PathVariable("page") Long page,
                              @PathVariable("limit") Long limit){
        Page<Process> processPage = new Page<>(page,limit);
        return Result.ok(processService.findPending(processPage));
    }

审批详情：

service层：

    @Override
    public Map<String, Object> show(Long id) {
        //根据流程id获取流程信息
        Process process = baseMapper.selectById(id);
        //根据流程id获取流程记录信息
        LambdaQueryWrapper<ProcessRecord> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(ProcessRecord::getProcessId,process.getId());
        List<ProcessRecord> recordList = processRecordService.list(wrapper);
        //根据模板id查询模板信息
        ProcessTemplate processTemplate = processTemplateService.getById(process.getProcessTemplateId());
        //判断当前用户是否能审批,不能重复审批
        boolean isApprove = false;
        //根据流程实例id查询
        List<Task> taskList = this.getCurrentTaskList(process.getProcessInstanceId());
        for (Task task:taskList){
            //判断当前任务审批人是否是当前用户
            if (task.getAssignee().equals(LoginUserInfoHelper.getUsername())){
                isApprove = true;
            }
        }
        //查询的数据都封装到map集合内
        HashMap<String , Object> map = new HashMap<>();
        map.put("process",process);
        map.put("processRecordList",recordList);
        map.put("processTemplate",processTemplate);
        map.put("isApprove",isApprove);
        return map;
    }

controller层

   @ApiOperation("查看审批详情")
    @GetMapping("show/{id}")
    public Result show(@PathVariable("id") Long id){
        Map<String,Object> map =  processService.show(id);
        return Result.ok(map);
    }

审批是否通过：

 //审批是否通过
    @Override
    public void approve(ApprovalVo approvalVo) {
        //根据任务id获取流程变量
        String taskId = approvalVo.getTaskId();
        Map<String, Object> map = taskService.getVariables(taskId);
        //遍历map集合
        for (Map.Entry<String, Object> entry : map.entrySet()){
            System.out.println(entry.getKey());
            System.out.println(entry.getValue());
        }
        //判断审批状态值
        //状态为1就审批通过
        if (approvalVo.getStatus() == 1){
            //审批通过
            HashMap<String , Object> variable = new HashMap<>();
            taskService.complete(taskId,variable);
        }else {
           //状态为-1审批不通过
            this.endTask(taskId);
        }
        //记录审批相关过程信息更新
        String description = approvalVo.getStatus().intValue() == 1 ? "审批通过" : "审批未通过";
        processRecordService.record(approvalVo.getProcessId(),approvalVo.getStatus(),description);
        //查询下一个审批人，更新流程表 oa_process记录
        Process process = baseMapper.selectById(approvalVo.getProcessId());
        //查询任务
        List<Task> tasks = this.getCurrentTaskList(process.getProcessInstanceId());
        if (!CollectionUtils.isEmpty(tasks)){
            ArrayList<String> arrayList = new ArrayList<>();
            for(Task task:tasks){
                String assignee = task.getAssignee();
                SysUser sysUser = sysUserService.findUserByUserName(assignee);
                arrayList.add(sysUser.getName());
                // TODO 使用微信公众号推送
            }
            process.setDescription("等待" + StringUtils.join(arrayList.toArray(),",") + "审批");
            process.setStatus(1);
        }else {
            if (approvalVo.getStatus() == 1){
                process.setDescription("审批已通过");
                process.setStatus(2);
            }else {
                process.setDescription("审批未通过");
                process.setStatus(-1);
            }
        }
        baseMapper.updateById(process);
    }
    //结束流程
    private void endTask(String taskId) {
        //根据任务id获取任务对象task
        Task task = taskService.createTaskQuery().taskId(taskId).singleResult();
        //获取流程定义模型
        BpmnModel bpmnModel = repositoryService.getBpmnModel(task.getProcessDefinitionId());
        //获取结束流向节点
        List<EndEvent> endEventList = bpmnModel.getMainProcess().findFlowElementsOfType(EndEvent.class);
        if (CollectionUtils.isEmpty(endEventList)){
            return;
        }
        FlowNode endFlowNode = endEventList.get(0);
        //当前流行节点
        FlowNode currentFlowNode = (FlowNode) bpmnModel.getMainProcess().getFlowElement(task.getTaskDefinitionKey());
        //临时保存当前活动的原始方向
        ArrayList originalSequenceFlowList= new ArrayList<>();
        originalSequenceFlowList.addAll(currentFlowNode.getOutgoingFlows());
        //清理当前流动方向
        currentFlowNode.getOutgoingFlows().clear();
        //创建新流向
        SequenceFlow sequenceFlow = new SequenceFlow();
        sequenceFlow.setId("newSequenceFlow");
        sequenceFlow.setSourceFlowElement(currentFlowNode);
        sequenceFlow.setTargetFlowElement(endFlowNode);
        //当前节点指向新节点
        ArrayList newSequenceFlowList = new ArrayList<>();
        newSequenceFlowList.add(sequenceFlow);
        currentFlowNode.setOutgoingFlows(newSequenceFlowList);
        //完成当前任务
        taskService.complete(taskId);
    }

查询已处理任务：

service层：

    //已处理的审批
    @Override
    public IPage<ProcessVo> findProcessed(Page<Process> processPage) {
        //封装查询条件,根据用户名查询完成的任务
        HistoricTaskInstanceQuery query = historyService.createHistoricTaskInstanceQuery()
                .taskAssignee(LoginUserInfoHelper.getUsername()).finished().orderByTaskCreateTime().desc();

        //调用方法条件分页查询，返回list集合
        int start = (int) ((processPage.getCurrent() - 1) * processPage.getSize());
        int end = (int) processPage.getSize();
        List<HistoricTaskInstance> list = query.listPage(start, end);
        long count = query.count();
        //封装list<ProcessVo>
        ArrayList<ProcessVo> arrayList = new ArrayList<>();
        for (HistoricTaskInstance item:list){
            //流程实例id
            String processInstanceId = item.getProcessInstanceId();
            //根据流程id查询process
            LambdaQueryWrapper<Process> wrapper = new LambdaQueryWrapper<>();
            wrapper.eq(Process::getProcessInstanceId,processInstanceId);
            Process processes = baseMapper.selectOne(wrapper);
            if (processes != null){
                ProcessVo processVo = new ProcessVo();
                BeanUtils.copyProperties(processes,processVo);
                //processVo存入list集合
                arrayList.add(processVo);
            }
        }
        IPage<ProcessVo> processVoIPage = new Page<>(processPage.getCurrent(),processPage.getSize(),count);
        processVoIPage.setRecords(arrayList);
        return processVoIPage;
    }

controller层：

 @ApiOperation("已处理")
    @GetMapping("/findProcessed/{page}/{limit}")
    public Result findProcessed(@PathVariable("page") Long page,
                                @PathVariable("limit") Long limit){
        Page<Process> processPage = new Page<>(page,limit);
        return Result.ok(processService.findProcessed(processPage));
    }

查询已发起审批：

service层：

//已发起审批
    @Override
    public IPage<ProcessVo> findStarted(Page<ProcessVo> processVoPage) {
        ProcessQueryVo processQueryVo = new ProcessQueryVo();
        processQueryVo.setUserId(LoginUserInfoHelper.getUserId());
        IPage<ProcessVo> processVoIPage = baseMapper.selectPage(processVoPage, processQueryVo);
        return processVoIPage;
    }

controller层：

   @ApiOperation("已发起审批任务")
    @GetMapping("/findStarted/{page}/{limit}")
    public Result findStarted(@PathVariable("page") Long page,
                              @PathVariable("limit") Long limit){
        Page<ProcessVo> processVoPage = new Page<>(page, limit);
        return Result.ok(processService.findStarted(processVoPage));
    }

发起人查询：

审批人查询：

 查询自己信息：

service层：

@Override
    public Map<String, Object> getCurrentUser() {
        HashMap<String , Object> map = new HashMap<>();
        SysUser sysUser = baseMapper.selectById(LoginUserInfoHelper.getUserId());
        map.put("name",sysUser.getName());
        map.put("phone",sysUser.getPhone());
        return map;
    }

controller层：

 @ApiOperation("我的信息查询")
    @GetMapping("/getCurrentUser")
    public Result getCurrentUser(){
       Map<String ,Object> map = sysUserService.getCurrentUser();
       return Result.ok(map);
    }