Enhanced NotEqual expression support

Added support for `NotEqual` expressions in `ContentItemQueryExpressionVisitor` within the `XperienceCommunity.DataContext` namespace, enabling the handling of various right-hand expression types such as `ConstantExpression`, `MemberExpression`, `UnaryExpression`, and `MethodCallExpression`. Improved code readability by modifying the `GetMemberValue` method call to span two lines. Introduced a new method `ProcessNotEquality` for robust processing of `NotEqual` binary expressions, supporting diverse expression types and enhancing query capabilities with negation conditions. This update ensures better error handling by throwing `NotSupportedException` for unsupported expression types.

src/XperienceCommunity.DataContext/ContentItemQueryExpressionVisitor.cs

@@ -24,6 +24,10 @@ protected override Expression VisitBinary(BinaryExpression node)
                     ProcessEquality(node);
                     break;
 
+                case ExpressionType.NotEqual:
+                    ProcessNotEquality(node);
+                    break;
+
                 case ExpressionType.GreaterThan:
                     ProcessComparison(node, isGreaterThan: true);
                     break;
@@ -128,7 +132,6 @@ protected override Expression VisitUnary(UnaryExpression node)
             return node;
         }
 
-
         private static object? GetMemberValue(Expression expression)
         {
             switch (expression)
@@ -138,7 +141,8 @@ protected override Expression VisitUnary(UnaryExpression node)
 
                 case MemberExpression memberExpression:
                     var member = memberExpression.Member;
-                    var objectValue = GetMemberValue(memberExpression.Expression!); // Recursively process the expression
+                    var objectValue =
+                        GetMemberValue(memberExpression.Expression!); // Recursively process the expression
 
                     if (objectValue == null)
                         throw new InvalidOperationException("The target object for the member expression is null.");
@@ -408,6 +412,48 @@ private void ProcessLogicalOr(BinaryExpression node)
             Visit(node.Right);
         }
 
+        private void ProcessNotEquality(BinaryExpression node)
+        {
+            if (node.Left is MemberExpression left)
+            {
+                if (node.Right is ConstantExpression right)
+                {
+                    _queryParameters.Where(where => where.WhereNotEquals(left.Member.Name, right.Value));
+                }
+                else if (node.Right is MemberExpression rightMember)
+                {
+                    _queryParameters.Where(where =>
+                        where.WhereNotEquals(left.Member.Name, GetMemberValue(rightMember)));
+                }
+                else if (node.Right is UnaryExpression rightUnary && rightUnary.NodeType == ExpressionType.Convert)
+                {
+                    var value = GetMemberValue(rightUnary.Operand);
+                    _queryParameters.Where(where => where.WhereNotEquals(left.Member.Name, value));
+                }
+                else if (node.Right is MethodCallExpression rightMethod)
+                {
+                    var value = GetMethodCallValue(rightMethod);
+                    _queryParameters.Where(where => where.WhereNotEquals(left.Member.Name, value));
+                }
+                else
+                {
+                    throw new NotSupportedException(
+                        $"The right expression type '{node.Right.GetType().Name}' is not supported.");
+                }
+            }
+            else if (node.Left is MethodCallExpression leftMethod && node.Right is ConstantExpression rightConst)
+            {
+                var value = GetMethodCallValue(leftMethod);
+
+                _queryParameters.Where(where => where.WhereNotEquals(value?.ToString(), rightConst.Value));
+            }
+            else
+            {
+                throw new NotSupportedException(
+                    $"The left expression type '{node.Left.GetType().Name}' is not supported.");
+            }
+        }
+
         private void ProcessStringContains(MethodCallExpression node)
         {
             if (node.Object is MemberExpression member && node.Arguments[0] is ConstantExpression constant)