public loadNeighborsPage()

in src/Explorer/Graph/GraphExplorerComponent/GraphExplorer.tsx [572:686]
98 lines of code
19 McCabe index (conditional complexity)

  public loadNeighborsPage(
    vertex: GraphData.GremlinVertex,
    graphData: GraphData.GraphData<GraphData.GremlinVertex, GraphData.GremlinEdge>,
    offsetIndex: number,
  ): Q.Promise<GraphData.GraphData<GraphData.GremlinVertex, GraphData.GremlinEdge>> {
    const updateGraphData = () => {
      // Cache results
      this.edgeInfoCache.addVertex(vertex);

      graphData.setAsRoot(vertex.id);
      this.updateGraphData(graphData, this.state.igraphConfig);
    };

    vertex._outEdgeIds = vertex._outEdgeIds || [];
    vertex._inEdgeIds = vertex._inEdgeIds || [];
    if (
      offsetIndex >= vertex._outEdgeIds.length + vertex._inEdgeIds.length &&
      vertex._outEAllLoaded &&
      vertex._inEAllLoaded
    ) {
      updateGraphData();
      return Q.resolve(graphData);
    }

    // TODO For now, discard previously loaded edges and fetch again.
    // The following assumes that outE's are loaded before inE's
    if (offsetIndex <= vertex._outEdgeIds.length) {
      vertex._outEdgeIds.splice(offsetIndex, vertex._outEdgeIds.length - offsetIndex);
      vertex._inEdgeIds = [];
      vertex._outEAllLoaded = false;
      vertex._inEAllLoaded = false;
    } else if (offsetIndex <= vertex._outEdgeIds.length + vertex._inEdgeIds.length) {
      const relativeOffset = offsetIndex - vertex._outEdgeIds.length;
      vertex._inEdgeIds.splice(relativeOffset, vertex._inEdgeIds.length - relativeOffset);
    }

    GraphUtil.trimGraph(vertex, graphData);
    const totalEdgesToFetch = GraphExplorer.LOAD_PAGE_SIZE + 1;
    let addedEdgesNb = 0;

    let promise: Q.Promise<number> = null;
    if (!vertex._outEAllLoaded) {
      promise = this.fetchEdgeVertexPairs(true, vertex, offsetIndex, totalEdgesToFetch).then(
        (pairs: EdgeVertexPair[]) => {
          vertex._outEAllLoaded = pairs.length < totalEdgesToFetch;

          const pairsToAdd = pairs.slice(0, GraphExplorer.LOAD_PAGE_SIZE);
          pairsToAdd.forEach((p: EdgeVertexPair) => {
            GraphData.GraphData.addOutE(vertex, p.e.label, p.e);
            GraphUtil.addRootChildToGraph(vertex, p.v, graphData);
            graphData.addEdge(p.e);
            vertex._outEdgeIds.push(p.e.id);

            // Cache results (graphdata now contains a vertex with inE's filled in)
            this.edgeInfoCache.addVertex(graphData.getVertexById(p.v.id));
          });
          addedEdgesNb += pairsToAdd.length;
          return pairs.length;
        },
      );
    } else {
      promise = Q.resolve(0);
    }

    promise = promise.then((outEPairsNb: number): Q.Promise<number> => {
      const inEdgesToFetch = totalEdgesToFetch - outEPairsNb;
      if (!vertex._inEAllLoaded && inEdgesToFetch > 0) {
        let start: number;
        if (offsetIndex <= vertex._outEdgeIds.length) {
          start = 0;
        } else {
          start = offsetIndex - vertex._outEdgeIds.length;
        }

        return this.fetchEdgeVertexPairs(false, vertex, start, inEdgesToFetch).then(
          (pairs: EdgeVertexPair[]): number => {
            vertex._inEAllLoaded = pairs.length < inEdgesToFetch;

            const pairsToAdd = pairs.slice(0, GraphExplorer.LOAD_PAGE_SIZE - outEPairsNb);
            pairsToAdd.forEach((p: EdgeVertexPair) => {
              GraphData.GraphData.addInE(vertex, p.e.label, p.e);
              GraphUtil.addRootChildToGraph(vertex, p.v, graphData);
              graphData.addEdge(p.e);
              vertex._inEdgeIds.push(p.e.id);

              // Cache results (graphdata now contains a vertex with outE's filled in)
              this.edgeInfoCache.addVertex(graphData.getVertexById(p.v.id));
            });
            addedEdgesNb += pairsToAdd.length;
            return outEPairsNb + pairs.length;
          },
        );
      } else {
        return Q.resolve(outEPairsNb);
      }
    });

    return promise.then(() => {
      if (offsetIndex >= GraphExplorer.LOAD_PAGE_SIZE || !vertex._outEAllLoaded || !vertex._inEAllLoaded) {
        vertex._pagination = {
          total:
            (vertex._pagination && vertex._pagination.total) ||
            (vertex._outEAllLoaded && vertex._inEAllLoaded
              ? vertex._outEdgeIds.length + vertex._inEdgeIds.length
              : null),
          currentPage: {
            start: offsetIndex,
            end: offsetIndex + addedEdgesNb,
          },
        };
      }
      updateGraphData();
      return graphData;
    });
  }