public static string GenerateJSON()

in tools/Graph Explorer/GraphExplorer/Models/Model.cs [370:520]
122 lines of code
18 McCabe index (conditional complexity)

        public static string GenerateJSON(List<IRecord> records)
        {
            var nodes = new Dictionary<long,object>();
            var edges = new Dictionary<long, object>();
            var values = new List<object>();

            var inDegrees = new Dictionary<long, long>();  // Map from nodeId onto in degree
            var outDegrees = new Dictionary<long, long>(); // Map from nodeId onto out degree

            void GenerateRelationship(IRelationship relationship)
            {
                if (!edges.ContainsKey(relationship.Id))
                {
                    var edge = new Dictionary<string, object>
                    {
                        ["id"] = relationship.Id,
                        ["type"] = relationship.Type,
                        ["from"] = relationship.StartNodeId,
                        ["to"] = relationship.EndNodeId
                    };

                    if (outDegrees.ContainsKey(relationship.StartNodeId))
                        outDegrees[relationship.StartNodeId] += 1;
                    else
                        outDegrees[relationship.StartNodeId] = 1;

                    if (inDegrees.ContainsKey(relationship.EndNodeId))
                        inDegrees[relationship.EndNodeId] += 1;
                    else
                        inDegrees[relationship.EndNodeId] = 1;

                    var props = new Dictionary<string, object>();
                    foreach (var kvp in relationship.Properties.OrderBy(p => p.Key))
                    {
                        props[kvp.Key] = kvp.Value;
                    }
                    edge["properties"] = props;

                    edges[relationship.Id] = edge;
                }
            }

            void GeneratePath(IPath value)
            {
                // Extract the nodes and the bpath between them
                GenerateNode(value.Start);
                GenerateNode(value.End);

                foreach (var relationship in value.Relationships)
                {
                    GenerateRelationship(relationship);
                }
            }

            void GenerateNode(INode node)
            {
                if (!nodes.ContainsKey(node.Id))
                {
                    var n = new Dictionary<string, object>
                    {
                        ["id"] = node.Id,
                        ["labels"] = node.Labels.ToArray()
                    };

                    var props = new Dictionary<string, object>();
                    foreach (var kvp in node.Properties.OrderBy(p => p.Key))
                    {
                        props[kvp.Key] = kvp.Value;
                    }

                    n["properties"] = props;
                    nodes[node.Id] = n;
                }
            }

            void GenerateList(List<object> l)
            {
                //var v = new List<object>();
                //// TODO. Something is wrong here.
                //foreach (var element in l)
                //{
                //    Generate(element);
                //}
                values.Add(l);
            }

            void GenerateObject(object o)
            {
                if (o != null)
                    values.Add(o);
            }

            void Generate(object value)
            {
                if (value is IPath)
                    GeneratePath(value as IPath);
                else if (value is INode)
                    GenerateNode(value as INode);
                else if (value is IRelationship)
                    GenerateRelationship(value as IRelationship);
                else if (value is List<object>)
                    GenerateList(value as List<object>);
                else
                    GenerateObject(value);
            }

            foreach (var record in records)
            {
                var kvps = record.Values;

                foreach (var kvp in kvps)
                {
                    Generate(kvp.Value);
                }
            }


            foreach (var nodeId in nodes.Keys)
            {
                var node = nodes[nodeId] as Dictionary<string, object>;
                var nodeProperties = node["properties"] as Dictionary<string, object>;

                if (inDegrees.ContainsKey(nodeId))
                {
                    nodeProperties["$indegree"] = inDegrees[nodeId];
                }
                else
                {
                    nodeProperties["$indegree"] = 0;
                }

                if (outDegrees.ContainsKey(nodeId))
                {
                    nodeProperties["$outdegree"] = outDegrees[nodeId];
                }
                else
                {
                    nodeProperties["$outdegree"] = 0;
                }
            }

            var result = new Dictionary<string, object>
            {
                ["nodes"] = nodes.Values,
                ["edges"] = edges.Values,
                ["values"] = values
            };

            var serialized = Newtonsoft.Json.JsonConvert.SerializeObject(result, Newtonsoft.Json.Formatting.Indented);
            return serialized;
        }