From 20e8c0b896ffcc27fbe0596f276a01e5dad09608 Mon Sep 17 00:00:00 2001
From: Adam Hopkins <adam.hopkins@simpat.tech>
Date: Mon, 22 Jul 2024 08:46:49 -0500
Subject: [PATCH] Simplify

---
 .../ApiSchema/DependencyCalculator.cs         | 32 +++++++++----------
 1 file changed, 16 insertions(+), 16 deletions(-)

diff --git a/src/core/EdFi.DataManagementService.Core/ApiSchema/DependencyCalculator.cs b/src/core/EdFi.DataManagementService.Core/ApiSchema/DependencyCalculator.cs
index abf25c63f..fc9f357f4 100644
--- a/src/core/EdFi.DataManagementService.Core/ApiSchema/DependencyCalculator.cs
+++ b/src/core/EdFi.DataManagementService.Core/ApiSchema/DependencyCalculator.cs
@@ -80,44 +80,44 @@ private static string ReplaceAbstractResourceNames(string resourceName)
 
     public static Dictionary<string, int> GetDependencies(Dictionary<string, List<string>> resources)
     {
-        Dictionary<string, int> orderedResources = resources.ToDictionary(d => d.Key, _ => 0);
-        Dictionary<string, int> visitedResources = [];
+        Dictionary<string, int> orderedNodes = resources.ToDictionary(d => d.Key, _ => 0);
+        Dictionary<string, int> visitedNodes = [];
 
-        foreach (var dependency in resources.OrderBy(d => d.Value.Count).ThenBy(d => d.Key).Select(d => d.Key))
+        foreach (var resource in resources.Select(d => d.Key))
         {
-            RecursivelyDetermineDependencies(dependency, 0);
+            RecursivelyDetermineDependencies(resource);
         }
 
-        int RecursivelyDetermineDependencies(string resourceName, int depth)
+        int RecursivelyDetermineDependencies(string resourceName)
         {
-            if (orderedResources[resourceName] > 0)
+            if (orderedNodes[resourceName] > 0)
             {
-                return orderedResources[resourceName];
+                return orderedNodes[resourceName];
             }
 
-            visitedResources.TryAdd(resourceName, 0);
-            var maxDepth = depth;
+            visitedNodes.TryAdd(resourceName, 0);
+            var maxDepth = 0;
             foreach (var dependency in resources[resourceName])
             {
-                if (visitedResources.ContainsKey(dependency))
+                if (visitedNodes.ContainsKey(dependency))
                 {
-                    if (visitedResources[dependency] > maxDepth)
+                    if (visitedNodes[dependency] > maxDepth)
                     {
-                        maxDepth = visitedResources[dependency];
+                        maxDepth = visitedNodes[dependency];
                     }
                 }
                 else
                 {
-                    var level = RecursivelyDetermineDependencies(dependency, depth);
+                    var level = RecursivelyDetermineDependencies(dependency);
                     if (level > maxDepth)
                         maxDepth = level;
                 }
             }
-            orderedResources[resourceName] = maxDepth + 1;
-            visitedResources[resourceName] = maxDepth + 1;
+            orderedNodes[resourceName] = maxDepth + 1;
+            visitedNodes[resourceName] = maxDepth + 1;
             return maxDepth + 1;
         }
 
-        return orderedResources;
+        return orderedNodes;
     }
 }