Merge pull request #3809 from Ginger-Automation/Feature/MockDataGenerate

Mock Data generate Option added in Value Expression

Ginger/Ginger/UserControlsLib/ImageMakerLib/ImageMakerControl.xaml.cs

@@ -996,6 +996,21 @@ private void SetImage()
                 case eImageType.Asterisk:
                     SetAsFontAwesomeIcon(EFontAwesomeIcon.Solid_Asterisk);
                     break;
+                case eImageType.MoneyCheckDollar:
+                    SetAsFontAwesomeIcon(EFontAwesomeIcon.Solid_MoneyCheckDollar);
+                    break;
+                case eImageType.AddressCard:
+                    SetAsFontAwesomeIcon(EFontAwesomeIcon.Regular_AddressCard);
+                    break;
+                case eImageType.IdCard:
+                    SetAsFontAwesomeIcon(EFontAwesomeIcon.Regular_IdCard);
+                    break;
+                case eImageType.IdBadge:
+                    SetAsFontAwesomeIcon(EFontAwesomeIcon.Regular_IdBadge);
+                    break;
+                case eImageType.Phone:
+                    SetAsFontAwesomeIcon(EFontAwesomeIcon.Solid_Phone);
+                    break;
                 #endregion
 
                 #region ElementType Images

Ginger/Ginger/ValueExpression/ValueExpressionEditorPage.xaml.cs

@@ -195,7 +195,7 @@ private void BuildItemsTree()
         }
 
 
-
+        
         private void AddGlobalModelParameters()
         {
             TreeViewItem Parent = AddOrGetCategory("Data");
@@ -418,10 +418,35 @@ eImageType GetCategoryImageType(string category)
                 case "Solution":
                     eImageType = eImageType.Solution;
                     break;
+                case "Mock Data":
+                    eImageType = eImageType.Table;
+                    break;
+                case "Address":
+                    eImageType = eImageType.AddressCard;
+                    break;
+                case "Date":
+                    eImageType = eImageType.Timer;
+                    break;
+                case "Finance":
+                    eImageType = eImageType.MoneyCheckDollar;
+                    break;
+                case "Internet":
+                    eImageType = eImageType.IdCard;
+                    break;
+                case "Name":
+                    eImageType = eImageType.IdBadge;
+                    break;
+                case "Phone":
+                    eImageType = eImageType.Phone;
+                    break;
+                case "Random":
+                    eImageType = eImageType.Operations;
+                    break;
                 default:
                     throw new KeyNotFoundException();
             }
             return eImageType;
+
         }
 
         private TreeViewItem AddOrGetCategory(string Category)
@@ -613,7 +638,6 @@ private void AddVBSIfEval(TreeViewItem tviVars, string Desc, string Eval)
         private void AddEnvParams()
         {
             TreeViewItem Parent = AddOrGetCategory("Data");
-            //TreeViewItem child = AddOrGetSubCategory("Environments", Parent);
             TreeViewItem tviEnvs = new TreeViewItem();
             tviEnvs.Selected += CleanHelpText;
             SetItemView(tviEnvs, "Environments", "", eImageType.Environment);
@@ -628,15 +652,11 @@ private void AddEnvParams()
                 tviEnv.Selected += CleanHelpText;
                 tviEnvs.Items.Add(tviEnv);
 
-                TreeViewItem tviEnvApps = new TreeViewItem();
-                SetItemView(tviEnvApps, "Applications", "", eImageType.Application);
-                tviEnv.Items.Add(tviEnvApps);
-
                 foreach (EnvApplication a in env.Applications)
                 {
                     TreeViewItem tviEnvApp = new TreeViewItem();
                     SetItemView(tviEnvApp, a.Name, "", eImageType.Window);
-                    tviEnvApps.Items.Add(tviEnvApp);
+                    tviEnv.Items.Add(tviEnvApp);
                     tviEnvApp.Selected += CleanHelpText;
                     //Add Env URL
                     TreeViewItem tviEnvAppURL = new TreeViewItem();

Ginger/GingerCoreCommon/EnumsLib/eImageType.cs

@@ -325,6 +325,11 @@ public enum eImageType
         Support,
         Asterisk,
         Smile,
+        AddressCard,
+        IdCard,
+        IdBadge,
+        Phone,
+        MoneyCheckDollar,
         #endregion
 
         #region Source control Images     

Ginger/GingerCoreNET/GingerCoreNET.csproj

@@ -233,6 +233,8 @@
 
     <PackageReference Include="Azure.Identity" Version="1.11.0" />
 
+    <PackageReference Include="Bogus" Version="35.5.1" />
+
     <PackageReference Include="CassandraCSharpDriver" Version="3.19.5" />
 
     <PackageReference Include="CliWrap" Version="3.6.6" />

Ginger/GingerCoreNET/RosLynLib/CodeProcessor.cs

@@ -26,6 +26,7 @@ limitations under the License.
 using System.Diagnostics;
 using System.Linq;
 using System.Reflection;
+using System.Reflection.Metadata;
 using System.Text.RegularExpressions;
 using System.Threading.Tasks;
 
@@ -245,6 +246,102 @@ public static object ExecuteNew(string code)
 
             return null;
         }
+        /// <summary>
+        /// function is designed to process a given Expression string and replace occurrences of a specific pattern ({MockDataExp(...)}) 
+        /// with evaluated results obtained from another function (GetBogusExpressionEvaluateResult)
+        /// </summary>
+        /// <param name="Expression"></param>
+        /// <returns></returns>
+        public static string GetBogusDataGenerateresult(string Expression)
+        {
+            if (!Expression.Contains(@"{MockDataExp"))
+            {
+                return Expression;
+            }
+            const string pattern = "{MockDataExp({.*}|[^{}]*)*}";
+            Pattern = new Regex(pattern, RegexOptions.Compiled);
+            Regex Clean = new Regex("{MockDataExp(\\s)*Fun(\\s)*=", RegexOptions.Compiled);
 
+            foreach (Match M in Pattern.Matches(Expression))
+            {
+                string Error = "";
+                string match = M.Value;
+                string exp = match;
+                exp = exp.Replace(Clean.Match(exp).Value, "");
+                exp = exp.Remove(exp.Length - 1);
+                string evalresult = GetBogusExpressionEvaluteResult(exp, out Error);
+                Expression = Expression.Replace(match, evalresult);
+            }
+            return Expression;
+        }
+        /// <summary>
+        /// The GetBogusExpressionEvaluteResult function is responsible for evaluating and generating data using Bogus library expressions based on the provided expression. 
+        /// It handles different types of expressions related to data generation and returns the evaluated result as a string.
+        /// If the expression does not start with new Bogus.DataSets.
+        /// it checks for special cases like Randomizer and constructs appropriate var Result = ...; return Result; expressions.
+        /// Handles scenarios with special characters(@) and constructs expressions accordingly like for Between.
+        /// If the expression starts with new Bogus.DataSets., it directly constructs the expression for evaluation.
+        /// </summary>
+        /// <param name="expression"></param>
+        /// <param name="error"></param>
+        /// <returns></returns>
+        public static string GetBogusExpressionEvaluteResult(string expression, out string error)
+        {
+            error = string.Empty;
+            try
+            {
+                Assembly BogusAssembly = Assembly.Load("Bogus");
+                /// If the expression does not start with new Bogus.DataSets.
+                if (!expression.Contains("new Bogus.DataSets."))
+                {
+                    /// it checks for special cases like Randomizer and constructs appropriate var Result = ...; return Result; expressions.
+                    if (expression.Contains("Randomizer"))
+                    {
+                        expression = $"var Result = new Bogus.{expression} return Result;";
+                    }
+                    else
+                    {
+                        /// Handles scenarios with special characters(@) and constructs expressions accordingly.
+                        if (expression.Contains('@'))
+                        {
+                            string[] expressionlist = expression.Split('.');
+                            /// Handles scenarios with special case like Between and constructs expressions accordingly
+                            if (expressionlist[1].Contains("Between"))
+                            {
+                                string expressionsubstring = expressionlist[1].Substring(expressionlist[1].IndexOf('(') + 1,expressionlist[1].IndexOf("))") - expressionlist[1].IndexOf("(") + 1);
+                                string[] Parameter = expressionsubstring.Split(',');
+                                /// Handles scenarios with special case like Between function have inbuilt function as parameter and constructs expressions accordingly
+                                if (expressionlist[1].Contains("Past") && expressionlist[1].Contains("Future"))
+                                {
+                                    expressionlist[1] = expressionlist[1].Replace(Parameter[0], $"Result.{Parameter[0]}").Replace(Parameter[1], $"Result.{Parameter[1]}");
+                                }
+                                expression = $"var Result = new Bogus.DataSets.{expressionlist[0]}; return Result.{expressionlist[1]}";
+                            }
+                            else 
+                            {
+                                expression = $"var Result = new Bogus.DataSets.{expressionlist[0]}; return Result.{expressionlist[1]}";
+                            }
+
+                        }
+                        else
+                        {
+                            expression = $"var Result = new Bogus.DataSets.{expression} return Result;";
+                        }
+                    }
+                }/// If the expression starts with new Bogus.DataSets., it directly constructs the expression for evaluation.
+                else
+                {
+                    expression = $"var Result = {expression} return Result;";
+                }
+
+                object result = CSharpScript.EvaluateAsync(expression, ScriptOptions.Default.WithReferences(BogusAssembly)).Result;
+                return result.ToString();
+            }
+            catch (Exception e)
+            {
+                Reporter.ToLog(eLogLevel.DEBUG, expression + System.Environment.NewLine + " not a valid Bogus data generate expression to evaluate", e);
+            }
+            return error;
+        }
     }
 }