记一次递归的使用(流程平台)

/**
   * 获取流程节点数据，用于页面图形展示
   *
   * @param param
   * @return
   */
  private ProcessInfoVo getFlowNodeInfo(QueryNodeInfoParam param) {

    // 获取流程实例ID
    String processInstanceId = processHistoryBiz.getLatestProcessInstanceId(param);

    param.setProcessInstanceId(processInstanceId);

    //获取流程图元素信息
    ProcessInfoVo vo = processMethodsFeign.getNodeInfo(param).getData();

    String fJsonData = processHistoryBiz.getFJsonDataByProcessDefinitionId(param.getProcessDefinitionId()).getJsonData();
    JSONArray jsonArray = JSONObject.parseObject(fJsonData).getJSONArray("nodes");
    Map<String, String> nodeClzMap = new HashMap<>();
    Map<String, String> dataSourceIdMap = new HashMap<>();
    Map<String, String> contrastFlagMap = new HashMap<>();
    for (int i = 0; i < jsonArray.size(); i++) {
      String key = jsonArray.getJSONObject(i).getString("id");
      String clazz = jsonArray.getJSONObject(i).getString("clazz");
      String monitorTask = jsonArray.getJSONObject(i).getString("monitorTask");
      String contrastFlag = jsonArray.getJSONObject(i).getString("contrastFlag");
      nodeClzMap.put(key, clazz);
      dataSourceIdMap.put(key, monitorTask);
      contrastFlagMap.put(key, contrastFlag);
    }

    String firstNodeId = vo.getFirstNode().getId();

    for (NodeInfoVo item : vo.getNodes()) {
      item.setClazz(nodeClzMap.get(item.getId()));
      item.setContrastFlag(contrastFlagMap.get(item.getId()));

      //获取数据源
      //DataSourceDO dataSourceDO = dataSourceBiz.queryDataSourceByTaskId(taskId)
      DataSourceDO dataSourceDO = null;
      if (null != (dataSourceIdMap.get(item.getId()))) {
        dataSourceDO = dataSourceBiz.getOne(new QueryWrapper<DataSourceDO>().eq("id", dataSourceIdMap.get(item.getId())));
      }
      if (dataSourceDO == null) {
        continue;
      }

      item.setNodeDataType("service".equals(dataSourceDO.getType()) ? "0" : "1");

      String taskId = item.getTaskId();
      if (StringUtils.isBlank(taskId)) {
        continue;
      }

      item.setClickFlag(true);

      //获取判定标准
      ComplateFlag complateFlag = complateFlagBiz.queryComplateFlagByDataSourceId(dataSourceDO.getId());

      //没有设置判定标准，则查看节点状态
      if (complateFlag == null) {
        continue;
      }

      //获取变量结果
      String resultVariable = dataSourceDO.getResultVariable();
      Object data = processMethodsFeign.getHistoryVariable(taskId, resultVariable).getData();

      int finished = 0;
      int unfinished = 0;
      if ("0".equals(item.getContrastFlag())) {
        if (data instanceof Collection) {
          Map[] resultMaps = JSON.parseObject(JSON.toJSONString(data), Map[].class);
          for (Map visiable : resultMaps) {
            String visiableValue = (String) visiable.get(complateFlag.getField());

            //判断字段值是否符合预设值
            if (complateFlag.getValue().equals(visiableValue)) {
              finished++;
            } else {
              unfinished++;
            }
          }
        } else {
          Map resultMap = JSON.parseObject(JSON.toJSONString(data), Map.class);

          String visiableValue = (String) resultMap.get(complateFlag.getField());

          //判断字段值是否符合预设值
          if (complateFlag.getValue().equals(visiableValue)) {
            finished++;
          } else {
            unfinished++;
          }
        }
      }

      item.setFinished(finished);
      item.setUnfinished(unfinished);

      if (item.getId().equals(firstNodeId)) {
        vo.setFirstNode(item);
      }
    }

    // 解析分离主子流程图
    Map<String, NodeInfoVo> nodesMap = new HashMap<>();
    List<String> startNodeList = new ArrayList<>();
    for (NodeInfoVo nodeInfoVo : vo.getNodes()) {
      if (nodeInfoVo.getId().startsWith("start") || nodeInfoVo.getId().startsWith("signalStart")) {
        startNodeList.add(nodeInfoVo.getId());
      }
      nodesMap.put(nodeInfoVo.getId(), nodeInfoVo);
    }

    List<ProcessInfoVo> voList = new ArrayList<>();
    for (String startNodeId : startNodeList) {
      ProcessInfoVo processInfoVo = new ProcessInfoVo();
      List<NodeInfoVo> nodesList = new ArrayList<>();
      List<EdgesInfoVo> edgesList = new ArrayList<>();
      nodesList.add(nodesMap.get(startNodeId));
      processInfoVo.setNodes(nodesList);
      processInfoVo.setEdges(edgesList);

      processInfoVo = getProcessInfoVo(startNodeId, vo, processInfoVo);

//      NodeInfoVo firstNode = new NodeInfoVo();
//      boolean existFirstNode = false;
//      for(NodeInfoVo o : processInfoVo.getNodes()){
//        if("monitorTask".equals(o.getClazz())){
//          existFirstNode = true;
//          break;
//        }
//      }
//      if(existFirstNode){
//        firstNode = getFirstNode(startNodeId, vo, firstNode);
//      }
//      processInfoVo.setFirstNode(firstNode);

      // 获取首节点,判断紧跟着起点后的节点,若该节点类型为monitorTask,则直接返回,否则返回空对象,此时前端不在初始化查询首节点的数据
      List<EdgesInfoVo> edgeList = nodeToEdgeList(startNodeId, vo.getEdges());
      NodeInfoVo node = edgeToNode(edgeList.get(0), vo.getNodes());
      processInfoVo.setFirstNode("monitorTask".equals(node.getClazz()) ? node : new NodeInfoVo());


      List<NodeInfoVo> nodeInfoVos = processInfoVo.getNodes().stream().distinct().collect(Collectors.toList());
      List<EdgesInfoVo> edgesInfoVos = processInfoVo.getEdges().stream().distinct().collect(Collectors.toList());

      processInfoVo.setNodes(nodeInfoVos);
      processInfoVo.setEdges(edgesInfoVos);
      voList.add(processInfoVo);
    }

    ProcessInfoVo returnVo = new ProcessInfoVo();
    for (ProcessInfoVo processInfoVo : voList) {
      for (NodeInfoVo nodeInfoVo : processInfoVo.getNodes()) {
        if (nodeInfoVo.getId().equals(param.getStartActId())) {
          returnVo = processInfoVo;
        }
      }
    }

    return returnVo;
  }

  private ProcessInfoVo getProcessInfoVo(String nodeId, ProcessInfoVo sumVo, ProcessInfoVo vo) {
    List<EdgesInfoVo> edgeList = nodeToEdgeList(nodeId, sumVo.getEdges());
    if (edgeList.size() == 0) return vo;
    vo.getEdges().addAll(edgeList);
    for (EdgesInfoVo o : edgeList) {
      NodeInfoVo node = edgeToNode(o, sumVo.getNodes());
      vo.getNodes().add(node);
      vo = getProcessInfoVo(node.getId(), sumVo, vo);
    }
    return vo;
  }

  private NodeInfoVo getFirstNode(String startNodeId, ProcessInfoVo sumVo, NodeInfoVo vo) {
    List<EdgesInfoVo> edgeList = nodeToEdgeList(startNodeId, sumVo.getEdges());
    for (EdgesInfoVo edge : edgeList) {
      NodeInfoVo node = edgeToNode(edge, sumVo.getNodes());
      if ("end".equals(node.getClazz())) continue;
      if ("monitorTask".equals(node.getClazz())) {
        vo = node;
        break;
      } else {
        vo = getFirstNode(node.getId(), sumVo, vo);
      }
    }
    return vo;
  }

  private List<EdgesInfoVo> nodeToEdgeList(String nodeId, List<EdgesInfoVo> edgesInfoVos) {
    List<EdgesInfoVo> edgeList = new ArrayList<>();
    for (EdgesInfoVo temp : edgesInfoVos) {
      if (temp.getSource().equals(nodeId)) {
        edgeList.add(temp);
      }
    }
    return edgeList;
  }

  private NodeInfoVo edgeToNode(EdgesInfoVo edge, List<NodeInfoVo> nodeInfoVos) {
    NodeInfoVo node = new NodeInfoVo();
    for (NodeInfoVo temp : nodeInfoVos) {
      if (StringUtils.isNotBlank(edge.getTarget()) && edge.getTarget().equals(temp.getId())) {
        node = temp;
      }
    }
    return node;
  }