Add new functions in expression (#3470)

Author: Danieladu

libraries/AdaptiveExpressions/ExpressionFunctions.cs

@@ -2437,15 +2437,27 @@ private static EvaluateExpressionDelegate SortBy(bool isDescending)
                return (result, error);
            };
 
+        // TODO we should uniform the list format
+        private static List<object> Object2List(JObject jobj)
+        {
+            var tempList = new List<object>();
+            foreach (var item in jobj)
+            {
+                tempList.Add(new { index = item.Key, value = item.Value });
+            }
+
+            return tempList;
+        }
+
         private static (object, string) IndicesAndValues(Expression expression, object state)
         {
             object result = null;
             string error;
-            object arr;
-            (arr, error) = expression.Children[0].TryEvaluate(state);
+            object instance;
+            (instance, error) = expression.Children[0].TryEvaluate(state);
             if (error == null)
             {
-                if (TryParseList(arr, out var list))
+                if (TryParseList(instance, out var list))
                 {
                     var tempList = new List<object>();
                     for (var i = 0; i < list.Count; i++)
@@ -2455,9 +2467,17 @@ private static (object, string) IndicesAndValues(Expression expression, object s
 
                     result = tempList;
                 }
+                else if (instance is JObject jobj)
+                {
+                    result = Object2List(jobj);
+                }
+                else if (JToken.FromObject(instance) is JObject jobject)
+                {
+                    result = Object2List(jobject);
+                }
                 else
                 {
-                    error = $"{expression.Children[0]} is not array.";
+                    error = $"{expression.Children[0]} is not array or object..";
                 }
             }
 
@@ -2517,6 +2537,46 @@ private static int GetPropertyCount(dynamic obj)
             return -1;
         }
 
+        private static IEnumerable<object> Flatten(IEnumerable<object> list, int dept)
+        {
+            var result = list.ToList();
+            if (dept < 1)
+            {
+                dept = 1;
+            }
+
+            for (var i = 0; i < dept; i++)
+            {
+                var hasArray = result.Any(u => TryParseList(u, out var _));
+                if (hasArray)
+                {
+                    var tempList = new List<object>();
+                    foreach (var item in result)
+                    {
+                        if (TryParseList(item, out var itemList))
+                        {
+                            foreach (var childItem in itemList)
+                            {
+                                tempList.Add(childItem);
+                            }
+                        }
+                        else
+                        {
+                            tempList.Add(item);
+                        }
+                    }
+
+                    result = tempList.ToList();
+                }
+                else
+                {
+                    break;
+                }
+            }
+
+            return result;
+        }
+
         private static Dictionary<string, ExpressionEvaluator> GetExpressionFunctions()
         {
             var functions = new List<ExpressionEvaluator>
@@ -2784,6 +2844,27 @@ private static Dictionary<string, ExpressionEvaluator> GetExpressionFunctions()
                     ReturnType.Object,
                     (expression) => ExpressionFunctions.ValidateOrder(expression, new[] { ReturnType.String }, ReturnType.Object)),
                 new ExpressionEvaluator(ExpressionType.IndicesAndValues, IndicesAndValues, ReturnType.Object, ValidateUnary),
+                new ExpressionEvaluator(
+                    ExpressionType.Flatten,
+                    Apply(
+                        args =>
+                        {
+                            IEnumerable<object> result = args[0];
+                            var depth = args.Count > 1 ? args[1] : 100;
+                            return ExpressionFunctions.Flatten(result, depth);
+                        }),
+                    ReturnType.Object,
+                    (expression) => ValidateOrder(expression, new[] { ReturnType.Number }, ReturnType.Object)),
+                new ExpressionEvaluator(
+                    ExpressionType.Unique,
+                    Apply(
+                        args =>
+                        {
+                            IEnumerable<object> result = args[0];
+                            return result.Distinct().ToList();
+                        }, VerifyList),
+                    ReturnType.Object,
+                    (expression) => ValidateOrder(expression, null, ReturnType.Object)),
 
                 // Booleans
                 Comparison(ExpressionType.LessThan, args => args[0] < args[1], ValidateBinaryNumberOrString, VerifyNumberOrString),

libraries/AdaptiveExpressions/ExpressionType.cs

@@ -71,6 +71,8 @@ public static class ExpressionType
         public const string SortBy = "sortBy";
         public const string SortByDescending = "sortByDescending";
         public const string IndicesAndValues = "indicesAndValues";
+        public const string Flatten = "flatten";
+        public const string Unique = "unique";
 
         // DateTime
         public const string AddDays = "addDays";

tests/AdaptiveExpressions.Tests/ExpressionEngineTests.cs

@@ -691,6 +691,7 @@ public class ExpressionEngineTests
             Test("join(where(items, item, item == 'two'), ',')", "two"),
             Test("string(where(dialog, item, item.value=='Dialog Title'))", "{\"title\":\"Dialog Title\"}"),
             Test("first(where(indicesAndValues(items), elt, elt.index > 1)).value", "two"),
+            Test("first(where(indicesAndValues(bag), elt, elt.index == \"three\")).value", 3),
             Test("join(foreach(where(nestedItems, item, item.x > 1), result, result.x), ',')", "2,3", new HashSet<string> { "nestedItems" }),
             Test("join(foreach(doubleNestedItems, items, join(foreach(items, item, concat(y, string(item.x))), ',')), ',')", "y1,y2,y3"),
             Test("join(foreach(doubleNestedItems, items, join(foreach(items, item, items[0].x), ',')), ',')", "1,1,3"),
@@ -729,6 +730,9 @@ public class ExpressionEngineTests
             Test("sortBy(nestedItems, 'x')[0].x", 1),
             Test("sortByDescending(items)", new List<object> { "zero", "two", "one" }),
             Test("sortByDescending(nestedItems, 'x')[0].x", 3),
+            Test("flatten(createArray(1,createArray(2),createArray(createArray(3, 4), createArray(5,6))))", new List<object> { 1, 2, 3, 4, 5, 6 }),
+            Test("flatten(createArray(1,createArray(2),createArray(createArray(3, 4), createArray(5,6))), 1)", new List<object> { 1, 2, new List<object>() { 3, 4 }, new List<object>() { 5, 6 } }),
+            Test("unique(createArray(1, 5, 1))", new List<object>() { 1, 5 }),
             #endregion
 
             #region  Object manipulation and construction functions
@@ -921,7 +925,7 @@ private void AssertObjectEquals(object expected, object actual)
                 Assert.AreEqual(expectedList.Count, actualList.Count);
                 for (var i = 0; i < expectedList.Count; i++)
                 {
-                    Assert.AreEqual(ResolveValue(expectedList[i]), ResolveValue(actualList[i]));
+                    AssertObjectEquals(ResolveValue(expectedList[i]), ResolveValue(actualList[i]));
                 }
             }
             else