Fixes potential duplicate operation ids of navigation property paths with overloaded composable functions (#597)

irvinesunday · baywet · andrueastman · web-flow · commit a464bed4966c · 2024-10-17T17:26:48.000+03:00
* Fixes generation of navigation property op ids with overloaded composable fxns

* Adds validation unit test

* Updates release note

* chore: adds string comparison

Co-authored-by: Andrew Omondi &lt;andrueastman@users.noreply.github.com&gt;

---------

Co-authored-by: Vincent Biret &lt;vibiret@microsoft.com&gt;
Co-authored-by: Andrew Omondi &lt;andrueastman@users.noreply.github.com&gt;
diff --git a/src/Microsoft.OpenApi.OData.Reader/Common/EdmModelHelper.cs b/src/Microsoft.OpenApi.OData.Reader/Common/EdmModelHelper.cs
@@ -93,38 +93,40 @@ internal static bool NavigationRestrictionsAllowsNavigability(
         /// Generates the operation id from a navigation property path.
         /// </summary>
         /// <param name="path">The target <see cref="ODataPath"/>.</param>
+        /// <param name="context">The OData context.</param>
         /// <param name="prefix">Optional: Identifier indicating whether it is a collection-valued non-indexed or single-valued navigation property.</param>
         /// <returns>The operation id generated from the given navigation property path.</returns>
-        internal static string GenerateNavigationPropertyPathOperationId(ODataPath path, string prefix = null)
+        internal static string GenerateNavigationPropertyPathOperationId(ODataPath path, ODataContext context, string prefix = null)
         {
-            IList<string> items = RetrieveNavigationPropertyPathsOperationIdSegments(path);
+            IList<string> items = RetrieveNavigationPropertyPathsOperationIdSegments(path, context);
 
             if (!items.Any())
                 return null;
 
-            int lastItemIndex = items.Count - 1;
+            int lastItemIndex = items[^1].StartsWith('-') ? items.Count - 2 : items.Count - 1;
             
             if (!string.IsNullOrEmpty(prefix))
             {
-                items[lastItemIndex] = prefix + Utils.UpperFirstChar(items.Last());
+                items[lastItemIndex] = prefix + Utils.UpperFirstChar(items[lastItemIndex]);
             }
             else
             {
-                items[lastItemIndex] = Utils.UpperFirstChar(items.Last());
+                items[lastItemIndex] = Utils.UpperFirstChar(items[lastItemIndex]);
             }
 
-            return string.Join(".", items);
+            return GenerateNavigationPropertyPathOperationId(items);
         }
 
         /// <summary>
         /// Generates the operation id from a complex property path.
         /// </summary>
         /// <param name="path">The target <see cref="ODataPath"/>.</param>
+        /// <param name="context">The OData context.</param>
         /// <param name="prefix">Optional: Identifier indicating whether it is a collection-valued or single-valued complex property.</param>
         /// <returns>The operation id generated from the given complex property path.</returns>
-        internal static string GenerateComplexPropertyPathOperationId(ODataPath path, string prefix = null)
+        internal static string GenerateComplexPropertyPathOperationId(ODataPath path, ODataContext context, string prefix = null)
         {
-            IList<string> items = RetrieveNavigationPropertyPathsOperationIdSegments(path);
+            IList<string> items = RetrieveNavigationPropertyPathsOperationIdSegments(path, context);
 
             if (!items.Any())
                 return null;
@@ -141,15 +143,29 @@ internal static string GenerateComplexPropertyPathOperationId(ODataPath path, st
                 items.Add(Utils.UpperFirstChar(lastSegment?.Identifier));
             }
 
-            return string.Join(".", items);
+            return GenerateNavigationPropertyPathOperationId(items);
+        }
+
+        /// <summary>
+        /// Generates a navigation property operation id from a list of string values.
+        /// </summary>
+        /// <param name="items">The list of string values.</param>
+        /// <returns>The generated navigation property operation id.</returns>
+        private static string GenerateNavigationPropertyPathOperationId(IList<string> items)
+        {
+            if (!items.Any())
+                return null;
+
+            return string.Join(".", items).Replace(".-", "-", StringComparison.OrdinalIgnoreCase); // Format any hashed value appropriately (this will be the last value)
         }
 
         /// <summary>
         /// Retrieves the segments of an operation id generated from a navigation property path.
         /// </summary>
         /// <param name="path">The target <see cref="ODataPath"/>.</param>
+        /// <param name="context">The OData context.</param>
         /// <returns>The segments of an operation id generated from the given navigation property path.</returns>
-        internal static IList<string> RetrieveNavigationPropertyPathsOperationIdSegments(ODataPath path)
+        internal static IList<string> RetrieveNavigationPropertyPathsOperationIdSegments(ODataPath path, ODataContext context)
         {
             Utils.CheckArgumentNull(path, nameof(path));
 
@@ -173,6 +189,8 @@ s is ODataOperationSegment ||
             Utils.CheckArgumentNull(segments, nameof(segments));
 
             string previousTypeCastSegmentId = null;
+            string pathHash = string.Empty;
+
             foreach (var segment in segments)
             {
                 if (segment is ODataNavigationPropertySegment navPropSegment)
@@ -192,6 +210,14 @@ s is ODataOperationSegment ||
                 else if (segment is ODataOperationSegment operationSegment)
                 {
                     // Navigation property generated via composable function
+                    if (operationSegment.Operation is IEdmFunction function && context.Model.IsOperationOverload(function))
+                    {
+                        // Hash the segment to avoid duplicate operationIds
+                        pathHash = string.IsNullOrEmpty(pathHash)
+                            ? operationSegment.GetPathHash(context.Settings)
+                            : (pathHash + operationSegment.GetPathHash(context.Settings)).GetHashSHA256()[..4];
+                    }
+
                     items.Add(operationSegment.Identifier);
                 }
                 else if (segment is ODataKeySegment keySegment && keySegment.IsAlternateKey)
@@ -208,6 +234,11 @@ s is ODataOperationSegment ||
                 }
             }
 
+            if (!string.IsNullOrEmpty(pathHash))
+            {
+                items.Add("-" + pathHash);
+            }
+
             return items;
         }
 
@@ -320,9 +351,10 @@ internal static string GenerateComplexPropertyPathTagName(ODataPath path, ODataC
         /// Generates the operation id prefix from an OData type cast path.
         /// </summary>
         /// <param name="path">The target <see cref="ODataPath"/>.</param>
+        /// <param name="context">The OData context.</param>
         /// <param name="includeListOrGetPrefix">Optional: Whether to include the List or Get prefix to the generated operation id.</param>
         /// <returns>The operation id prefix generated from the OData type cast path.</returns>
-        internal static string GenerateODataTypeCastPathOperationIdPrefix(ODataPath path, bool includeListOrGetPrefix = true)
+        internal static string GenerateODataTypeCastPathOperationIdPrefix(ODataPath path, ODataContext context, bool includeListOrGetPrefix = true)
         {
             // Get the segment before the last OData type cast segment
             ODataTypeCastSegment typeCastSegment = path.Segments.OfType<ODataTypeCastSegment>()?.Last();
@@ -352,7 +384,7 @@ internal static string GenerateODataTypeCastPathOperationIdPrefix(ODataPath path
             if (secondLastSegment is ODataComplexPropertySegment complexSegment)
             {
                 string listOrGet = includeListOrGetPrefix ? (complexSegment.Property.Type.IsCollection() ? "List" : "Get") : null;
-                operationId = GenerateComplexPropertyPathOperationId(path, listOrGet);
+                operationId = GenerateComplexPropertyPathOperationId(path, context, listOrGet);
             }
             else if (secondLastSegment is ODataNavigationPropertySegment navPropSegment)
             {
@@ -362,13 +394,13 @@ internal static string GenerateODataTypeCastPathOperationIdPrefix(ODataPath path
                     prefix = navPropSegment?.NavigationProperty.TargetMultiplicity() == EdmMultiplicity.Many ? "List" : "Get";
                 }
 
-                operationId = GenerateNavigationPropertyPathOperationId(path, prefix);
+                operationId = GenerateNavigationPropertyPathOperationId(path, context, prefix);
             }
             else if (secondLastSegment is ODataKeySegment keySegment)
             {
                 if (isIndexedCollValuedNavProp)
                 {
-                    operationId = GenerateNavigationPropertyPathOperationId(path, "Get");
+                    operationId = GenerateNavigationPropertyPathOperationId(path, context, "Get");
                 }
                 else
                 {
diff --git a/src/Microsoft.OpenApi.OData.Reader/Microsoft.OpenAPI.OData.Reader.csproj b/src/Microsoft.OpenApi.OData.Reader/Microsoft.OpenAPI.OData.Reader.csproj
@@ -15,7 +15,7 @@
     <TargetFrameworks>net8.0</TargetFrameworks>
     <PackageId>Microsoft.OpenApi.OData</PackageId>
     <SignAssembly>true</SignAssembly>
-    <Version>2.0.0-preview.5</Version>
+    <Version>2.0.0-preview.6</Version>
     <Description>This package contains the codes you need to convert OData CSDL to Open API Document of Model.</Description>
     <Copyright>© Microsoft Corporation. All rights reserved.</Copyright>
     <PackageTags>Microsoft OpenApi OData EDM</PackageTags>
@@ -28,9 +28,10 @@
 		- Adds nullable to double schema conversions #581
 		- Updates tag names for actions/functions operations #585
 		- Creates unique operation ids for paths with composable overloaded functions #580
-        - Further fixes for double/decimal/float schema conversions #581
-        - Replaced integer types by number types
+		- Further fixes for double/decimal/float schema conversions #581
+		- Replaced integer types by number types
 		- Further fix for generating unique operation ids for paths with composable overloaded functions where all functions in path are overloaded #594
+		- Further fix for generating unique operation ids for navigation property paths with composable overloaded functions #596
 	</PackageReleaseNotes>
     <AssemblyName>Microsoft.OpenApi.OData.Reader</AssemblyName>
     <AssemblyOriginatorKeyFile>..\..\tool\Microsoft.OpenApi.OData.snk</AssemblyOriginatorKeyFile>
diff --git a/src/Microsoft.OpenApi.OData.Reader/Operation/ComplexPropertyGetOperationHandler.cs b/src/Microsoft.OpenApi.OData.Reader/Operation/ComplexPropertyGetOperationHandler.cs
@@ -39,7 +39,7 @@ protected override void SetBasicInfo(OpenApiOperation operation)
         if (Context.Settings.EnableOperationId)
         {
             string prefix = ComplexPropertySegment.Property.Type.IsCollection() ? "List" : "Get";
-            operation.OperationId = EdmModelHelper.GenerateComplexPropertyPathOperationId(Path, prefix);
+            operation.OperationId = EdmModelHelper.GenerateComplexPropertyPathOperationId(Path, Context, prefix);
         }
 
         // Summary and Description
diff --git a/src/Microsoft.OpenApi.OData.Reader/Operation/ComplexPropertyPostOperationHandler.cs b/src/Microsoft.OpenApi.OData.Reader/Operation/ComplexPropertyPostOperationHandler.cs
@@ -42,7 +42,7 @@ protected override void SetBasicInfo(OpenApiOperation operation)
         // OperationId
         if (Context.Settings.EnableOperationId)
         {
-            operation.OperationId = EdmModelHelper.GenerateComplexPropertyPathOperationId(Path, "Set");
+            operation.OperationId = EdmModelHelper.GenerateComplexPropertyPathOperationId(Path, Context, "Set");
         }
 
         // Summary and Description
diff --git a/src/Microsoft.OpenApi.OData.Reader/Operation/ComplexPropertyUpdateOperationHandler.cs b/src/Microsoft.OpenApi.OData.Reader/Operation/ComplexPropertyUpdateOperationHandler.cs
@@ -40,7 +40,7 @@ protected override void SetBasicInfo(OpenApiOperation operation)
         // OperationId
         if (Context.Settings.EnableOperationId)
         {
-            operation.OperationId = EdmModelHelper.GenerateComplexPropertyPathOperationId(Path, "Update");
+            operation.OperationId = EdmModelHelper.GenerateComplexPropertyPathOperationId(Path, Context, "Update");
         }
     }
 
diff --git a/src/Microsoft.OpenApi.OData.Reader/Operation/DollarCountGetOperationHandler.cs b/src/Microsoft.OpenApi.OData.Reader/Operation/DollarCountGetOperationHandler.cs
@@ -128,17 +128,17 @@ protected override void SetBasicInfo(OpenApiOperation operation)
                 }
                 else if (SecondLastSegment is ODataNavigationPropertySegment)
                 {
-                    var navPropOpId = string.Join(".", EdmModelHelper.RetrieveNavigationPropertyPathsOperationIdSegments(Path));
+                    var navPropOpId = string.Join(".", EdmModelHelper.RetrieveNavigationPropertyPathsOperationIdSegments(Path, Context));
                     operation.OperationId = $"{navPropOpId}.GetCount-{Path.GetPathHash(Context.Settings)}";
                 }
                 else if (SecondLastSegment is ODataTypeCastSegment odataTypeCastSegment)
                 {
                     IEdmNamedElement targetStructuredType = odataTypeCastSegment.StructuredType as IEdmNamedElement;
-                    operation.OperationId = $"{EdmModelHelper.GenerateODataTypeCastPathOperationIdPrefix(Path, false)}.GetCount.As{Utils.UpperFirstChar(targetStructuredType.Name)}-{Path.GetPathHash(Context.Settings)}";
+                    operation.OperationId = $"{EdmModelHelper.GenerateODataTypeCastPathOperationIdPrefix(Path, Context, false)}.GetCount.As{Utils.UpperFirstChar(targetStructuredType.Name)}-{Path.GetPathHash(Context.Settings)}";
                 }
                 else if (SecondLastSegment is ODataComplexPropertySegment)
                 {
-                    operation.OperationId = $"{EdmModelHelper.GenerateComplexPropertyPathOperationId(Path)}.GetCount-{Path.GetPathHash(Context.Settings)}";
+                    operation.OperationId = $"{EdmModelHelper.GenerateComplexPropertyPathOperationId(Path, Context)}.GetCount-{Path.GetPathHash(Context.Settings)}";
                 }
             }
 
diff --git a/src/Microsoft.OpenApi.OData.Reader/Operation/NavigationPropertyOperationHandler.cs b/src/Microsoft.OpenApi.OData.Reader/Operation/NavigationPropertyOperationHandler.cs
@@ -107,7 +107,7 @@ protected override void SetExtensions(OpenApiOperation operation)
 
         internal string GetOperationId(string prefix = null)
         {            
-            return EdmModelHelper.GenerateNavigationPropertyPathOperationId(Path, prefix);
+            return EdmModelHelper.GenerateNavigationPropertyPathOperationId(Path, Context, prefix);
         }               
 
         /// <inheritdoc/>
diff --git a/src/Microsoft.OpenApi.OData.Reader/Operation/ODataTypeCastGetOperationHandler.cs b/src/Microsoft.OpenApi.OData.Reader/Operation/ODataTypeCastGetOperationHandler.cs
@@ -188,7 +188,7 @@ protected override void SetBasicInfo(OpenApiOperation operation)
 
         // OperationId
         if (Context.Settings.EnableOperationId)
-			operation.OperationId = EdmModelHelper.GenerateODataTypeCastPathOperationIdPrefix(Path) + $".As{Utils.UpperFirstChar(TargetSchemaElement.Name)}";
+			operation.OperationId = EdmModelHelper.GenerateODataTypeCastPathOperationIdPrefix(Path, Context) + $".As{Utils.UpperFirstChar(TargetSchemaElement.Name)}";
 
         base.SetBasicInfo(operation);
 	}
diff --git a/test/Microsoft.OpenAPI.OData.Reader.Tests/Operation/NavigationPropertyGetOperationHandlerTests.cs b/test/Microsoft.OpenAPI.OData.Reader.Tests/Operation/NavigationPropertyGetOperationHandlerTests.cs
@@ -131,6 +131,70 @@ public void CreateNavigationGetOperationViaComposableFunctionReturnsCorrectOpera
             Assert.Contains(operation.Parameters, x => x.Name == "path");
         }
 
+        [Fact]
+        public void CreateNavigationGetOperationViaOverloadedComposableFunctionReturnsCorrectOperation()
+        {
+            // Arrange
+            IEdmModel model = EdmModelHelper.GraphBetaModel;
+            ODataContext context = new(model, new OpenApiConvertSettings()
+            {
+                EnableOperationId = true
+            });
+
+            IEdmEntitySet drives = model.EntityContainer.FindEntitySet("drives");
+            IEdmEntityType drive = model.SchemaElements.OfType<IEdmEntityType>().First(c => c.Name == "drive");
+            IEdmNavigationProperty items = drive.DeclaredNavigationProperties().First(c => c.Name == "items");
+            IEdmEntityType driveItem = model.SchemaElements.OfType<IEdmEntityType>().First(c => c.Name == "driveItem");
+            IEdmNavigationProperty workbook = driveItem.DeclaredNavigationProperties().First(c => c.Name == "workbook");
+            IEdmEntityType workbookEntity = model.SchemaElements.OfType<IEdmEntityType>().First(c => c.Name == "workbook");
+            IEdmNavigationProperty worksheets = workbookEntity.DeclaredNavigationProperties().First(c => c.Name == "worksheets");
+            IEdmEntityType workbookWorksheet = model.SchemaElements.OfType<IEdmEntityType>().First(c => c.Name == "workbookWorksheet");
+            IEdmOperation usedRangeWithParams = model.SchemaElements.OfType<IEdmOperation>().First(f => f.Name == "usedRange" && f.Parameters.Any(x => x.Name.Equals("valuesOnly")));
+            IEdmOperation usedRange = model.SchemaElements.OfType<IEdmOperation>().First(f => f.Name == "usedRange" && f.Parameters.Count() == 1);
+            IEdmEntityType workbookRange = model.SchemaElements.OfType<IEdmEntityType>().First(c => c.Name == "workbookRange");
+            IEdmNavigationProperty format = workbookRange.DeclaredNavigationProperties().First(c => c.Name == "format");
+
+
+            ODataPath path1 = new(new ODataNavigationSourceSegment(drives),
+                new ODataKeySegment(drive),
+                new ODataNavigationPropertySegment(items),
+                new ODataKeySegment(driveItem),
+                new ODataNavigationPropertySegment(workbook),
+                new ODataNavigationPropertySegment(worksheets),
+                new ODataKeySegment(workbookWorksheet),
+                new ODataOperationSegment(usedRangeWithParams),
+                new ODataNavigationPropertySegment(format));
+
+            ODataPath path2 = new(new ODataNavigationSourceSegment(drives),
+                new ODataKeySegment(drive),
+                new ODataNavigationPropertySegment(items),
+                new ODataKeySegment(driveItem),
+                new ODataNavigationPropertySegment(workbook),
+                new ODataNavigationPropertySegment(worksheets),
+                new ODataKeySegment(workbookWorksheet),
+                new ODataOperationSegment(usedRange),
+                new ODataNavigationPropertySegment(format));
+
+            // Act
+            var operation1 = _operationHandler.CreateOperation(context, path1);
+            var operation2 = _operationHandler.CreateOperation(context, path2);
+
+            // Assert
+            Assert.NotNull(operation1);
+            Assert.NotNull(operation2);
+
+            Assert.Equal("drives.items.workbook.worksheets.usedRange.GetFormat-206d", operation1.OperationId);
+            Assert.Equal("drives.items.workbook.worksheets.usedRange.GetFormat-ec2c", operation2.OperationId);
+
+            Assert.NotNull(operation1.Parameters);
+            Assert.Equal(6, operation1.Parameters.Count);
+            Assert.Contains(operation1.Parameters, x => x.Name == "valuesOnly");
+
+            Assert.NotNull(operation2.Parameters);
+            Assert.Equal(5, operation2.Parameters.Count);
+            Assert.DoesNotContain(operation2.Parameters, x => x.Name == "valuesOnly");
+        }
+
         [Theory]
         [InlineData(true)]
         [InlineData(false)]

Original file line number	Diff line number	Diff line change
`@@ -93,38 +93,40 @@ internal static bool NavigationRestrictionsAllowsNavigability(`
`93`	`93`	`/// Generates the operation id from a navigation property path.`
`94`	`94`	`/// </summary>`
`95`	`95`	`/// <param name="path">The target <see cref="ODataPath"/>.</param>`
	`96`	`+ /// <param name="context">The OData context.</param>`
`96`	`97`	`/// <param name="prefix">Optional: Identifier indicating whether it is a collection-valued non-indexed or single-valued navigation property.</param>`
`97`	`98`	`/// <returns>The operation id generated from the given navigation property path.</returns>`
`98`		`- internal static string GenerateNavigationPropertyPathOperationId(ODataPath path, string prefix = null)`
	`99`	`+ internal static string GenerateNavigationPropertyPathOperationId(ODataPath path, ODataContext context, string prefix = null)`
`99`	`100`	`{`
`100`		`- IList<string> items = RetrieveNavigationPropertyPathsOperationIdSegments(path);`
	`101`	`+ IList<string> items = RetrieveNavigationPropertyPathsOperationIdSegments(path, context);`
`101`	`102`
`102`	`103`	`if (!items.Any())`
`103`	`104`	`return null;`
`104`	`105`
`105`		`- int lastItemIndex = items.Count - 1;`
	`106`	`+ int lastItemIndex = items[^1].StartsWith('-') ? items.Count - 2 : items.Count - 1;`
`106`	`107`
`107`	`108`	`if (!string.IsNullOrEmpty(prefix))`
`108`	`109`	`{`
`109`		`- items[lastItemIndex] = prefix + Utils.UpperFirstChar(items.Last());`
	`110`	`+ items[lastItemIndex] = prefix + Utils.UpperFirstChar(items[lastItemIndex]);`
`110`	`111`	`}`
`111`	`112`	`else`
`112`	`113`	`{`
`113`		`- items[lastItemIndex] = Utils.UpperFirstChar(items.Last());`
	`114`	`+ items[lastItemIndex] = Utils.UpperFirstChar(items[lastItemIndex]);`
`114`	`115`	`}`
`115`	`116`
`116`		`- return string.Join(".", items);`
	`117`	`+ return GenerateNavigationPropertyPathOperationId(items);`
`117`	`118`	`}`
`118`	`119`
`119`	`120`	`/// <summary>`
`120`	`121`	`/// Generates the operation id from a complex property path.`
`121`	`122`	`/// </summary>`
`122`	`123`	`/// <param name="path">The target <see cref="ODataPath"/>.</param>`
	`124`	`+ /// <param name="context">The OData context.</param>`
`123`	`125`	`/// <param name="prefix">Optional: Identifier indicating whether it is a collection-valued or single-valued complex property.</param>`
`124`	`126`	`/// <returns>The operation id generated from the given complex property path.</returns>`
`125`		`- internal static string GenerateComplexPropertyPathOperationId(ODataPath path, string prefix = null)`
	`127`	`+ internal static string GenerateComplexPropertyPathOperationId(ODataPath path, ODataContext context, string prefix = null)`
`126`	`128`	`{`
`127`		`- IList<string> items = RetrieveNavigationPropertyPathsOperationIdSegments(path);`
	`129`	`+ IList<string> items = RetrieveNavigationPropertyPathsOperationIdSegments(path, context);`
`128`	`130`
`129`	`131`	`if (!items.Any())`
`130`	`132`	`return null;`
`@@ -141,15 +143,29 @@ internal static string GenerateComplexPropertyPathOperationId(ODataPath path, st`
`141`	`143`	`items.Add(Utils.UpperFirstChar(lastSegment?.Identifier));`
`142`	`144`	`}`
`143`	`145`
`144`		`- return string.Join(".", items);`
	`146`	`+ return GenerateNavigationPropertyPathOperationId(items);`
	`147`	`+ }`
	`148`	`+`
	`149`	`+ /// <summary>`
	`150`	`+ /// Generates a navigation property operation id from a list of string values.`
	`151`	`+ /// </summary>`
	`152`	`+ /// <param name="items">The list of string values.</param>`
	`153`	`+ /// <returns>The generated navigation property operation id.</returns>`
	`154`	`+ private static string GenerateNavigationPropertyPathOperationId(IList<string> items)`
	`155`	`+ {`
	`156`	`+ if (!items.Any())`
	`157`	`+ return null;`
	`158`	`+`
	`159`	`+ return string.Join(".", items).Replace(".-", "-", StringComparison.OrdinalIgnoreCase); // Format any hashed value appropriately (this will be the last value)`
`145`	`160`	`}`
`146`	`161`
`147`	`162`	`/// <summary>`
`148`	`163`	`/// Retrieves the segments of an operation id generated from a navigation property path.`
`149`	`164`	`/// </summary>`
`150`	`165`	`/// <param name="path">The target <see cref="ODataPath"/>.</param>`
	`166`	`+ /// <param name="context">The OData context.</param>`
`151`	`167`	`/// <returns>The segments of an operation id generated from the given navigation property path.</returns>`
`152`		`- internal static IList<string> RetrieveNavigationPropertyPathsOperationIdSegments(ODataPath path)`
	`168`	`+ internal static IList<string> RetrieveNavigationPropertyPathsOperationIdSegments(ODataPath path, ODataContext context)`
`153`	`169`	`{`
`154`	`170`	`Utils.CheckArgumentNull(path, nameof(path));`
`155`	`171`
`@@ -173,6 +189,8 @@ s is ODataOperationSegment \|\|`
`173`	`189`	`Utils.CheckArgumentNull(segments, nameof(segments));`
`174`	`190`
`175`	`191`	`string previousTypeCastSegmentId = null;`
	`192`	`+ string pathHash = string.Empty;`
	`193`	`+`
`176`	`194`	`foreach (var segment in segments)`
`177`	`195`	`{`
`178`	`196`	`if (segment is ODataNavigationPropertySegment navPropSegment)`
`@@ -192,6 +210,14 @@ s is ODataOperationSegment \|\|`
`192`	`210`	`else if (segment is ODataOperationSegment operationSegment)`
`193`	`211`	`{`
`194`	`212`	`// Navigation property generated via composable function`
	`213`	`+ if (operationSegment.Operation is IEdmFunction function && context.Model.IsOperationOverload(function))`
	`214`	`+ {`
	`215`	`+ // Hash the segment to avoid duplicate operationIds`
	`216`	`+ pathHash = string.IsNullOrEmpty(pathHash)`
	`217`	`+ ? operationSegment.GetPathHash(context.Settings)`
	`218`	`+ : (pathHash + operationSegment.GetPathHash(context.Settings)).GetHashSHA256()[..4];`
	`219`	`+ }`
	`220`	`+`
`195`	`221`	`items.Add(operationSegment.Identifier);`
`196`	`222`	`}`
`197`	`223`	`else if (segment is ODataKeySegment keySegment && keySegment.IsAlternateKey)`
`@@ -208,6 +234,11 @@ s is ODataOperationSegment \|\|`
`208`	`234`	`}`
`209`	`235`	`}`
`210`	`236`
	`237`	`+ if (!string.IsNullOrEmpty(pathHash))`
	`238`	`+ {`
	`239`	`+ items.Add("-" + pathHash);`
	`240`	`+ }`
	`241`	`+`
`211`	`242`	`return items;`
`212`	`243`	`}`
`213`	`244`
`@@ -320,9 +351,10 @@ internal static string GenerateComplexPropertyPathTagName(ODataPath path, ODataC`
`320`	`351`	`/// Generates the operation id prefix from an OData type cast path.`
`321`	`352`	`/// </summary>`
`322`	`353`	`/// <param name="path">The target <see cref="ODataPath"/>.</param>`
	`354`	`+ /// <param name="context">The OData context.</param>`
`323`	`355`	`/// <param name="includeListOrGetPrefix">Optional: Whether to include the List or Get prefix to the generated operation id.</param>`
`324`	`356`	`/// <returns>The operation id prefix generated from the OData type cast path.</returns>`
`325`		`- internal static string GenerateODataTypeCastPathOperationIdPrefix(ODataPath path, bool includeListOrGetPrefix = true)`
	`357`	`+ internal static string GenerateODataTypeCastPathOperationIdPrefix(ODataPath path, ODataContext context, bool includeListOrGetPrefix = true)`
`326`	`358`	`{`
`327`	`359`	`// Get the segment before the last OData type cast segment`
`328`	`360`	`ODataTypeCastSegment typeCastSegment = path.Segments.OfType<ODataTypeCastSegment>()?.Last();`
`@@ -352,7 +384,7 @@ internal static string GenerateODataTypeCastPathOperationIdPrefix(ODataPath path`
`352`	`384`	`if (secondLastSegment is ODataComplexPropertySegment complexSegment)`
`353`	`385`	`{`
`354`	`386`	`string listOrGet = includeListOrGetPrefix ? (complexSegment.Property.Type.IsCollection() ? "List" : "Get") : null;`
`355`		`- operationId = GenerateComplexPropertyPathOperationId(path, listOrGet);`
	`387`	`+ operationId = GenerateComplexPropertyPathOperationId(path, context, listOrGet);`
`356`	`388`	`}`
`357`	`389`	`else if (secondLastSegment is ODataNavigationPropertySegment navPropSegment)`
`358`	`390`	`{`
`@@ -362,13 +394,13 @@ internal static string GenerateODataTypeCastPathOperationIdPrefix(ODataPath path`
`362`	`394`	`prefix = navPropSegment?.NavigationProperty.TargetMultiplicity() == EdmMultiplicity.Many ? "List" : "Get";`
`363`	`395`	`}`
`364`	`396`
`365`		`- operationId = GenerateNavigationPropertyPathOperationId(path, prefix);`
	`397`	`+ operationId = GenerateNavigationPropertyPathOperationId(path, context, prefix);`
`366`	`398`	`}`
`367`	`399`	`else if (secondLastSegment is ODataKeySegment keySegment)`
`368`	`400`	`{`
`369`	`401`	`if (isIndexedCollValuedNavProp)`
`370`	`402`	`{`
`371`		`- operationId = GenerateNavigationPropertyPathOperationId(path, "Get");`
	`403`	`+ operationId = GenerateNavigationPropertyPathOperationId(path, context, "Get");`
`372`	`404`	`}`
`373`	`405`	`else`
`374`	`406`	`{`
Original file line number	Diff line number	Diff line change
`@@ -39,7 +39,7 @@ protected override void SetBasicInfo(OpenApiOperation operation)`
`39`	`39`	`if (Context.Settings.EnableOperationId)`
`40`	`40`	`{`
`41`	`41`	`string prefix = ComplexPropertySegment.Property.Type.IsCollection() ? "List" : "Get";`
`42`		`- operation.OperationId = EdmModelHelper.GenerateComplexPropertyPathOperationId(Path, prefix);`
	`42`	`+ operation.OperationId = EdmModelHelper.GenerateComplexPropertyPathOperationId(Path, Context, prefix);`
`43`	`43`	`}`
`44`	`44`
`45`	`45`	`// Summary and Description`
Original file line number	Diff line number	Diff line change
`@@ -42,7 +42,7 @@ protected override void SetBasicInfo(OpenApiOperation operation)`
`42`	`42`	`// OperationId`
`43`	`43`	`if (Context.Settings.EnableOperationId)`
`44`	`44`	`{`
`45`		`- operation.OperationId = EdmModelHelper.GenerateComplexPropertyPathOperationId(Path, "Set");`
	`45`	`+ operation.OperationId = EdmModelHelper.GenerateComplexPropertyPathOperationId(Path, Context, "Set");`
`46`	`46`	`}`
`47`	`47`
`48`	`48`	`// Summary and Description`
Original file line number	Diff line number	Diff line change
`@@ -40,7 +40,7 @@ protected override void SetBasicInfo(OpenApiOperation operation)`
`40`	`40`	`// OperationId`
`41`	`41`	`if (Context.Settings.EnableOperationId)`
`42`	`42`	`{`
`43`		`- operation.OperationId = EdmModelHelper.GenerateComplexPropertyPathOperationId(Path, "Update");`
	`43`	`+ operation.OperationId = EdmModelHelper.GenerateComplexPropertyPathOperationId(Path, Context, "Update");`
`44`	`44`	`}`
`45`	`45`	`}`
`46`	`46`
Original file line number	Diff line number	Diff line change
`@@ -128,17 +128,17 @@ protected override void SetBasicInfo(OpenApiOperation operation)`
`128`	`128`	`}`
`129`	`129`	`else if (SecondLastSegment is ODataNavigationPropertySegment)`
`130`	`130`	`{`
`131`		`- var navPropOpId = string.Join(".", EdmModelHelper.RetrieveNavigationPropertyPathsOperationIdSegments(Path));`
	`131`	`+ var navPropOpId = string.Join(".", EdmModelHelper.RetrieveNavigationPropertyPathsOperationIdSegments(Path, Context));`
`132`	`132`	`operation.OperationId = $"{navPropOpId}.GetCount-{Path.GetPathHash(Context.Settings)}";`
`133`	`133`	`}`
`134`	`134`	`else if (SecondLastSegment is ODataTypeCastSegment odataTypeCastSegment)`
`135`	`135`	`{`
`136`	`136`	`IEdmNamedElement targetStructuredType = odataTypeCastSegment.StructuredType as IEdmNamedElement;`
`137`		`- operation.OperationId = $"{EdmModelHelper.GenerateODataTypeCastPathOperationIdPrefix(Path, false)}.GetCount.As{Utils.UpperFirstChar(targetStructuredType.Name)}-{Path.GetPathHash(Context.Settings)}";`
	`137`	`+ operation.OperationId = $"{EdmModelHelper.GenerateODataTypeCastPathOperationIdPrefix(Path, Context, false)}.GetCount.As{Utils.UpperFirstChar(targetStructuredType.Name)}-{Path.GetPathHash(Context.Settings)}";`
`138`	`138`	`}`
`139`	`139`	`else if (SecondLastSegment is ODataComplexPropertySegment)`
`140`	`140`	`{`
`141`		`- operation.OperationId = $"{EdmModelHelper.GenerateComplexPropertyPathOperationId(Path)}.GetCount-{Path.GetPathHash(Context.Settings)}";`
	`141`	`+ operation.OperationId = $"{EdmModelHelper.GenerateComplexPropertyPathOperationId(Path, Context)}.GetCount-{Path.GetPathHash(Context.Settings)}";`
`142`	`142`	`}`
`143`	`143`	`}`
`144`	`144`
Original file line number	Diff line number	Diff line change
`@@ -107,7 +107,7 @@ protected override void SetExtensions(OpenApiOperation operation)`
`107`	`107`
`108`	`108`	`internal string GetOperationId(string prefix = null)`
`109`	`109`	`{`
`110`		`- return EdmModelHelper.GenerateNavigationPropertyPathOperationId(Path, prefix);`
	`110`	`+ return EdmModelHelper.GenerateNavigationPropertyPathOperationId(Path, Context, prefix);`
`111`	`111`	`}`
`112`	`112`
`113`	`113`	`/// <inheritdoc/>`
Original file line number	Diff line number	Diff line change
`@@ -188,7 +188,7 @@ protected override void SetBasicInfo(OpenApiOperation operation)`
`188`	`188`
`189`	`189`	`// OperationId`
`190`	`190`	`if (Context.Settings.EnableOperationId)`
`191`		`- operation.OperationId = EdmModelHelper.GenerateODataTypeCastPathOperationIdPrefix(Path) + $".As{Utils.UpperFirstChar(TargetSchemaElement.Name)}";`
	`191`	`+ operation.OperationId = EdmModelHelper.GenerateODataTypeCastPathOperationIdPrefix(Path, Context) + $".As{Utils.UpperFirstChar(TargetSchemaElement.Name)}";`
`192`	`192`
`193`	`193`	`base.SetBasicInfo(operation);`
`194`	`194`	`}`