Fix failure on REST requests with $filter and $orderby parameters (#3664)

## Why make this change?

- Fix issue #3662

This issue is caused by a regression in PR
#3080
The regression is that we start using the raw encoded URL and we assume
that the `$` character is not encoded when using the
`ExtractRawQueryParameter` function, this is half true, since depending
on where the URL comes from it will encode it or it will treat it as a
special character and leave it as it is.
This means the function looks for the `$filter` or `$orderby` when the
URL has the possibility to change them to `%24filter` or `%24orderby`
which causes the failure.

## What is this change?

This change fixes a bug that caused using `$filter` or `$orderby` in
REST. This is done by encoding the `parameterName` so that it has the
same format as the raw URL, it will only change it if it is unable to
find the original `$` character in the raw query.

## How was this tested?

- [ ] Integration Tests
- [x] Unit Tests
Added end to end test to ensure that REST requests that use `$filter`
and `$orderby` succeed for both cases where a user uses the special
character `$` or its URL encoded format `%24`.

## Sample Request(s)
http://localhost:5000/api/Book?$orderby=id desc
http://localhost:5000/api/Book?$filter=publisher_id 1234

Author: RubenCerna2079

src/Core/Parsers/RequestParser.cs

@@ -2,6 +2,7 @@
 // Licensed under the MIT License.
 
 using System.Net;
+using System.Web;
 using Azure.DataApiBuilder.Core.Models;
 using Azure.DataApiBuilder.Core.Services;
 using Azure.DataApiBuilder.Service.Exceptions;
@@ -321,6 +322,12 @@ private static bool IsNull(string value)
                 return null;
             }
 
+            // Encode the parameterName to ensure it matches the encoding in the query string if the $ sign is URL encoded.
+            if (!queryString.Contains(parameterName, StringComparison.OrdinalIgnoreCase))
+            {
+                parameterName = HttpUtility.UrlEncode(parameterName);
+            }
+
             // Split on '&' which are parameter separators in properly URL-encoded query strings.
             // Any '&' characters within parameter values will be encoded as %26.
             foreach (string param in queryString.TrimStart('?').Split('&'))

src/Service.Tests/Configuration/ConfigurationTests.cs

@@ -4224,6 +4224,47 @@ public async Task OpenApi_InteractiveSwaggerUI(
             }
         }
 
+        /// <summary>
+        /// End to end test that validates that REST requests with OData query
+        /// options $filter and $orderby succeed to ensure no regression can occur.
+        /// </summary>
+        [DataTestMethod]
+        [DataRow("/api/Book?$orderby=id desc&$filter=publisher_id eq 1234", DisplayName = "REST URL without encoded characters")]
+        [DataRow("/api/Book?%24orderby=id%20desc&%24filter=publisher_id%20eq%201234", DisplayName = "REST URL with encoded characters")]
+        [TestCategory(TestCategory.MSSQL)]
+        public async Task TestForRestRequestsWithFilterAndOrderbyParameters(string restUri)
+        {
+            // The configuration file is constructed by merging hard-coded JSON strings to simulate the scenario where users manually edit the
+            // configuration file (instead of using CLI).
+            string configJson = TestHelper.AddPropertiesToJson(TestHelper.BASE_CONFIG, BOOK_ENTITY_JSON);
+            Assert.IsTrue(RuntimeConfigLoader.TryParseConfig(
+                configJson,
+                out RuntimeConfig deserializedConfig,
+                replacementSettings: new(),
+                connectionString: GetConnectionStringFromEnvironmentConfig(environment: TestCategory.MSSQL)));
+            string configFileName = "custom-config.json";
+            File.WriteAllText(configFileName, deserializedConfig.ToJson());
+            string[] args = new[]
+            {
+                    $"--ConfigFileName={configFileName}"
+            };
+
+            using (TestServer server = new(Program.CreateWebHostBuilder(args)))
+            using (HttpClient client = server.CreateClient())
+            {
+                // Act
+                using HttpRequestMessage restRequest = new(HttpMethod.Get, restUri);
+                using HttpResponseMessage restResponse = await client.SendAsync(restRequest);
+
+                // Assert - Verify REST response
+                Assert.AreEqual(HttpStatusCode.OK, restResponse.StatusCode, "REST request to auto-generated entity should succeed");
+
+                string restResponseBody = await restResponse.Content.ReadAsStringAsync();
+                Assert.IsTrue(!string.IsNullOrEmpty(restResponseBody), "REST response should contain data");
+                Assert.IsTrue(restResponseBody.Contains("\"publisher_id\":1234"));
+            }
+        }
+
         /// <summary>
         /// Test different loglevel values that are avaliable by deserializing RuntimeConfig with specified LogLevel
         /// and checks if value exists properly inside the deserialized RuntimeConfig.