甬台温手机端可审批查看

blade-service/blade-meter/src/main/java/org/springblade/meter/controller/APIController.java

@@ -7,6 +7,7 @@ import io.swagger.annotations.Api;
 import io.swagger.annotations.ApiOperation;
 import lombok.AllArgsConstructor;
 import org.apache.commons.lang.StringUtils;
+import org.springblade.business.entity.FixedFlow;
 import org.springblade.business.entity.FixedFlowLink;
 import org.springblade.business.entity.Task;
 import org.springblade.business.entity.TaskParallel;
@@ -18,6 +19,7 @@ import org.springblade.core.tool.api.R;
 import org.springblade.core.tool.utils.ObjectUtil;
 import org.springblade.manager.entity.ContractInfo;
 import org.springblade.manager.entity.ContractRelationJlyz;
+import org.springblade.manager.entity.ProjectInfo;
 import org.springblade.manager.feign.ProjectClient;
 import org.springblade.meter.dto.ApiTaskPageDto;
 import org.springblade.meter.entity.MeterApproveOpinion;
@@ -93,23 +95,48 @@ public class APIController {
                 sqlString.append(" AND contract_id in(").append(StringUtils.join(ids, ",")).append(")");
             }
         }
+        if (ObjectUtil.isNotEmpty(dto.getStatusValue())) {
+            if(dto.getStatusValue() .equals(4) ){//----先查询出所有待审批的 然后根据条件进行过滤出任务已经到当前登陆人的任务为可审批
+                sqlString.append(" AND status = 1");
+            }else {
+                sqlString.append(" AND status = ?");
+                params.add(dto.getStatusValue());
+            }
+        }
         if (ObjectUtil.isNotEmpty(dto.getSelectedType())) {
             sqlString.append(" AND (");
-            if (dto.getSelectedType().equals(1)) {
-                sqlString.append("EXISTS (SELECT 1 FROM u_task_parallel WHERE u_task.process_instance_id = u_task_parallel.process_instance_id AND u_task_parallel.status = ? AND u_task_parallel.task_user = ?)");
-                params.add(1);
-                params.add(SecureUtil.getUserId());//待办页面
-                sqlString.append("AND status = 1");
+            if (dto.getSelectedType().equals(1)) { //待办页面
+
+                /*如果是待办页面，且 任务状态下拉框 选择的是 待审批或可审批状态 的任务，那么才查询数据*/
+                if (ObjectUtil.isNotEmpty(dto.getStatusValue()) && (dto.getStatusValue().equals(1) || dto.getStatusValue().equals(4))) {
+                    sqlString.append("EXISTS (SELECT 1 FROM u_task_parallel WHERE u_task.process_instance_id = u_task_parallel.process_instance_id AND u_task_parallel.status = ? AND u_task_parallel.task_user = ?)");
+                    params.add(1);
+                    params.add(SecureUtil.getUserId());
+
+                    /*如果是待办页面，且 任务状态下拉框 选择的不是 待审批状态 的任务，那么直接返回null*/
+                } else if (ObjectUtil.isNotEmpty(dto.getStatusValue()) && !dto.getStatusValue().equals(1)) {
+                    return null;
+
+                    /*如果是待办页面，没选择 任务状态下拉框，那么就默认查询 待审批状态 任务*/
+                } else if (ObjectUtil.isEmpty(dto.getStatusValue())) {
+                    sqlString.append("EXISTS (SELECT 1 FROM u_task_parallel WHERE u_task.process_instance_id = u_task_parallel.process_instance_id AND u_task_parallel.status = ? AND u_task_parallel.task_user = ?)");
+                    params.add(1);
+                    params.add(SecureUtil.getUserId());
+                    sqlString.append(" AND status = 1");
+                }
+
             } else if (dto.getSelectedType().equals(2)) { //已办页面
                 sqlString.append("EXISTS (SELECT 1 FROM u_task_parallel WHERE u_task.process_instance_id = u_task_parallel.process_instance_id AND u_task_parallel.status in(2,3) AND u_task_parallel.task_user = ?)");
                 /*当前自己的任务必须是已审批、已废除 status = 2,3 ，才视为已办*/
                 params.add(SecureUtil.getUserId());
+
             } else if (dto.getSelectedType().equals(3)) { //我发起页面
                 sqlString.append("report_user = ?");
                 params.add(SecureUtil.getUserId());
             }
             sqlString.append(")");
         }
+
         /*总数量*/
         String sqlCount = sqlString.toString().replace("*", "count(1)");
         Optional<Integer> totalCountOptional = Optional.ofNullable(jdbcTemplate.queryForObject(sqlCount, Integer.class, params.toArray()));
@@ -127,6 +154,50 @@ public class APIController {
 
         /*获取用户信息Map*/
         Map<Long, String> nameMap = jdbcTemplate.query("select id,name from blade_user where is_deleted = 0", new BeanPropertyRowMapper<>(User.class)).stream().collect(Collectors.toMap(User::getId, User::getName, (key1, key2) -> key1));
+        /*获取预设流程Map*/
+        //Map<Long, String> flowMap = jdbcTemplate.query("select id,fixed_flow_name from u_fixed_flow where is_deleted = 0 and contract_id = "+dto.getContractId(), new BeanPropertyRowMapper<>(FixedFlow.class)).stream().collect(Collectors.toMap(FixedFlow::getId, FixedFlow::getFixedFlowName, (key1, key2) -> key1));
+        //筛选出可审批的数据
+        if(ObjectUtil.isNotEmpty(dto.getStatusValue()) && dto.getStatusValue() .equals(4) && ObjectUtil.isNotEmpty(resultList)){
+            //获取当前用户id
+            Long userId = AuthUtil.getUserId();
+
+            String processIdsStr = resultList.stream().map(task -> task.getProcessInstanceId()).collect(Collectors.joining(","));
+            //查询出所有proccesId的数据转换成map  map为processId键为u_task_papallel对象
+            Map<String, List<TaskParallel>> taskParallelMap = jdbcTemplate.query("select * from u_task_parallel where process_instance_id in (" + processIdsStr + ")", new BeanPropertyRowMapper<>(TaskParallel.class)).stream().collect(Collectors.groupingBy(TaskParallel::getProcessInstanceId));
+
+            //根据条件过滤出可审批的数据(流程审批-非自定义流程)   flowid为0的是自定义审批的流程
+            Map<Long, List<Task>> flowIdMaps = resultList.stream().filter(task->!"0".equals(task.getFixedFlowId().toString())).collect(Collectors.groupingBy(Task::getFixedFlowId));
+            if(ObjectUtil.isNotEmpty(flowIdMaps)){
+                String join = StringUtils.join(flowIdMaps.keySet(), ",");
+                //结果集所有数据
+                String sql = "select fixed_flow_id ,fixed_flow_branch_sort,fixed_flow_link_type,fixed_flow_link_sort from u_fixed_flow_link where  is_deleted = 0  and  fixed_flow_id in ( "+join+")";
+                List<FixedFlowLink> fixedFlowLinks = jdbcTemplate.query(sql, new BeanPropertyRowMapper<>(FixedFlowLink.class));
+                Map<Long, List<FixedFlowLink>> fixedsMap = fixedFlowLinks.stream().collect(Collectors.groupingBy(FixedFlowLink::getFixedFlowId));
+                for (Long l : flowIdMaps.keySet()) {
+                    List<Task> tasks = flowIdMaps.get(l);
+                    for (Task task : tasks) {
+                        handleTaskParallel1(task,fixedsMap, taskParallelMap,userId, resultList);
+                    }
+                }
+            }
+            //自定义流程判断 查询出所有垂直审批的项目
+            //String sqlForchuizhi = "select id from m_project_info where approval_type = 1 and is_deleted = 0";
+            //目前默认所有项目都是垂直审批  上面的注释掉的是以后要用的内容 1为垂直审批2为流程审批
+            String sqlForchuizhi = "select id from m_project_info where  is_deleted = 0";
+            List<Long> projectIds = jdbcTemplate.query(sqlForchuizhi, new BeanPropertyRowMapper<>(ProjectInfo.class)).stream().map(ProjectInfo::getId).collect(Collectors.toList());
+            if(ObjectUtil.isNotEmpty(projectIds)){
+                //所有自定义审批的任务
+                Set<Task> tasks = resultList.stream().filter(task -> "0".equals(task.getFixedFlowId().toString())).collect(Collectors.toSet());
+                if(ObjectUtil.isNotEmpty(tasks)){
+                    for (Task task : tasks) {
+                        if(projectIds.contains(Long.parseLong(task.getProjectId()))){
+                            //是自定义垂直审批
+                            handleTaskParallel(task, taskParallelMap,userId, resultList);
+                        }
+                    }
+                }
+            }
+        }
         /*解析page分页数据*/
         IPage<ApiTaskPageVo> page = new Page<>(current, size);
         List<ApiTaskPageVo> pageList = resultList.stream().map(task -> {
@@ -196,6 +267,75 @@ public class APIController {
         return R.data(page);
     }
 
+    private void handleTaskParallel1(Task task, Map<Long, List<FixedFlowLink>> fixedsMap, Map<String, List<TaskParallel>> taskParallelMap, Long userId, List<Task> resultList) {
+        Long fixedFlowId = task.getFixedFlowId();
+        String processInstanceId = task.getProcessInstanceId();
+        //查出当前电签到的节点sort
+        List<TaskParallel> taskParallels = taskParallelMap.get(processInstanceId);
+        Optional<Integer> sortDq = taskParallels.stream()
+            .filter(t -> t.getStatus() == 1)
+            .min(Comparator.comparing(TaskParallel::getSort))
+            .map(TaskParallel::getSort);
+        //获取当前用户的sort值
+        List<Integer> userSort = taskParallels.stream()
+            .filter(t -> t.getTaskUser().equals(userId.toString()))
+            .sorted(Comparator.comparing(TaskParallel::getSort))
+            .map(TaskParallel::getSort).collect(Collectors.toList());
+        Integer dqSort = sortDq.orElse(null);
+        if(ObjectUtil.isNotEmpty(dqSort)){
+            List<Integer> list1 = userSort.stream().filter(a -> dqSort.compareTo(a) <= 0).collect(Collectors.toList());
+            if(ObjectUtil.isEmpty(list1)){
+                //当前用户已经签字过
+                resultList.remove(task);
+            }else {
+                //筛选出最近的一条没有电签的当前用户的sort
+                Integer userMinSort = Collections.min(list1);
+                if(userMinSort.toString().equals(dqSort.toString())){
+                    //当前用户就是下一个电签用户 可审批 放行
+                    return;
+                }
+                List<FixedFlowLink> fixedFlowLinks = fixedsMap.get(fixedFlowId);
+                Optional<FixedFlowLink> dqFlowLink = fixedFlowLinks.stream().filter(f -> f.getFixedFlowBranchSort().equals(dqSort)).findFirst();
+                Optional<FixedFlowLink> userFlowLink = fixedFlowLinks.stream().filter(f -> f.getFixedFlowBranchSort().equals(userMinSort)).findFirst();
+                if(dqFlowLink.get().getFixedFlowLinkSort() == userFlowLink.get().getFixedFlowLinkSort()){
+                    //在同一个小流程里面去判断是否垂直还是水平
+                    if(dqFlowLink.get().getFixedFlowLinkType() == 2){//平行
+                        //通过
+                        return;
+                    }else {
+                        resultList.remove(task);
+                    }
+                }else {
+                    //不在一个小流程 不可审批
+                    resultList.remove(task);
+                }
+            }
+        }else {
+            //全部签完了 肯定不是可审批
+            resultList.remove(task);
+        }
+    }
+    private void handleTaskParallel(Task task,Map<String, List<TaskParallel>> map, Long userId, List<Task> resultList) {
+        String processInstanceId = task.getProcessInstanceId();
+        List<TaskParallel> taskParallels = map.get(processInstanceId.toString());
+        //按照sort升序排序
+        taskParallels.sort(Comparator.comparingInt(TaskParallel::getSort));
+        boolean isApprove = true;
+        for (TaskParallel taskParallel : taskParallels) {
+            if(taskParallel.getTaskUser().toString().equals(userId.toString())){
+                break;
+            }else {
+                if(taskParallel.getStatus() != 2){//不为2说明 还未审批  流程未到当前用户 不可审批
+                    isApprove = false;
+                    break;
+                }
+            }
+        }
+        if(!isApprove){//不可审批的数据
+            resultList.remove(task);
+        }
+    }
+
     /**
      * 第三方对接 获取任务流程状态
      * @param taskId