Merge pull request #42 from thygesteffensen/dev

Dev

Author: thygesteffensen

PowerAutomateMockUp/ExpressionParser/Functions/CustomException/InvalidTemplateException.cs

@@ -59,5 +59,15 @@ public static InvalidTemplateException BuildInvalidTemplateExceptionParameterTyp
 
             return new InvalidTemplateException(msg);
         }
+
+        public static InvalidTemplateException BuildInvalidLanguageFunction(string actionName, string functionName)
+        {
+            var msg = $"InvalidTemplate. Unable to process template language expressions in action '{actionName}' inputs at " +
+                      $"line 'x' and column 'y': 'The template language function '{functionName}' expects a comma separated " +
+                      "list of parameters. The function was invoked with no parameters. " +
+                      "Please see https://aka.ms/logicexpressions#createArray for usage details.'.";
+
+            return new InvalidTemplateException(msg);
+        }
     }
 }

PowerAutomateMockUp/ExpressionParser/Functions/Implementations/ConversionFunctions/CreateArrayFunction.cs

@@ -0,0 +1,23 @@
+using System.Linq;
+using Parser.ExpressionParser.Functions.Base;
+using Parser.ExpressionParser.Functions.CustomException;
+
+namespace Parser.ExpressionParser.Functions.Implementations.ConversionFunctions
+{
+    public class CreateArrayFunction : Function
+    {
+        public CreateArrayFunction() : base("createArray")
+        {
+        }
+
+        public override ValueContainer ExecuteFunction(params ValueContainer[] parameters)
+        {
+            if (parameters.Length == 0)
+            {
+                throw InvalidTemplateException.BuildInvalidLanguageFunction("SomeActon", "createArray");
+            }
+
+            return new ValueContainer(parameters.ToList());
+        }
+    }
+}

PowerAutomateMockUp/ExpressionParser/Functions/Implementations/ConversionFunctions/DataUriFunction.cs

@@ -1,4 +1,5 @@
 using Parser.ExpressionParser.Functions.Base;
+using Parser.ExpressionParser.Functions.CustomException;
 
 namespace Parser.ExpressionParser.Functions.Implementations.ConversionFunctions
 {
@@ -10,6 +11,11 @@ public DataUriFunction() : base("dataUri")
 
         public override ValueContainer ExecuteFunction(params ValueContainer[] parameters)
         {
+            if (parameters.Length == 0)
+            {
+                throw InvalidTemplateException.BuildInvalidLanguageFunction("SomeActon", "dataUri");
+            }
+            
             return parameters[0].Type() switch
             {
                 ValueContainer.ValueType.String =>

PowerAutomateMockUp/ExpressionParser/Functions/Implementations/ConversionFunctions/DataUriToBinaryFunction.cs

@@ -0,0 +1,32 @@
+using System;
+using System.Linq;
+using System.Text;
+using Parser.ExpressionParser.Functions.Base;
+using Parser.ExpressionParser.Functions.CustomException;
+
+namespace Parser.ExpressionParser.Functions.Implementations.ConversionFunctions
+{
+    public class DataUriToBinaryFunction : Function
+    {
+        public DataUriToBinaryFunction() : base("dataUriToBinary")
+        {
+        }
+
+        public override ValueContainer ExecuteFunction(params ValueContainer[] parameters)
+        {
+            if (parameters.Length == 0)
+            {
+                throw InvalidTemplateException.BuildInvalidLanguageFunction("SomeActon", "dataUriToBinary");
+            }
+
+            return parameters[0].Type() switch
+            {
+                ValueContainer.ValueType.String =>
+                    new ValueContainer(Encoding.UTF8.GetBytes(parameters[0].GetValue<string>())
+                        .Aggregate("", (s, b) => s + Convert.ToString(b, 2).PadLeft(8, '0'))),
+                _ => throw new PowerAutomateMockUpException(
+                    $"Array function can only operate on strings, not {parameters[0].Type()}.")
+            };
+        }
+    }
+}

PowerAutomateMockUp/ExpressionParser/Functions/Math/AddFunction.cs

@@ -0,0 +1,25 @@
+using Parser.ExpressionParser.Functions.Base;
+using Parser.ExpressionParser.Functions.CustomException;
+
+namespace Parser.ExpressionParser.Functions.Math
+{
+    public class AddFunction : Function
+    {
+        public AddFunction() : base("add")
+        {
+        }
+
+        public override ValueContainer ExecuteFunction(params ValueContainer[] parameters)
+        {
+            if (parameters.Length != 2)
+            {
+                throw new InvalidTemplateException("Paramters count does not match expected");
+            }
+
+            var first = parameters[0].GetValue<float>();
+            var second = parameters[1].GetValue<float>();
+
+            return new ValueContainer(first + second);
+        }
+    }
+}

PowerAutomateMockUp/ExpressionParser/Rules/AccessValueRule.cs

@@ -30,7 +30,7 @@ public AccessValueRule(IRule func, IEnumerable<IRule> indexRules)
 
                     foreach (var accessor in indexes.Skip(1))
                     {
-                        tempIndexRules.Add(new IndexRule(new ConstantRule(new ValueContainer(accessor)), false));
+                        tempIndexRules.Add(new IndexRule(new ConstantRule(new ValueContainer(accessor)), nullConditional));
                     }
                 }
                 else

PowerAutomateMockUp/ExpressionParser/ValueContainer.cs

@@ -59,7 +59,7 @@ public ValueContainer(string stringValue)
 
         public ValueContainer(float floatValue)
         {
-            _value = floatValue;
+            _value = Convert.ToDouble(floatValue);
             _type = ValueType.Float;
         }
 
@@ -250,9 +250,22 @@ private ValueContainer JsonToValueContainer(JToken json)
                 case JValue jValue:
                     if (jValue.HasValues)
                     {
-                        throw new PowerAutomateMockUpException("When parsing JToken to ValueContainer, the JToken as JValue can only contain one value.");
+                        throw new PowerAutomateMockUpException(
+                            "When parsing JToken to ValueContainer, the JToken as JValue can only contain one value.");
                     }
-                    return jValue.Value == null ? new ValueContainer() : new ValueContainer(jValue.Value.ToString(), true);
+
+                    return jValue.Type switch
+                    {
+                        JTokenType.Boolean => new ValueContainer(jValue.Value<bool>()),
+                        JTokenType.Integer => new ValueContainer(jValue.Value<int>()),
+                        JTokenType.Float => new ValueContainer(jValue.Value<float>()),
+                        JTokenType.Null => new ValueContainer(),
+                        JTokenType.String => new ValueContainer(jValue.Value<string>()),
+                        JTokenType.None => new ValueContainer(),
+                        JTokenType.Guid => new ValueContainer(jValue.Value<Guid>().ToString()),
+                        _ => throw new PowerAutomateMockUpException(
+                            $"{jValue.Type} is not yet supported in ValueContainer conversion")
+                    };
                 default:
                     throw new PowerAutomateMockUpException("Could not parse JToken to ValueContainer.");
             }
@@ -380,6 +393,19 @@ public bool Equals(ValueContainer other)
 
                     return thisDict.Count == otherDict.Count && !thisDict.Except(otherDict).Any();
                 }
+                case ValueType.Integer when other._type == ValueType.Float:
+                    var v = (double) _value;
+                    return Math.Abs(Math.Floor(v) - other._value) < double.Epsilon;
+                case ValueType.Float when other._type == ValueType.Integer:
+                {
+                    return Math.Abs(Math.Floor(_value) - other._value) < double.Epsilon;
+                }
+                case ValueType.Float:
+                {
+                    // TODO: Figure out how to handle comparison and in general how to handle float/double..
+                    // assignee: thygesteffensen
+                    return Math.Abs(_value - other._value) < 0.01;
+                }
                 default:
                     return Equals(_value, other._value) && _type == other._type;
             }

…Implementations/DoUntilActionExecutor.cs …/ControlActions/DoUntilActionExecutor.csPowerAutomateMockUp/FlowParser/ActionExecutors/Implementations/DoUntilActionExecutor.cs renamed to PowerAutomateMockUp/FlowParser/ActionExecutors/Implementations/ControlActions/DoUntilActionExecutor.cs PowerAutomateMockUp/FlowParser/ActionExecutors/Implementations/DoUntilActionExecutor.cs renamed to PowerAutomateMockUp/FlowParser/ActionExecutors/Implementations/ControlActions/DoUntilActionExecutor.cs

@@ -5,7 +5,7 @@
 using Newtonsoft.Json.Linq;
 using Parser.ExpressionParser;
 
-namespace Parser.FlowParser.ActionExecutors.Implementations
+namespace Parser.FlowParser.ActionExecutors.Implementations.ControlActions
 {
     public class DoUntilActionExecutor : DefaultBaseActionExecutor, IScopeActionExecutor
     {

…Implementations/ForEachActionExecutor.cs …/ControlActions/ForEachActionExecutor.csPowerAutomateMockUp/FlowParser/ActionExecutors/Implementations/ForEachActionExecutor.cs renamed to PowerAutomateMockUp/FlowParser/ActionExecutors/Implementations/ControlActions/ForEachActionExecutor.cs PowerAutomateMockUp/FlowParser/ActionExecutors/Implementations/ForEachActionExecutor.cs renamed to PowerAutomateMockUp/FlowParser/ActionExecutors/Implementations/ControlActions/ForEachActionExecutor.cs

@@ -6,7 +6,7 @@
 using Newtonsoft.Json.Linq;
 using Parser.ExpressionParser;
 
-namespace Parser.FlowParser.ActionExecutors.Implementations
+namespace Parser.FlowParser.ActionExecutors.Implementations.ControlActions
 {
     public class ForEachActionExecutor : DefaultBaseActionExecutor, IScopeActionExecutor, IItemHandler
     {