Cleaned up code and notes and stated assumptions for how we process NavigationPropertyBindings to generate the reference URL.

Author: MIchaelMainer

Templates/CSharp/Base/CollectionRequest.Base.template.tt

@@ -141,11 +141,9 @@ public string GetImplicitNavigationPropertyUrlSegment(OdcmSingleton singleton, O
 		To help the future dev in figuring this out, put a break point on the next executable line
 		with the condition odcmProperty.Name == "teachers". The CSDL in and entities mentioned in these 
 		comments are an example of the use of this scenario. 
-		
 		****/
 
-
-        // (1) Check that there are NavigationPropertyBindings. If there aren't any, then we know this segment of 
+        // (1) Check that there are NavigationPropertyBindings. If there aren't any, then we know this segment is 
 		// the canonical path to the reference.
         if (singleton.NavigationPropertyBindings.Count == 0)
         {
@@ -158,107 +156,19 @@ public string GetImplicitNavigationPropertyUrlSegment(OdcmSingleton singleton, O
 		// defines the EntitySet that contains this property. The NavigationPropertyBindings provide generation hints for how to 
 		// reference non-contained entities that are defined within the same Singleton (this statement is conjecture). This generation
 		// hints is used to specify a reference URL for $ref call. 
-
 		// Example: in this case, "teachers". This should be the end part of the BindingPath.
 
         IEnumerable<string> keys = singleton.NavigationPropertyBindings.Where(kvp => kvp.Key.EndsWith(odcmProperty.Name)).Select(kvp => kvp.Key);
-		/*
-                <Singleton Name="education" Type="microsoft.graph.educationRoot">
-                     <NavigationPropertyBinding Path="classes/teachers" Target="users" />
-                    <NavigationPropertyBinding Path="classes/members" Target="users" />
-                    <NavigationPropertyBinding Path="classes/schools" Target="schools" />
-                    <NavigationPropertyBinding Path="schools/classes" Target="classes" />
-                    <NavigationPropertyBinding Path="schools/users" Target="users" />
-                    <NavigationPropertyBinding Path="users/schools" Target="schools" />
-                    <NavigationPropertyBinding Path="users/classes" Target="classes" />
-                </Singleton>
-
-				<EntityType Name="educationRoot" BaseType="microsoft.graph.entity">
-					<NavigationProperty Name="synchronizationProfiles" Type="Collection(microsoft.graph.educationSynchronizationProfile)" ContainsTarget="true" />
-					 <NavigationProperty Name="classes" Type="Collection(microsoft.graph.educationClass)" ContainsTarget="true" />
-					<NavigationProperty Name="schools" Type="Collection(microsoft.graph.educationSchool)" ContainsTarget="true" />
-					<NavigationProperty Name="users" Type="Collection(microsoft.graph.educationUser)" ContainsTarget="true" />
-					<NavigationProperty Name="me" Type="microsoft.graph.educationUser" ContainsTarget="true" />
-				</EntityType>
-
-				<EntityType Name="educationClass" BaseType="microsoft.graph.entity">
-					<Property Name="displayName" Type="Edm.String" Nullable="false" />
-					<NavigationProperty Name="schools" Type="Collection(microsoft.graph.educationSchool)" />
-					<NavigationProperty Name="members" Type="Collection(microsoft.graph.educationUser)" />
- 					 <NavigationProperty Name="teachers" Type="Collection(microsoft.graph.educationUser)" />
-					<NavigationProperty Name="group" Type="microsoft.graph.group" />
-					<NavigationProperty Name="assignments" Type="Collection(microsoft.graph.educationAssignment)" ContainsTarget="true" />
-				</EntityType>
-		*/
-
-		// We need to support long NavPropBindings. That is, we need to support multi-segment NavigationPropertyBinding paths
-		// (3) We need to query the paths in {keys} against the entity (odcmProperty.Class) that contains this navigation property (odcmProperty). 
-		//	   We need to determine the unique binding path from the singleton through the entity on to this navigation property, query the keys
-		//       for it, and then get the target. There could be 1 or more pat segments that we need to account for.
-		// Example: odcmProperty.Class is the entity "educationClass" that has the non-contained navigation property represented by odcmProperty,
-		// which is named 'teachers'. At this point, we know the singleton and all of its NavigationPropertyBindings, we know the singleton's entity type,
-		// which is named 'educationRoot'.
-		// We need to determine whether a NavigationPropertyBinding pth and target is different than the CSDL described path to the reference non-contained entity. 
-
-		// odcmProperty.Name; // --> "teachers"
-
-		var navPropClassToFind = odcmProperty.Class.Name; // -- > "educationClass"; This is the EntityType that contains the navigation property
-		string firstBindingPathSegment = ""; // We are incorrectly assuming to segment.
-				
-		// Get the path segments.
-		//string[] navPropBindingSegments = keys.First().Split('/'); 
-
-		// Example: After hitting the conditional breakpoint, singleton.Type.Name is "educationRoot". 
-		// We are going to inspect each navigation property on singleton's type and compare to the segments
-		// in the keys IEnumerable. 
-		// The assumption here is that the first segment is a navigation property of the singleton's type
-		// The second assumption is that there are only two segments. We know this is a bad assumption.
-		// The third assumption is that the last segment is the most meaningful. 
-		// In short, this only works for a Path that has two segments.
-
-		foreach (OdcmProperty prop in (singleton.Type as OdcmEntityClass).Properties)
-		{
-			if (prop.Type.Name == navPropClassToFind)
-			{
-				firstBindingPathSegment = prop.Name;
-				break;
-			}		 	
-		}
-
-		/*
-			What we know.
-
-			We know the navigation property name and type.
-			We know whih entity contains the navigation property.
-			We know that the navigation property does not contain the entity.
-			We know which singleton is the entity set for the navigation property.
-			We know the singleton's type.
-			We know the NavigationPropertyBindings and which candidates CAN be the one to define the reference path to the entity in the navigation.
-
-			We don't know the paths to the entity that contains our navigation property. So, the question is, can we know the context in which the 
-			navigation property is being accessed at generation time? I don't think we can.
-
-			The next question is can we code the templates to generate code that is context aware and can create the ref path based on that context. 
-			This is a maybe. 
-
-			Our current example works since the scenario only has two levels of entities. What happens when we have three level of entities like
-			/schools/classes/teachers. We know the teachers segments. We don't have context which entities are accessed across the request builders
-			at runtime. 
-
-			We may need to generate a dictionary from the NavPropBindings in to the code files and use those at runtime to discover the context in
-			which a navigtion is called in order to provide the correct reference path. 
-
-			TODO: investigate what it would take to generate code that is context aware of binding path.
-		*/
-
-		string secondBindingPathSegment = odcmProperty.Name;
-
-		//string bindingPath = firstBindingPathSegment + "/" + keys.First(); // TODO: Need to fix this.
-		string bindingPath = firstBindingPathSegment + "/" + secondBindingPathSegment;
 
 		string bindingTarget;
 
-		if (singleton.NavigationPropertyBindings.TryGetValue(bindingPath, out bindingTarget))
+        // The first assumption is that CSDL is added with a convention where the last path segment in NavigationPropertyBinding.Path
+        // is named consistently in a singleton so it doesn't matter what the preceding segments are. 
+        // The second assumption is that if the last path is named consistently, the target will be consistent as well.
+        // These may turn out to be a weak assumption. We use this assumption since we can't determine a unique path
+        // for three or more segments since *RequestBuilder and *Request objects are generated per entity+navigation,
+        // and not [entity+navigation]*n --> across multiple navigations.
+		if (keys.Count() > 0 && singleton.NavigationPropertyBindings.TryGetValue(keys.First(), out bindingTarget))
 		{
 			// We found the target
 			return "/" + bindingTarget;