From 39417b00e3f7798c6878e9da9a9041b5f010b3d4 Mon Sep 17 00:00:00 2001
From: Brandon Henricks <78803523+bluemodus-brandon@users.noreply.github.com>
Date: Thu, 11 Jul 2024 22:57:36 -0400
Subject: [PATCH] Enhance expression handling and refactoring

Refactored `ContentItemQueryExpressionVisitor.cs` to make `ExtractFieldValues` and `GetExpressionValue` methods static, improving design by eliminating the need for class instances for these operations. Added multiple new methods and `using` directives in `ExpressionExtensions.cs` to expand expression handling capabilities, including reflection and collection processing. Introduced utility methods for more efficient and flexible value extraction from expressions, supporting a variety of types and scenarios. These changes significantly enhance the utility and maintainability of the `XperienceCommunity.DataContext` namespace, making the data context more dynamic and capable of handling a broader range of data manipulation and querying scenarios.
---
 .../ContentItemQueryExpressionVisitor.cs      |   4 +-
 .../Extensions/ExpressionExtensions.cs        | 120 +++++++++++++++++-
 2 files changed, 121 insertions(+), 3 deletions(-)

diff --git a/src/XperienceCommunity.DataContext/ContentItemQueryExpressionVisitor.cs b/src/XperienceCommunity.DataContext/ContentItemQueryExpressionVisitor.cs
index 5f6c3d0..18d3926 100644
--- a/src/XperienceCommunity.DataContext/ContentItemQueryExpressionVisitor.cs
+++ b/src/XperienceCommunity.DataContext/ContentItemQueryExpressionVisitor.cs
@@ -308,13 +308,13 @@ private void AddWhereInCondition(string columnName, IEnumerable<object>? values)
             return null;
         }
 
-        private IEnumerable<object> ExtractFieldValues(MemberExpression fieldExpression)
+        private static IEnumerable<object> ExtractFieldValues(MemberExpression fieldExpression)
         {
             var value = GetExpressionValue(fieldExpression);
             return ExtractValues(value);
         }
 
-        private object? GetExpressionValue(Expression expression)
+        private static object? GetExpressionValue(Expression expression)
         {
             switch (expression)
             {
diff --git a/src/XperienceCommunity.DataContext/Extensions/ExpressionExtensions.cs b/src/XperienceCommunity.DataContext/Extensions/ExpressionExtensions.cs
index 0c28aa4..1008259 100644
--- a/src/XperienceCommunity.DataContext/Extensions/ExpressionExtensions.cs
+++ b/src/XperienceCommunity.DataContext/Extensions/ExpressionExtensions.cs
@@ -1,9 +1,72 @@
-using System.Linq.Expressions;
+using System.Collections;
+using System.Linq.Expressions;
+using System.Reflection;
 
 namespace XperienceCommunity.DataContext.Extensions
 {
     internal static class ExpressionExtensions
     {
+        /// <summary>
+        /// Extracts the values from a collection expression.
+        /// </summary>
+        /// <param name="collectionExpression">The collection expression.</param>
+        /// <returns>The extracted values as an enumerable of objects.</returns>
+        internal static IEnumerable<object>? ExtractCollectionValues(this MemberExpression collectionExpression)
+        {
+            if (collectionExpression.Expression != null)
+            {
+                var value = GetExpressionValue(collectionExpression.Expression);
+
+                return ExtractValues(value);
+            }
+
+            return null;
+        }
+
+        /// <summary>
+        /// Extracts the values from a field expression.
+        /// </summary>
+        /// <param name="fieldExpression">The field expression.</param>
+        /// <returns>The extracted values as an enumerable of objects.</returns>
+        internal static IEnumerable<object> ExtractFieldValues(this MemberExpression fieldExpression)
+        {
+            var value = GetExpressionValue(fieldExpression);
+            return ExtractValues(value);
+        }
+
+        /// <summary>
+        /// Gets the value of an expression.
+        /// </summary>
+        /// <param name="expression">The expression.</param>
+        /// <returns>The value of the expression.</returns>
+        internal static object? GetExpressionValue(Expression expression)
+        {
+            switch (expression)
+            {
+                case ConstantExpression constantExpression:
+                    return constantExpression.Value!;
+
+                case MemberExpression memberExpression:
+                    var container = GetExpressionValue(memberExpression.Expression!);
+                    var member = memberExpression.Member;
+                    switch (member)
+                    {
+                        case FieldInfo fieldInfo:
+                            return fieldInfo.GetValue(container);
+
+                        case PropertyInfo propertyInfo:
+                            return propertyInfo.GetValue(container);
+
+                        default:
+                            throw new NotSupportedException(
+                                $"The member type '{member.GetType().Name}' is not supported.");
+                    }
+                default:
+                    throw new NotSupportedException(
+                        $"The expression type '{expression.GetType().Name}' is not supported.");
+            }
+        }
+
         /// <summary>
         /// Gets the member name from a method call expression.
         /// </summary>
@@ -18,5 +81,60 @@ internal static class ExpressionExtensions
 
             return null;
         }
+
+        private static IEnumerable<object> ExtractValues(object? value)
+        {
+            if (value is null)
+            {
+                return [];
+            }
+
+            if (value is IEnumerable<object> objectEnumerable)
+            {
+                return objectEnumerable;
+            }
+
+            if (value is IEnumerable<int> intEnumerable)
+            {
+                return intEnumerable.Cast<object>();
+            }
+
+            if (value is IEnumerable<string> stringEnumerable)
+            {
+                return stringEnumerable.Cast<object>();
+            }
+
+            if (value is IEnumerable<Guid> guidEnumerable)
+            {
+                return guidEnumerable.Cast<object>();
+            }
+
+            if (value is IEnumerable enumerable)
+            {
+                var list = new List<object>();
+
+                foreach (var item in enumerable)
+                {
+                    var itemValues = ExtractValues(item);
+                    list.AddRange(itemValues);
+                }
+
+                return list;
+            }
+
+            // Check if the object has a property that is a collection
+            var properties = value.GetType().GetProperties();
+
+            var collectionProperty = properties.FirstOrDefault(p =>
+                p.PropertyType.IsGenericType && p.PropertyType.GetGenericTypeDefinition() == typeof(IEnumerable<>));
+
+            if (collectionProperty != null)
+            {
+                var collectionValue = collectionProperty.GetValue(value);
+                return ExtractValues(collectionValue);
+            }
+
+            return new[] { value };
+        }
     }
 }