Transformation of routes fails, when duplicate Upstream paths (via wildcard) are specified

[Salatbesteck]

When the Ocelot configuration includes both a wildcard route, such as /{everything}, and a dedicated route pointing to the same path, the route transformer fails. Instead of showing the correctly transformed downstream route, it displays the untransformed route.

Expected behaviour
The transformation should be applied and shown in Swagger UI.

To Reproduce
Use the following Ocelot ReRoutes configuration.

{
  "Routes": [
    {
      "DownstreamPathTemplate": "/api/Version/GetBEVersion",
      "DownstreamScheme": "https",
      "UpstreamPathTemplate": "/mvda/version",
      "UpstreamHttpMethod": [ "Get" ],
      "ServiceName": "MVDA",
      "SwaggerKey": "MVDA",
      "Key": "MVDAVersion"
    },
    {
      "UpstreamHttpMethod": [ "GET", "OPTIONS", "POST", "PUT", "DELETE" ],
      "UpstreamPathTemplate": "/mvda/{everything}",
      "DownstreamPathTemplate": "/api/{everything}",
      "DownstreamScheme": "https",
      "AddHeadersToRequest": {
        "Authorization": "{Authorization}"
      },
      "ServiceName": "MVDA",
      "SwaggerKey": "MVDA"
    }
  ]
}

In order to fix this issue the transformer function could be modifed as following:

private void RenameAndRemovePaths(IEnumerable<RouteOptions> routes, JToken paths, string basePath)
 {
     var oldPaths = new List<JProperty>();
     var newPaths = new Dictionary<string, JProperty>(StringComparer.OrdinalIgnoreCase);
     for (int i = 0; i < paths.Count(); i++)
     {
         var oldPath = paths.ElementAt(i) as JProperty;
         oldPaths.Add(oldPath);
         string downstreamPath = oldPath.Name.RemoveSlashFromEnd();
         foreach (var tmpMethod in oldPath.First)
         {
             var method = tmpMethod as JProperty;
             List<RouteOptions> matchedRoutes = FindRoutes(routes, oldPath.Name.WithSlashEnding(), [method.Name](http://method.name/), basePath);
             foreach (var route in matchedRoutes)
             {
                 string newPath = ConvertDownstreamPathToUpstreamPath(
                     downstreamPath, route.DownstreamPath, route.UpstreamPath, basePath);
                 if (!newPaths.TryGetValue(newPath, out JProperty newPathJson))
                 {
                     newPathJson = new JProperty(newPath, new JObject());
                     newPaths.Add(newPath, newPathJson);
                 }
                 var newMethod = (method.DeepClone() as JProperty);
                 AddSecurityDefinition(newMethod, route);
                 if (!((JObject)newPathJson.Value).TryGetValue([newMethod.Name](http://newmethod.name/), out JToken value))
                 {
                     ((JObject)newPathJson.Value).Add(newMethod);
                 }
             }
         }
     }

     oldPaths.ForEach(oldPath => oldPath.Remove());
     newPaths.Select(item => item.Value)
         .OrderBy(newPath => [newPath.Name](http://newpath.name/))
         .ForEach(newPath => ((JObject)paths).Add(newPath));
 }

[makomkubiak]

Hello, are there any news on this issue? We are having the same problem, it was introduced in version 8.1.0 and we have not updated the package ever since in order not to break swagger functionality. Just to clarify and add to the context, in our case "normal" methods are being matched against "wildcard" ones. So for instance a very simple route /api/test/healthcheck will match also the "generic" route /api/test/{everything} under the name /api/test/healthcheck. And then this line ((JObject)newPathJson.Value).Add(newMethod); fails since it already has route with the same name.

Best Regards