GoJS graph parser

Question

I am trying to parse an GoJS diagram, user can drag different categories from a plate, circle node, rectangle node, triangle. and he can interconnect them in in one direction until reaching the end.

the required function is to parse the graph and give a list of possible paths according the user dependency graph. sample graph is shown here

my function is something like this code:

function collectPaths(y, x) {
                                var stack = new go.List(go.node);
                                var coll = new go.List(go.List);
                                lock = false;
                                function find(y, x) {
                                    console.log(y.data.name);
                                    y.findNodesInto().each(function (n) {
                                        console.log(y.data.name + " ●▬● " + n.data.name);
                                        if ((n.data.key == x.data.key) && !(lock)) {  // success 
                                            console.log(n.data.name);
                                            var path = stack.copy();
                                            path.reverse();
                                            coll.add(path);
                                        } else if((n.data.key !=x.data.key) && lock){
                                            //   stack.add(n);
                                            console.log(n.data.name);
                                            if (n.data.category === "triangle") {

                                                pp = pp.findNodesInto();
                                                var it = pp.iterator;
                                                var m = new go.Map(go.node, "number");
                                                lock = true;
                                                while (it.next()) {
                                                    m.pop(it.value,it.value);
                                                    stack.add(it.value);
                                                    console.log(it.value.data.name);
                                                    find(it.value, x);
                                                }
                                                var tempList=go.list(go.node);
                                                tempList.each(function (pn) {
                                                   pn = tempList.pop();
                                                  if (!"undefined") {
                                                        stack.add(parent);
                                                        find(parent, x);
                                                        //  stack.add(pn);
                                                        console.log(pn.data.name);
                                                    } else {
                                                        pn = tempList.pop();
                                                        find(pn, x);
                                                    }
                                                });
                                            } else {
                                                console.log(n.data.name);
                                                stack.add(n);
                                                find(n, x);
                                                stack.removeAt(stack.count - 1);
                                            }
                                        }
                                        lock = false;
                                    });
                                } // end of full stack collection
                                find(y, x);
                                return coll;
                            }

but the function doesn't give the required output.

expected output like this: for the figure attached as follows:

N30 – N40 – N10
N1 -N2-N3-N4-N10
N5-N6-N9-N10
N5-N10
N7-N8-N10
N7-N8-N11-N10

What I can do ?

Answer 1

The sample https://gojs.net/latest/samples/distances.html demonstrates how to find all paths between any pair of nodes. You want to use the collectAllPaths function -- you can delete the functions involved with creating a random graph or with finding distances between nodes or with helping the user select the start and end nodes interactively.