Fix parsing issue for Flags enum values with combined flags

src/Microsoft.OData.Core/EdmExtensionMethods.cs

@@ -7,6 +7,8 @@
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
+using System.Linq;
+using System.Text;
 using Microsoft.OData.Edm;
 using Microsoft.OData.UriParser;
 
@@ -152,17 +154,150 @@ public static bool TryParse(this IEdmEnumType enumType, long value, out IEdmEnum
         /// <param name="memberName">The member name to check.</param>
         /// <param name="comparison">The comparison type to use for string comparison. Default is Ordinal.</param>
         /// <returns>True if the member name exists in the enum type; otherwise, false.</returns>
-        public static bool ContainsMember(this IEdmEnumType enumType, string memberName, StringComparison comparison = StringComparison.Ordinal)
+        public static bool HasMember(this IEdmEnumType enumType, string memberName, StringComparison comparison = StringComparison.Ordinal)
+        {
+            return enumType.HasMember(memberName.AsSpan(), comparison);
+        }
+
+        /// <summary>
+        /// Determines whether the specified enum type contains a member with the given name, using the specified string comparison.
+        /// </summary>
+        /// <param name="enumType">The <see cref="IEdmEnumType"/> to search for the member.</param>
+        /// <param name="memberName">The name of the member to locate within the enum type.</param>
+        /// <param name="exactMemberName">When this method returns, contains the <see cref="IEdmEnumMember"/> that matches the specified name, if a match is found; otherwise, null.</param>
+        /// <param name="comparison">The comparison type to use for string comparison. Default is Ordinal.</param>
+        /// <returns>True if the member name exists in the enum type; otherwise, false.</returns>
+        public static IEdmEnumMember FindMember(this IEdmEnumType enumType, string memberName, StringComparison comparison = StringComparison.Ordinal)
+        {
+            return enumType.FindMember(memberName.AsSpan(), comparison);
+        }
+
+        /// <summary>
+        /// Checks if the given member name exists in the enum type.
+        /// </summary>
+        /// <param name="enumType">The enum type to search for the member.</param>
+        /// <param name="memberName">The name of the member to locate, represented as a <see cref="ReadOnlySpan{T}"/> of characters.</param>
+        /// <param name="comparison">The <see cref="StringComparison"/> to use when comparing the member names. The default is <see cref="StringComparison.Ordinal"/>.</param>
+        /// <returns>True if the member name exists in the enum type; otherwise, false.</returns>
+        public static bool HasMember(this IEdmEnumType enumType, ReadOnlySpan<char> memberName, StringComparison comparison = StringComparison.Ordinal)
         {
             foreach (IEdmEnumMember member in enumType.Members)
             {
-                if (string.Equals(member.Name, memberName, comparison))
+                if (memberName.Equals(member.Name.AsSpan(), comparison))
                 {
                     return true;
                 }
             }
 
             return false;
         }
+
+        /// <summary>
+        /// Checks if the given member name exists in the enum type.
+        /// </summary>
+        /// <param name="enumType">The enum type to search for the member.</param>
+        /// <param name="memberName">The name of the member to locate, represented as a <see cref="ReadOnlySpan{T}"/> of characters.</param>
+        /// <param name="exactMemberName">When this method returns, contains the <see cref="IEdmEnumMember"/> that matches the specified name, if a match is found; otherwise, null.</param>
+        /// <param name="comparison">The <see cref="StringComparison"/> to use when comparing the member names. The default is <see cref="StringComparison.Ordinal"/>.</param>
+        /// <returns>True if the member name exists in the enum type; otherwise, false.</returns>
+        public static IEdmEnumMember FindMember(this IEdmEnumType enumType, ReadOnlySpan<char> memberName, StringComparison comparison = StringComparison.Ordinal)
+        {
+            foreach (IEdmEnumMember member in enumType.Members)
+            {
+                if (memberName.Equals(member.Name.AsSpan(), comparison))
+                {
+                    return member;
+                }
+            }
+
+            return null;
+        }
+
+        /// <summary>
+        /// Parses the specified integral value into a comma-separated string of flag names based on the members of the given EDM enum type.
+        /// </summary>
+        /// <param name="enumType">The EDM enum type containing the members to parse.</param>
+        /// <param name="value">The integral value to parse into flag names.</param>
+        /// <returns>A comma-separated string of flag names corresponding to the set bits in the specified value. Returns null otherwise.</returns>
+        public static string ParseFlagsFromIntegralValue(this IEdmEnumType enumType, long value)
+        {
+            var result = new List<string>();
+            long remaining = value;
+
+            for (int index = enumType.Members.Count() - 1; index >= 0; index--)
+            {
+                IEdmEnumMember member = enumType.Members.ElementAt(index);
+                long flagValue = Convert.ToInt64(member.Value.Value);
+                if (flagValue != 0 && (remaining & flagValue) == flagValue)
+                {
+                    result.Add(member.Name);
+                    remaining &= ~flagValue; // Remove matched bits     
+                }
+            }
+
+            return result.Count > 0 && remaining == 0 ? string.Join(", ", result.Reverse<string>()) : null;
+        }
+
+        /// <summary>
+        /// Parses a comma-separated string of enum member names into a validated, formatted string containing only valid members of the specified <see cref="IEdmEnumType"/>.
+        /// </summary>
+        /// <param name="enumType">The EDM enum type to validate the enum member names against.</param>
+        /// <param name="memberName">A comma-separated string containing the names of enum members to parse and validate.</param>
+        /// <param name="comparison">The <see cref="StringComparison"/> to use when comparing the provided member names against the enum type's
+        /// defined members.</param>
+        /// <returns>A formatted string containing the validated enum member names, separated by commas and trimmed of whitespace. Otherwise, null or empty string.</returns>
+        public static string ParseFlagsFromStringValue(this IEdmEnumType enumType, string memberName, StringComparison comparison)
+        {
+            var stringBuilder = new StringBuilder();
+            int startIndex = 0, endIndex = 0;
+            while (endIndex < memberName.Length)
+            {
+                while (endIndex < memberName.Length && memberName[endIndex] != ',')
+                {
+                    endIndex++;
+                }
+
+                ReadOnlySpan<char> currentValue = memberName.AsSpan()[startIndex..endIndex].Trim();
+                IEdmEnumMember edmEnumMember = enumType.FindMember(currentValue, comparison);
+                if (edmEnumMember == null)
+                {
+                    return null;
+                }
+
+                if (stringBuilder.Length > 0)
+                {
+                    stringBuilder.Append(", ");
+                }
+
+                stringBuilder.Append(edmEnumMember.Name);
+                startIndex = endIndex + 1;
+                endIndex = startIndex;
+            }
+
+            return stringBuilder.Length == 0 ? null : stringBuilder.ToString();
+        }
+
+        /// <summary>
+        /// Determines whether the specified integral value is a valid combination of flags for the given enumeration type.
+        /// </summary>
+        /// <param name="enumType">The enumeration type to validate against. Must represent a flags enumeration.</param>
+        /// <param name="memberIntegralValue">The integral value to validate as a combination of flags.</param>
+        /// <returns><see langword="true"/> if the specified value is a valid combination of the flags defined in the
+        /// enumeration; otherwise, <see langword="false"/>.</returns>
+        public static bool IsValidFlagsEnumValue(this IEdmEnumType enumType, long memberIntegralValue)
+        {
+            if(enumType == null || !enumType.IsFlags)
+            {
+                return false;
+            }
+
+            long allFlagsMask = 0;
+            foreach (IEdmEnumMember member in enumType.Members)
+            {
+                allFlagsMask |= (long)member.Value.Value;
+            }
+
+            return (memberIntegralValue & ~allFlagsMask) == 0;
+        }
     }
 }

src/Microsoft.OData.Core/UriParser/Binders/InBinder.cs

@@ -70,7 +70,7 @@ internal QueryNode BindInOperator(InToken inToken, BindingState state)
             // Calls the MetadataBindingUtils.ConvertToTypeIfNeeded() method to convert the left operand to the same enum type as the right operand.
             if ((!(right is CollectionConstantNode) && right.ItemType.IsEnum()) && (left.TypeReference != null && (left.TypeReference.IsString() || left.TypeReference.IsIntegral())))
             {
-                left = MetadataBindingUtils.ConvertToTypeIfNeeded(left, right.ItemType);
+                left = MetadataBindingUtils.ConvertToTypeIfNeeded(left, right.ItemType, this.resolver.EnableCaseInsensitive);
             }
 
             MetadataBindingUtils.VerifyCollectionNode(right, this.resolver.EnableCaseInsensitive);
@@ -157,6 +157,10 @@ private CollectionNode GetCollectionOperandFromToken(QueryToken queryToken, IEdm
                         //    ==>  ['1970-01-01T00:00:00Z', '1980-01-01T01:01:01+01:00']
                         bracketLiteralText = NormalizeDateTimeCollectionItems(bracketLiteralText);
                     }
+                    else if (expectedType.Definition.AsElementType().TypeKind == EdmTypeKind.Enum)
+                    {
+                        bracketLiteralText = NormalizeEnumCollectionItems(bracketLiteralText, this.resolver.EnableCaseInsensitive, expectedTypeFullName);
+                    }
                 }
 
                 object collection = ODataUriConversionUtils.ConvertFromCollectionValue(bracketLiteralText, model, expectedType);
@@ -426,6 +430,108 @@ private static string NormalizeDateTimeCollectionItems(string bracketLiteralText
             return "[" + String.Join(",", items) + "]";
         }
 
+        private static string NormalizeEnumCollectionItems(string bracketLiteralText, bool enableCaseInsensitive, string expectedTypeFullName)
+        {
+            // Remove the '[' and ']' or '(' and ')' and trim the content
+            ReadOnlySpan<char> normalizedText = bracketLiteralText.AsSpan(1, bracketLiteralText.Length - 2);
+
+            // Trim leading/trailing whitespace
+            int left = 0;
+            int right = normalizedText.Length - 1;
+            while (left <= right && char.IsWhiteSpace(normalizedText[left]))
+            {
+                left++;
+            }
+
+            while (right >= left && char.IsWhiteSpace(normalizedText[right]))
+            {
+                right--;
+            }
+
+            if (left > right)
+            {
+                return "[]";
+            }
+
+            int expectedTypeFullNameLength = string.IsNullOrEmpty(expectedTypeFullName) ? 0 : expectedTypeFullName.Length;
+            ReadOnlySpan<char> content = normalizedText.Slice(left, right - left + 1);
+            int startIndex = 0;
+            int length = content.Length;
+
+            StringBuilder result = new StringBuilder(length + 2);
+            result.Append('[');
+
+            while (startIndex < length)
+            {
+                char currentChar = content[startIndex];
+
+                if (currentChar == '\'' || currentChar == '"')
+                {
+                    // Handle quoted items
+                    int relativeEnd = content.Slice(startIndex + 1).IndexOf(currentChar);
+                    if (relativeEnd < 0)
+                    {
+                        throw new ODataException(Error.Format("Found unbalanced quotes '{0}'", currentChar));
+                    }
+
+                    // Include closing quote
+                    int endIndex = startIndex + 1 + relativeEnd;
+                    result.Append(content.Slice(startIndex, endIndex - startIndex + 1)); 
+                    startIndex = endIndex + 1;
+                }
+                else if (currentChar == ',')
+                {
+                    // Handle commas
+                    result.Append(',');
+                    startIndex++;
+                }
+                else if (char.IsWhiteSpace(currentChar))
+                {
+                    // Skip whitespace
+                    startIndex++;
+                }
+                else
+                {
+                    // Handle non-quoted items
+                    int end = startIndex;
+                    while (end < length && content[end] != ',' && !char.IsWhiteSpace(content[end]))
+                    {
+                        end++;
+                    }
+
+                    ReadOnlySpan<char> token = content[startIndex..end];
+
+                    // Remove type prefix if present e.g., Namespace.Days'Monday'
+                    if (expectedTypeFullNameLength > 0 && token.Length > expectedTypeFullNameLength && 
+                        token.StartsWith(expectedTypeFullName, enableCaseInsensitive ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal))
+                    {
+                        char next = token[expectedTypeFullNameLength];
+                        if (next == '\'' || next == '\"')
+                        {
+                            token = token.Slice(expectedTypeFullNameLength);
+                        }
+                    }
+
+                    // If item is already quoted, keep it; otherwise wrap in single quotes
+                    if (token.Length > 0 && (token[0] == '\'' || token[0] == '"'))
+                    {
+                        result.Append(token);
+                    }
+                    else
+                    {
+                        result.Append('\'');
+                        result.Append(token);
+                        result.Append('\'');
+                    }
+
+                    startIndex = end;
+                }
+            }
+
+            result.Append(']');
+            return result.ToString();
+        }
+
         private static bool IsCollectionEmptyOrWhiteSpace(string bracketLiteralText)
         {
             string content = bracketLiteralText[1..^1].Trim();