Added FormatString function and possibility to define OutputParameters

Author: Florian Kroenert

build.fsx

@@ -35,7 +35,7 @@ let sha = Git.Information.getCurrentHash()
 // version info
 let major = "3"
 let minor = "9"
-let patch = "13"
+let patch = "14"
 
 // Follow SemVer scheme: http://semver.org/
 let asmVersion = major + "." + minor + "." + patch

src/lib/Xrm.Oss.XTL.Interpreter/FunctionHandlers.cs

@@ -1039,30 +1039,78 @@ private static T CheckedCast<T>(object input, string errorMessage, bool failOnEr
             return new ValueExpression(date.ToString(CultureInfo.InvariantCulture), date.ToString(CultureInfo.InvariantCulture));
         };
 
+        /// <summary>
+        /// Formats a single value with a format specifier (like .ToString(format))
+        /// </summary>
         public static FunctionHandler Format = (primary, service, tracing, interpreterConfig, parameters) =>
         {
             if (parameters.Count < 2)
             {
-                throw new InvalidPluginExecutionException("Format needs a value to format and a config for defining further options");
+                throw new InvalidPluginExecutionException("Format needs a value and a format string");
             }
 
             var value = parameters[0].Value;
+            
+            // Handle special CRM types
+            if (value is Money money) value = money.Value;
+            if (value is OptionSetValue optionSet) value = optionSet.Value;
+            
+            // Support both styles:
+            // Format(value, { format: "C2" }) 
+            // Format(value, { format: "{0:C2}" })
             var config = GetConfig(parameters);
-            var format = config.GetValue<string>("format", "format must be a string!");
+            var formatString = config.GetValue<string>("format", "format must be a string!");
+            
+            try
+            {
+                string formatted;
+                
+                // If format contains {0:, use string.Format
+                if (formatString.Contains("{0:") || formatString.Contains("{0}"))
+                {
+                    formatted = string.Format(CultureInfo.InvariantCulture, formatString, value);
+                }
+                // Otherwise, use direct formatting
+                else if (value is IFormattable formattable)
+                {
+                    formatted = formattable.ToString(formatString, CultureInfo.InvariantCulture);
+                }
+                else
+                {
+                    formatted = value?.ToString() ?? string.Empty;
+                }
+                
+                return new ValueExpression(formatted, formatted);
+            }
+            catch (FormatException ex)
+            {
+                throw new InvalidPluginExecutionException($"Invalid format '{formatString}': {ex.Message}");
+            }
+        };
 
-            var knownTypes = new Dictionary<Type, Func<object, ValueExpression>>
+        /// <summary>
+        /// Composes multiple values into a format string (like string.Format)
+        /// </summary>
+        public static FunctionHandler FormatString = (primary, service, tracing, interpreterConfig, parameters) =>
+        {
+            if (parameters.Count < 1)
             {
-                { typeof(Money), (obj) => { var val = obj as Money; var formatted = string.Format(CultureInfo.InvariantCulture, format, val.Value); return new ValueExpression( formatted, formatted ); } }
-            };
+                throw new InvalidPluginExecutionException("FormatString needs at least a format string");
+            }
 
-            if(knownTypes.ContainsKey(value.GetType()))
+            var format = CheckedCast<string>(parameters[0].Value, "First parameter must be a format string");
+            
+            // Positional parameters only - exactly like C# string.Format
+            var args = parameters.Skip(1).Select(p => p.Value).ToArray();
+            
+            try
             {
-                return knownTypes[value.GetType()](value);
+                var result = string.Format(CultureInfo.InvariantCulture, format, args);
+                return new ValueExpression(result, result);
             }
-            else
+            catch (FormatException ex)
             {
-                var formatted = string.Format(CultureInfo.InvariantCulture, format, value);
-                return new ValueExpression(formatted, formatted);
+                throw new InvalidPluginExecutionException($"Invalid format string: {ex.Message}");
             }
         };
 

src/lib/Xrm.Oss.XTL.Interpreter/InterpreterConfig.cs

@@ -43,6 +43,9 @@ public class InterpreterConfig : IConfig
         [DataMember(Name = "inputParameters")]
         public Dictionary<string, object> InputParameters { get; set; } = new Dictionary<string, object>();
 
+        [DataMember(Name = "outputParameters")]
+        public Dictionary<string, object> OutputParameters { get; set; } = new Dictionary<string, object>();
+
         public Dictionary<string, FunctionHandler> CustomHandlers { get; set; } = new Dictionary<string, FunctionHandler>();
 
         public static InterpreterConfig Parse(string json)

src/lib/Xrm.Oss.XTL.Interpreter/XTLInterpreter.cs

@@ -36,6 +36,7 @@ public class XTLInterpreter
             { "Filter", FunctionHandlers.Filter },
             { "First", FunctionHandlers.First },
             { "Format", FunctionHandlers.Format },
+            { "FormatString", FunctionHandlers.FormatString },
             { "GptPrompt", FunctionHandlers.GptPrompt },
             { "If", FunctionHandlers.If },
             { "IndexOf", FunctionHandlers.IndexOf },