feat: Add LINQ filtering support to BingTextSearch

- Implement equality (==), inequality (!=), Contains(), and AND (&&) operators
- Map LINQ expressions to Bing Web Search API advanced operators
- Support negation syntax for inequality (-operator:value)
- Maintain full backward compatibility

Addresses #10456
Aligns with PR #10273

Tests: 38/38 pass (100%)
Breaking changes: None

Author: alzarei

dotnet/src/Plugins/Plugins.Web/Bing/BingTextSearch.cs

@@ -134,39 +134,168 @@ private static TextSearchOptions ConvertToLegacyOptions(TextSearchOptions<BingWe
 
     /// <summary>
     /// Converts a LINQ expression to a TextSearchFilter compatible with Bing API.
-    /// Only supports simple property equality expressions that map to Bing's filter capabilities.
+    /// Supports equality, inequality, Contains() method calls, and logical AND operator.
     /// </summary>
     /// <param name="linqExpression">The LINQ expression to convert.</param>
     /// <returns>A TextSearchFilter with equivalent filtering.</returns>
     /// <exception cref="NotSupportedException">Thrown when the expression cannot be converted to Bing filters.</exception>
     private static TextSearchFilter ConvertLinqExpressionToBingFilter<TRecord>(Expression<Func<TRecord, bool>> linqExpression)
     {
-        if (linqExpression.Body is BinaryExpression binaryExpr && binaryExpr.NodeType == ExpressionType.Equal)
+        var filter = new TextSearchFilter();
+        ProcessExpression(linqExpression.Body, filter);
+        return filter;
+    }
+
+    /// <summary>
+    /// Recursively processes LINQ expression nodes and builds Bing API filters.
+    /// </summary>
+    private static void ProcessExpression(Expression expression, TextSearchFilter filter)
+    {
+        switch (expression)
+        {
+            case BinaryExpression binaryExpr when binaryExpr.NodeType == ExpressionType.AndAlso:
+                // Handle AND: page => page.Language == "en" && page.Name.Contains("AI")
+                ProcessExpression(binaryExpr.Left, filter);
+                ProcessExpression(binaryExpr.Right, filter);
+                break;
+
+            case BinaryExpression binaryExpr when binaryExpr.NodeType == ExpressionType.OrElse:
+                // Handle OR: Currently not directly supported by TextSearchFilter
+                // Bing API supports OR via multiple queries, but TextSearchFilter doesn't expose this
+                throw new NotSupportedException(
+                    "Logical OR (||) is not supported by Bing Text Search filters. " +
+                    "Consider splitting into multiple search queries.");
+
+            case UnaryExpression unaryExpr when unaryExpr.NodeType == ExpressionType.Not:
+                // Handle NOT: page => !page.Language.Equals("en")
+                throw new NotSupportedException(
+                    "Logical NOT (!) is not directly supported by Bing Text Search advanced operators. " +
+                    "Consider restructuring your filter to use positive conditions.");
+
+            case BinaryExpression binaryExpr when binaryExpr.NodeType == ExpressionType.Equal:
+                // Handle equality: page => page.Language == "en"
+                ProcessEqualityExpression(binaryExpr, filter, isNegated: false);
+                break;
+
+            case BinaryExpression binaryExpr when binaryExpr.NodeType == ExpressionType.NotEqual:
+                // Handle inequality: page => page.Language != "en"
+                // Implemented via Bing's negation syntax (e.g., -language:en)
+                ProcessEqualityExpression(binaryExpr, filter, isNegated: true);
+                break;
+
+            case MethodCallExpression methodExpr when methodExpr.Method.Name == "Contains":
+                // Handle Contains: page => page.Name.Contains("Microsoft")
+                ProcessContainsExpression(methodExpr, filter);
+                break;
+
+            default:
+                throw new NotSupportedException(
+                    $"Expression type '{expression.NodeType}' is not supported for Bing API filters. " +
+                    "Supported patterns: equality (==), inequality (!=), Contains(), and logical AND (&&). " +
+                    "Available Bing operators: " + string.Join(", ", s_advancedSearchKeywords));
+        }
+    }
+
+    /// <summary>
+    /// Processes equality and inequality expressions (property == value or property != value).
+    /// </summary>
+    /// <param name="binaryExpr">The binary expression to process.</param>
+    /// <param name="filter">The filter to update.</param>
+    /// <param name="isNegated">True if this is an inequality (!=) expression.</param>
+    private static void ProcessEqualityExpression(BinaryExpression binaryExpr, TextSearchFilter filter, bool isNegated)
+    {
+        if (binaryExpr.Left is MemberExpression memberExpr && binaryExpr.Right is ConstantExpression constExpr)
         {
-            // Handle simple equality: record.PropertyName == "value"
-            if (binaryExpr.Left is MemberExpression memberExpr && binaryExpr.Right is ConstantExpression constExpr)
+            string propertyName = memberExpr.Member.Name;
+            object? value = constExpr.Value;
+
+            string? bingFilterName = MapPropertyToBingFilter(propertyName);
+            if (bingFilterName != null && value != null)
+            {
+                if (isNegated)
+                {
+                    // For inequality, use Bing's negation syntax by prepending '-' to the filter name
+                    // Example: -language:en excludes pages in English
+                    filter.Equality($"-{bingFilterName}", value);
+                }
+                else
+                {
+                    filter.Equality(bingFilterName, value);
+                }
+            }
+            else if (value == null)
+            {
+                throw new NotSupportedException(
+                    $"Null values are not supported in Bing API filters for property '{propertyName}'.");
+            }
+            else
+            {
+                throw new NotSupportedException(
+                    $"Property '{propertyName}' cannot be mapped to Bing API filters. " +
+                    "Supported properties: Language, Url, DisplayUrl, Name, Snippet, IsFamilyFriendly.");
+            }
+        }
+        else
+        {
+            throw new NotSupportedException(
+                "Equality expressions must be in the form 'property == value' or 'property != value'. " +
+                "Complex expressions on the left or right side are not supported.");
+        }
+    }
+
+    /// <summary>
+    /// Processes Contains() method calls on string properties.
+    /// Maps to Bing's advanced search operators like intitle:, inbody:, url:.
+    /// </summary>
+    private static void ProcessContainsExpression(MethodCallExpression methodExpr, TextSearchFilter filter)
+    {
+        // Contains can be called on a property: page.Name.Contains("value")
+        // or on a collection: page.Tags.Contains("value")
+
+        if (methodExpr.Object is MemberExpression memberExpr)
+        {
+            string propertyName = memberExpr.Member.Name;
+
+            // Extract the search value from the Contains() argument
+            if (methodExpr.Arguments.Count == 1 && methodExpr.Arguments[0] is ConstantExpression constExpr)
             {
-                string propertyName = memberExpr.Member.Name;
                 object? value = constExpr.Value;
+                if (value == null)
+                {
+                    return; // Skip null values
+                }
 
-                // Map BingWebPage properties to Bing API filter names
-                string? bingFilterName = MapPropertyToBingFilter(propertyName);
-                if (bingFilterName != null && value != null)
+                // Map property to Bing filter with Contains semantic
+                string? bingFilterOperator = MapPropertyToContainsFilter(propertyName);
+                if (bingFilterOperator != null)
+                {
+                    // Use Bing's advanced search syntax: intitle:"value", inbody:"value", etc.
+                    filter.Equality(bingFilterOperator, value);
+                }
+                else
                 {
-                    return new TextSearchFilter().Equality(bingFilterName, value);
+                    throw new NotSupportedException(
+                        $"Contains() on property '{propertyName}' is not supported by Bing API filters. " +
+                        "Supported properties for Contains: Name (maps to intitle:), Snippet (maps to inbody:), Url (maps to url:).");
                 }
             }
+            else
+            {
+                throw new NotSupportedException(
+                    "Contains() must have a single constant value argument. " +
+                    "Complex expressions as arguments are not supported.");
+            }
+        }
+        else
+        {
+            throw new NotSupportedException(
+                "Contains() must be called on a property (e.g., page.Name.Contains(\"value\")). " +
+                "Collection Contains patterns are not yet supported.");
         }
-
-        throw new NotSupportedException(
-            "LINQ expression '" + linqExpression + "' cannot be converted to Bing API filters. " +
-            "Only simple equality expressions like 'page => page.Language == \"en\"' are supported, " +
-            "and only for properties that map to Bing API parameters: " +
-            string.Join(", ", s_queryParameters.Concat(s_advancedSearchKeywords)));
     }
 
     /// <summary>
-    /// Maps BingWebPage property names to Bing API filter field names.
+    /// Maps BingWebPage property names to Bing API filter field names for equality operations.
     /// </summary>
     /// <param name="propertyName">The BingWebPage property name.</param>
     /// <returns>The corresponding Bing API filter name, or null if not mappable.</returns>
@@ -180,16 +309,35 @@ private static TextSearchFilter ConvertLinqExpressionToBingFilter<TRecord>(Expre
             "DISPLAYURL" => "site",            // Maps to site: search
             "NAME" => "intitle",               // Maps to title search
             "SNIPPET" => "inbody",             // Maps to body content search
+            "ISFAMILYFRIENDLY" => "safeSearch", // Maps to safe search parameter
 
             // Direct API parameters (if we ever extend BingWebPage with metadata)
             "MKT" => "mkt",                    // Market/locale
             "FRESHNESS" => "freshness",        // Date freshness
-            "SAFESEARCH" => "safeSearch",      // Safe search setting
 
             _ => null // Property not mappable to Bing filters
         };
     }
 
+    /// <summary>
+    /// Maps BingWebPage property names to Bing API advanced search operators for Contains operations.
+    /// </summary>
+    /// <param name="propertyName">The BingWebPage property name.</param>
+    /// <returns>The corresponding Bing advanced search operator, or null if not mappable.</returns>
+    private static string? MapPropertyToContainsFilter(string propertyName)
+    {
+        return propertyName.ToUpperInvariant() switch
+        {
+            // Map properties to Bing's contains-style operators
+            "NAME" => "intitle",        // intitle:"search term" - title contains
+            "SNIPPET" => "inbody",      // inbody:"search term" - body contains
+            "URL" => "url",             // url:"search term" - URL contains
+            "DISPLAYURL" => "site",     // site:domain.com - site contains
+
+            _ => null // Property not mappable to Contains-style filters
+        };
+    }
+
     /// <summary>
     /// Execute a Bing search query and return the results.
     /// </summary>