private bool GetConditionResult(IAutomationEngineInstance engine)
{
bool isTrueStatement = true;
foreach (DataRow rw in v_IfConditionsTable.Rows)
{
var commandData = rw["CommandData"].ToString();
var ifCommand = JsonConvert.DeserializeObject <BeginIfCommand>(commandData);
var statementResult = CommandsHelper.DetermineStatementTruth(engine, ifCommand.v_IfActionType, ifCommand.v_ActionParameterTable);
if (!statementResult && v_LogicType == "And")
{
isTrueStatement = false;
break;
}
if (statementResult && v_LogicType == "Or")
{
isTrueStatement = true;
break;
}
else if (v_LogicType == "Or")
{
isTrueStatement = false;
}
}
return(isTrueStatement);
}
public async static Task <bool> ElementExists(IAutomationEngineInstance engine, OBAppInstance instance, string searchMethod, string parameterName,
string searchOption, int timeout)
{
//get engine reference
List <string[]> seleniumSearchParamRows = new List <string[]>();
seleniumSearchParamRows.Add(new string[]
{
string.Empty, $"\"{searchMethod}\"", parameterName
});
//get selenium instance driver
var seleniumInstance = (IWebDriver)instance.Value;
try
{
//search for element
var element = await FindElement(engine, seleniumInstance, seleniumSearchParamRows, searchOption, timeout);
//element exists
if (element == null)
{
return(false);
}
else
{
return(true);
}
}
catch (Exception)
{
//element does not exist
return(false);
}
}
public static bool ElementExists(IAutomationEngineInstance engine, string instanceName, string searchMethod, string parameterName,
string searchOption, int timeout)
{
//get engine reference
List <string[]> seleniumSearchParamRows = new List <string[]>();
seleniumSearchParamRows.Add(new string[]
{
string.Empty, searchMethod, parameterName
});
//get stored app object
var browserObject = instanceName.GetAppInstance(engine);
//get selenium instance driver
var seleniumInstance = (ChromeDriver)browserObject;
try
{
//search for element
var element = FindElement(engine, seleniumInstance, seleniumSearchParamRows, searchOption, timeout);
//element exists
return(true);
}
catch (Exception)
{
//element does not exist
return(false);
}
}
public static Type GetVarArgType(this string varArgName, IAutomationEngineInstance engine)
{
OBScriptVariable requiredVariable;
var variableList = engine.EngineContext.Variables;
var argumentsAsVariablesList = engine.EngineContext.Arguments
.Select(arg => new OBScriptVariable
{
VariableName = arg.ArgumentName,
VariableType = arg.ArgumentType,
VariableValue = arg.ArgumentValue
})
.ToList();
var variableSearchList = new List <OBScriptVariable>();
variableSearchList.AddRange(variableList);
variableSearchList.AddRange(argumentsAsVariablesList);
requiredVariable = variableSearchList.Where(var => var.VariableName == varArgName).FirstOrDefault();
if (requiredVariable != null)
{
return(requiredVariable.VariableType);
}
else
{
return(null);
}
}
public static object ConvertUserVariableToObject(this string varArgName, IAutomationEngineInstance engine, string parameterName, ScriptCommand parent)
{
var variableProperties = parent.GetType().GetProperties().Where(f => f.Name == parameterName).FirstOrDefault();
var compatibleTypesAttribute = variableProperties.GetCustomAttributes(typeof(CompatibleTypes), true);
Type[] compatibleTypes = null;
if (compatibleTypesAttribute.Length > 0)
{
compatibleTypes = ((CompatibleTypes[])compatibleTypesAttribute)[0].CompTypes;
}
ScriptVariable requiredVariable;
ScriptArgument requiredArgument;
if (varArgName.StartsWith("{") && varArgName.EndsWith("}"))
{
//reformat and attempt
var reformattedVarArg = varArgName.Replace("{", "").Replace("}", "");
requiredVariable = engine.AutomationEngineContext.Variables
.Where(var => var.VariableName == reformattedVarArg)
.FirstOrDefault();
if (requiredVariable != null && compatibleTypes != null && !compatibleTypes.Any(x => x.IsAssignableFrom(requiredVariable.VariableType) ||
x == requiredVariable.VariableType))
{
throw new ArgumentException($"The type of variable '{requiredVariable.VariableName}' is not compatible.");
}
requiredArgument = engine.AutomationEngineContext.Arguments
.Where(arg => arg.ArgumentName == reformattedVarArg)
.FirstOrDefault();
if (requiredArgument != null && compatibleTypes != null && !compatibleTypes.Any(x => x.IsAssignableFrom(requiredArgument.ArgumentType) ||
x == requiredArgument.ArgumentType))
{
throw new ArgumentException($"The type of argument '{requiredArgument.ArgumentName}' is not compatible.");
}
}
else
{
throw new Exception("Variable/Argument markers '{}' missing. Variable/Argument '" + varArgName + "' could not be found.");
}
if (requiredVariable != null)
{
return(requiredVariable.VariableValue);
}
else if (requiredArgument != null)
{
return(requiredArgument.ArgumentValue);
}
else
{
return(null);
}
}
public static AutomationElement SearchForGUIElement(IAutomationEngineInstance engine, DataTable uiaSearchParams, string variableWindowName)
{
User32Functions.ActivateWindow(variableWindowName);
//create search params
var searchParams = from rw in uiaSearchParams.AsEnumerable()
where rw.Field <string>("Enabled") == "True"
select rw;
//create and populate condition list
var conditionList = new List <Condition>();
foreach (var param in searchParams)
{
var parameterName = (string)param["Parameter Name"];
var parameterValue = (string)param["Parameter Value"];
parameterValue = parameterValue.ConvertUserVariableToString(engine);
PropertyCondition propCondition;
if (bool.TryParse(parameterValue, out bool bValue))
{
propCondition = CreatePropertyCondition(parameterName, bValue);
}
else
{
propCondition = CreatePropertyCondition(parameterName, parameterValue);
}
conditionList.Add(propCondition);
}
//concatenate or take first condition
Condition searchConditions;
if (conditionList.Count > 1)
{
searchConditions = new AndCondition(conditionList.ToArray());
}
else
{
searchConditions = conditionList[0];
}
//find window
var windowElement = AutomationElement.RootElement.FindFirst(TreeScope.Children, new PropertyCondition(AutomationElement.NameProperty, variableWindowName));
//if window was not found
if (windowElement == null)
{
throw new Exception("Window named '" + variableWindowName + "' was not found!");
}
//find required handle based on specified conditions
var element = windowElement.FindFirst(TreeScope.Descendants, searchConditions);
return(element);
}
public static void CreateTestVariable(object variableValue, IAutomationEngineInstance engine, string variableName, Type variableType)
{
ScriptVariable newVar = new ScriptVariable();
newVar.VariableName = variableName;
newVar.VariableValue = variableValue;
newVar.VariableType = variableType;
engine.AutomationEngineContext.Variables.Add(newVar);
}
private void InitializeArgumentLists(IAutomationEngineInstance parentAutomationEngineInstance)
{
_argumentList = new List <ScriptArgument>();
foreach (DataRow rw in v_ArgumentAssignments.Rows)
{
var argumentName = (string)rw.ItemArray[0];
var argumentType = (Type)rw.ItemArray[1];
object argumentValue = null;
var argumentDirection = (string)rw.ItemArray[3];
if (argumentDirection == "In" || argumentDirection == "InOut")
{
if (((string)rw.ItemArray[2]).StartsWith("{") && ((string)rw.ItemArray[2]).EndsWith("}"))
{
argumentValue = ((string)rw.ItemArray[2]).ConvertUserVariableToObject(parentAutomationEngineInstance, typeof(object));
}
if (argumentValue is string || argumentValue == null)
{
argumentValue = ((string)rw.ItemArray[2]).ConvertUserVariableToString(parentAutomationEngineInstance);
}
_argumentList.Add(new ScriptArgument
{
ArgumentName = argumentName.Replace("{", "").Replace("}", ""),
Direction = (ScriptArgumentDirection)Enum.Parse(typeof(ScriptArgumentDirection), argumentDirection),
ArgumentValue = argumentValue,
ArgumentType = argumentType
});
}
if (argumentDirection == "Out" || argumentDirection == "InOut")
{
//verify whether the assigned variable/argument exists
((string)rw.ItemArray[2]).ConvertUserVariableToObject(parentAutomationEngineInstance, nameof(v_ArgumentAssignments), this);
var existingArg = _argumentList.Where(x => x.ArgumentName == argumentName.Replace("{", "").Replace("}", "")).FirstOrDefault();
if (existingArg != null)
{
existingArg.AssignedVariable = ((string)rw.ItemArray[2]).Replace("{", "").Replace("}", "");
}
else
{
_argumentList.Add(new ScriptArgument
{
ArgumentName = argumentName.Replace("{", "").Replace("}", ""),
Direction = (ScriptArgumentDirection)Enum.Parse(typeof(ScriptArgumentDirection), argumentDirection),
AssignedVariable = ((string)rw.ItemArray[2]).Replace("{", "").Replace("}", ""),
ArgumentType = argumentType
});
}
}
}
}
/// <summary>
/// Stores value of the object to a user-defined variable.
/// </summary>
/// <param name="sender">The script engine instance (AutomationEngineInstance) which contains session variables.</param>
/// <param name="targetVariable">the name of the user-defined variable to override with new value</param>
public static void StoreInUserVariable(this object varArgValue, IAutomationEngineInstance engine, string varArgName, string parameterName, ScriptCommand parent)
{
var variableProperties = parent.GetType().GetProperties().Where(f => f.Name == parameterName).FirstOrDefault();
var compatibleTypesAttribute = variableProperties.GetCustomAttributes(typeof(CompatibleTypes), true);
Type[] compatibleTypes = null;
if (compatibleTypesAttribute.Length > 0)
{
compatibleTypes = ((CompatibleTypes[])compatibleTypesAttribute)[0].CompTypes;
}
if (varArgName.StartsWith("{") && varArgName.EndsWith("}"))
{
varArgName = varArgName.Replace("{", "").Replace("}", "");
}
else
{
throw new Exception("Variable markers '{}' missing. '" + varArgName + "' is an invalid output variable name.");
}
var existingVariable = engine.AutomationEngineContext.Variables
.Where(var => var.VariableName == varArgName)
.FirstOrDefault();
if (existingVariable != null && compatibleTypes != null && !compatibleTypes.Any(x => x.IsAssignableFrom(existingVariable.VariableType) ||
x == existingVariable.VariableType))
{
throw new ArgumentException($"The type of variable '{existingVariable.VariableName}' is not compatible.");
}
else if (existingVariable != null)
{
existingVariable.VariableValue = varArgValue;
return;
}
var existingArgument = engine.AutomationEngineContext.Arguments
.Where(arg => arg.ArgumentName == varArgName)
.FirstOrDefault();
if (existingArgument != null && compatibleTypes != null && !compatibleTypes.Any(x => x.IsAssignableFrom(existingArgument.ArgumentType) ||
x == existingArgument.ArgumentType))
{
throw new ArgumentException($"The type of argument '{existingArgument.ArgumentName}' is not compatible.");
}
else if (existingArgument != null)
{
existingArgument.ArgumentValue = varArgValue;
return;
}
throw new ArgumentNullException($"No variable/argument with the name '{varArgName}' was found.");
}
private static string CalculateVariables(this string str, IAutomationEngineInstance engine)
{
if (!engine.AutoCalculateVariables)
{
return(str);
}
else
{
//track math chars
var mathChars = new List <char>();
mathChars.Add('*');
mathChars.Add('+');
mathChars.Add('-');
mathChars.Add('=');
mathChars.Add('/');
//if the string matches the char then return
//as the user does not want to do math
if (mathChars.Any(f => f.ToString() == str) || (mathChars.Any(f => str.StartsWith(f.ToString()))))
{
return(str);
}
//bypass math for types that are dates
DateTime dateTest;
if ((DateTime.TryParse(str, out dateTest) || DateTime.TryParse(str, CultureInfo.CreateSpecificCulture("es-ES"), DateTimeStyles.AssumeUniversal, out dateTest)) &&
(str.Split('/').Length == 3 || str.Split('-').Length == 3))
{
return(str);
}
//test if math is required
if (mathChars.Any(f => str.Contains(f)))
{
try
{
DataTable dt = new DataTable();
var v = dt.Compute(str, "");
return(v.ToString());
}
catch (Exception)
{
return(str);
}
}
else
{
return(str);
}
}
}
public async static Task <bool> EvaluateSnippet(this string code, IAutomationEngineInstance engine)
{
if (engine.EngineContext.EngineScriptState == null)
{
engine.EngineContext.EngineScriptState = await engine.EngineContext.EngineScript.RunAsync();
}
string script = $"{code};";
engine.EngineContext.EngineScriptState = await engine.EngineContext.EngineScriptState
.ContinueWithAsync(script);
return(true);
}
public void UpdateCurrentEngineContext(IAutomationEngineInstance parentAutomationEngineIntance, IfrmScriptEngine childfrmScriptEngine, List <ScriptArgument> argumentList)
{
//get new variable list from the new task engine after it finishes running
var childEngine = ((frmScriptEngine)childfrmScriptEngine).EngineInstance;
var parentVariableList = parentAutomationEngineIntance.AutomationEngineContext.Variables;
var parentArgumentList = parentAutomationEngineIntance.AutomationEngineContext.Arguments;
//get new argument list from the new task engine after it finishes running
var childArgumentList = childfrmScriptEngine.ScriptEngineContext.Arguments;
foreach (var argument in argumentList)
{
if ((argument.Direction == ScriptArgumentDirection.Out || argument.Direction == ScriptArgumentDirection.InOut) &&
argument.AssignedVariable != null)
{
var assignedParentVariable = parentVariableList.Where(v => v.VariableName == argument.AssignedVariable).FirstOrDefault();
var assignedParentArgument = parentArgumentList.Where(a => a.ArgumentName == argument.AssignedVariable).FirstOrDefault();
if (assignedParentVariable != null)
{
assignedParentVariable.VariableValue = childArgumentList.Where(a => a.ArgumentName == argument.ArgumentName).First().ArgumentValue;
}
else if (assignedParentArgument != null)
{
assignedParentArgument.ArgumentValue = childArgumentList.Where(a => a.ArgumentName == argument.ArgumentName).First().ArgumentValue;
}
else
{
throw new ArgumentException($"Unable to assign the value of '{argument.ArgumentName}' to '{argument.AssignedVariable}' " +
"because no variable/argument with this name exists.");
}
}
}
//get updated app instance dictionary after the new engine finishes running
parentAutomationEngineIntance.AutomationEngineContext.AppInstances = childEngine.AutomationEngineContext.AppInstances;
//get errors from new engine (if any)
var newEngineErrors = childEngine.ErrorsOccured;
if (newEngineErrors.Count > 0 && !(parentAutomationEngineIntance.LastExecutedCommand.CommandName == "RunTaskCommand" && parentAutomationEngineIntance.LastExecutedCommand.v_ErrorHandling == "Ignore Error"))
{
parentAutomationEngineIntance.ChildScriptFailed = true;
foreach (var error in newEngineErrors)
{
parentAutomationEngineIntance.ErrorsOccured.Add(error);
}
}
}
private void UpdateCurrentEngineContext(IAutomationEngineInstance parentAutomationEngineIntance, IAutomationEngineInstance childAutomationEngineInstance)
{
parentAutomationEngineIntance.EngineContext.SessionVariables = childAutomationEngineInstance.EngineContext.SessionVariables;
var parentVariableList = parentAutomationEngineIntance.EngineContext.Variables;
var parentArgumentList = parentAutomationEngineIntance.EngineContext.Arguments;
//get new argument list from the new task engine after it finishes running
var childArgumentList = childAutomationEngineInstance.EngineContext.Arguments;
foreach (var argument in _argumentList)
{
if ((argument.Direction == ScriptArgumentDirection.Out || argument.Direction == ScriptArgumentDirection.InOut) &&
!string.IsNullOrEmpty(argument.AssignedVariable))
{
var assignedParentVariable = parentVariableList.Where(v => v.VariableName == argument.AssignedVariable).FirstOrDefault();
var assignedParentArgument = parentArgumentList.Where(a => a.ArgumentName == argument.AssignedVariable).FirstOrDefault();
if (assignedParentVariable != null)
{
var newVarValue = childArgumentList.Where(a => a.ArgumentName == argument.ArgumentName).First().ArgumentValue;
newVarValue.SetVariableValue(parentAutomationEngineIntance, assignedParentVariable.VariableName);
}
else if (assignedParentArgument != null)
{
var newArgValue = childArgumentList.Where(a => a.ArgumentName == argument.ArgumentName).First().ArgumentValue;
newArgValue.SetVariableValue(parentAutomationEngineIntance, assignedParentArgument.ArgumentName);
}
else
{
throw new ArgumentException($"Unable to assign the value of '{argument.ArgumentName}' to '{argument.AssignedVariable}' " +
"because no variable/argument with this name exists.");
}
}
}
//get errors from new engine (if any)
var newEngineErrors = childAutomationEngineInstance.ErrorsOccured;
if (newEngineErrors.Count > 0 && v_ErrorHandling != "Ignore Error")
{
parentAutomationEngineIntance.ChildScriptFailed = true;
foreach (var error in newEngineErrors)
{
parentAutomationEngineIntance.ErrorsOccured.Add(error);
}
}
}
private async Tasks.Task InitializeArgumentLists(IAutomationEngineInstance parentAutomationEngineInstance)
{
_argumentList = new List <ScriptArgument>();
foreach (DataRow rw in v_ArgumentAssignments.Rows)
{
var argumentName = (string)rw.ItemArray[0];
var argumentType = (Type)rw.ItemArray[1];
object argumentValue = null;
var argumentDirection = (string)rw.ItemArray[3];
if (argumentDirection == "In" || argumentDirection == "InOut")
{
argumentValue = await((string)rw.ItemArray[2]).EvaluateCode(parentAutomationEngineInstance);
_argumentList.Add(new ScriptArgument
{
ArgumentName = argumentName,
Direction = (ScriptArgumentDirection)Enum.Parse(typeof(ScriptArgumentDirection), argumentDirection),
ArgumentValue = argumentValue,
ArgumentType = argumentType
});
}
if (argumentDirection == "Out" || argumentDirection == "InOut")
{
//verify whether the assigned variable/argument exists
await((string)rw.ItemArray[2]).EvaluateCode(parentAutomationEngineInstance);
var existingArg = _argumentList.Where(x => x.ArgumentName == argumentName).FirstOrDefault();
if (existingArg != null)
{
existingArg.AssignedVariable = (string)rw.ItemArray[2];
}
else
{
_argumentList.Add(new ScriptArgument
{
ArgumentName = argumentName,
Direction = (ScriptArgumentDirection)Enum.Parse(typeof(ScriptArgumentDirection), argumentDirection),
AssignedVariable = (string)rw.ItemArray[2],
ArgumentType = argumentType
});
}
}
}
}
public static string GetJobId(IAutomationEngineInstance engine)
{
var sessionVariablesDict = engine.EngineContext.SessionVariables;
object value;
if (sessionVariablesDict != null && sessionVariablesDict.Count > 0)
{
bool keyExists = sessionVariablesDict.TryGetValue("JobId", out value);
if (keyExists)
{
return(value.ToString());
}
}
return(null);
}
public static object GetAppInstance(this string instanceName, IAutomationEngineInstance engine)
{
try
{
if (engine.AutomationEngineContext.AppInstances.TryGetValue(instanceName, out object appObject))
{
return(appObject);
}
throw new Exception("App Instance '" + instanceName + "' not found!");
}
catch (Exception ex)
{
throw ex;
}
}
public static void SetVariableValue(this object newVal, IAutomationEngineInstance engine, string varName)
{
engine.EngineContext.EngineScriptState.Variables.Where(x => x.Name == varName).FirstOrDefault().Value = newVal;
var existingVar = engine.EngineContext.Variables.Where(x => x.VariableName == varName).FirstOrDefault();
if (existingVar != null)
{
existingVar.VariableValue = newVal;
}
var existingArg = engine.EngineContext.Arguments.Where(x => x.ArgumentName == varName).FirstOrDefault();
if (existingArg != null)
{
existingArg.ArgumentValue = newVal;
}
}
public static object ConvertUserVariableToObject(this string varArgName, IAutomationEngineInstance engine, Type compatibleType)
{
ScriptVariable requiredVariable;
ScriptArgument requiredArgument;
if (varArgName.StartsWith("{") && varArgName.EndsWith("}"))
{
//reformat and attempt
var reformattedVarArg = varArgName.Replace("{", "").Replace("}", "");
requiredVariable = engine.AutomationEngineContext.Variables
.Where(var => var.VariableName == reformattedVarArg)
.FirstOrDefault();
if (requiredVariable != null && !compatibleType.IsAssignableFrom(requiredVariable.VariableType) && compatibleType != requiredVariable.VariableType)
{
throw new ArgumentException($"The type of variable '{requiredVariable.VariableName}' is not compatible.");
}
requiredArgument = engine.AutomationEngineContext.Arguments
.Where(arg => arg.ArgumentName == reformattedVarArg)
.FirstOrDefault();
if (requiredArgument != null && !compatibleType.IsAssignableFrom(requiredArgument.ArgumentType) && compatibleType != requiredArgument.ArgumentType)
{
throw new ArgumentException($"The type of argument '{requiredArgument.ArgumentName}' is not compatible.");
}
}
else
{
throw new Exception("Variable/Argument markers '{}' missing. Variable/Argument '" + varArgName + "' could not be found.");
}
if (requiredVariable != null)
{
return(requiredVariable.VariableValue);
}
else if (requiredArgument != null)
{
return(requiredArgument.ArgumentValue);
}
else
{
return(null);
}
}
private async Task <OleDbConnection> CreateConnection(IAutomationEngineInstance engine)
{
var connection = (string)await v_ConnectionString.EvaluateCode(engine);
var connectionSecurePass = (SecureString)await v_ConnectionStringPassword.EvaluateCode(engine);
var connectionPass = "";
if (connectionSecurePass != null)
{
connectionPass = connectionSecurePass.ConvertSecureStringToString();
}
connection = connection.Replace("#pwd", connectionPass);
return(new OleDbConnection(connection));
}
public static void RemoveAppInstance(this string instanceName, IAutomationEngineInstance engine)
{
try
{
if (engine.AutomationEngineContext.AppInstances.ContainsKey(instanceName))
{
engine.AutomationEngineContext.AppInstances.Remove(instanceName);
}
else
{
throw new Exception("App Instance '" + instanceName + "' not found!");
}
}
catch (Exception ex)
{
throw ex;
}
}
public async static Task <object> EvaluateCode(this string code, IAutomationEngineInstance engine)
{
if (string.IsNullOrEmpty(code))
{
return(null);
}
if (engine.EngineContext.EngineScriptState == null)
{
engine.EngineContext.EngineScriptState = await engine.EngineContext.EngineScript.RunAsync();
}
string script = $"object {engine.EngineContext.GuidPlaceholder} = {code};";
engine.EngineContext.EngineScriptState = await engine.EngineContext.EngineScriptState
.ContinueWithAsync(script);
return(engine.EngineContext.EngineScriptState.GetVariable($"{engine.EngineContext.GuidPlaceholder}").Value);
}
public static UserInfo RefreshToken(IAutomationEngineInstance engine)
{
var sessionVariablesDict = engine.EngineContext.SessionVariables;
UserInfo userInfo = (UserInfo)sessionVariablesDict["UserInfo"];
sessionVariablesDict.Remove("UserInfo");
//use refresh token and get new auth/refresh tokens
var environmentSettings = new EnvironmentSettings();
environmentSettings.Load();
AuthMethods authMethods = new AuthMethods();
authMethods.Initialize(environmentSettings.ServerType, environmentSettings.OrganizationName, environmentSettings.ServerUrl, environmentSettings.Username, environmentSettings.Password, environmentSettings.AgentId);
authMethods.RefreshToken(userInfo);
return(userInfo);
}
public static void StoreInUserVariable(this object varArgValue, IAutomationEngineInstance engine, string varArgName, Type compatibleType)
{
if (varArgName.StartsWith("{") && varArgName.EndsWith("}"))
{
varArgName = varArgName.Replace("{", "").Replace("}", "");
}
else
{
throw new Exception("Variable/Argument markers '{}' missing. '" + varArgName + "' is an invalid output variable/argument name.");
}
var existingVariable = engine.AutomationEngineContext.Variables
.Where(var => var.VariableName == varArgName)
.FirstOrDefault();
if (existingVariable != null && !compatibleType.IsAssignableFrom(existingVariable.VariableType) && compatibleType != existingVariable.VariableType)
{
throw new ArgumentException($"The type of variable '{existingVariable.VariableName}' is not compatible.");
}
else if (existingVariable != null)
{
existingVariable.VariableValue = varArgValue;
return;
}
var existingArgument = engine.AutomationEngineContext.Arguments
.Where(arg => arg.ArgumentName == varArgName)
.FirstOrDefault();
if (existingArgument != null && !compatibleType.IsAssignableFrom(existingArgument.ArgumentType) && compatibleType != existingArgument.ArgumentType)
{
throw new ArgumentException($"The type of argument '{existingArgument.ArgumentName}' is not compatible.");
}
else if (existingArgument != null)
{
existingArgument.ArgumentValue = varArgValue;
return;
}
throw new ArgumentNullException($"No variable/argument with the name '{varArgName}' was found.");
}
public static Type GetVarArgType(this string varArgName, IAutomationEngineInstance engine)
{
ScriptVariable requiredVariable;
if (varArgName.StartsWith("{") && varArgName.EndsWith("}"))
{
//reformat and attempt
var reformattedVarArg = varArgName.Replace("{", "").Replace("}", "");
var variableList = engine.AutomationEngineContext.Variables;
var systemVariables = CommonMethods.GenerateSystemVariables();
var argumentsAsVariablesList = engine.AutomationEngineContext.Arguments.Select(arg => new ScriptVariable
{
VariableName = arg.ArgumentName,
VariableType = arg.ArgumentType,
VariableValue = arg.ArgumentValue
})
.ToList();
var variableSearchList = new List <ScriptVariable>();
variableSearchList.AddRange(variableList);
variableSearchList.AddRange(systemVariables);
variableSearchList.AddRange(argumentsAsVariablesList);
requiredVariable = variableSearchList.Where(var => var.VariableName == reformattedVarArg).FirstOrDefault();
}
else
{
throw new Exception("Variable/Argument markers '{}' missing. Variable/Argument '" + varArgName + "' could not be found.");
}
if (requiredVariable != null)
{
return(requiredVariable.VariableType);
}
else
{
return(null);
}
}
public static void SetAuthSessionVariables(IAutomationEngineInstance engine, UserInfo userInfo)
{
var sessionVariablesDict = engine.EngineContext.SessionVariables;
object sessionUserInfo;
bool keyExists = sessionVariablesDict.TryGetValue("UserInfo", out sessionUserInfo);
if (!keyExists)
{
sessionVariablesDict.Add("UserInfo", userInfo);
}
else
{
var originalUserInfo = (UserInfo)sessionUserInfo;
string token = originalUserInfo.Token;
if (token != userInfo.Token)
{
sessionVariablesDict.Remove("UserInfo");
sessionVariablesDict.Add("UserInfo", userInfo);
}
}
}
public static UserInfo GetUserInfo(IAutomationEngineInstance engine)
{
var environmentSettings = new EnvironmentSettings();
environmentSettings.Load();
AuthMethods authMethods = new AuthMethods();
authMethods.Initialize(environmentSettings.ServerType, environmentSettings.OrganizationName, environmentSettings.ServerUrl, environmentSettings.Username, environmentSettings.Password, environmentSettings.AgentId);
var sessionVariablesDict = engine.EngineContext.SessionVariables;
object sessionUserInfo;
bool keyExists = sessionVariablesDict.TryGetValue("UserInfo", out sessionUserInfo);
if (!keyExists)
{
sessionUserInfo = authMethods.GetUserInfo();
SetAuthSessionVariables(engine, (UserInfo)sessionUserInfo);
}
return((UserInfo)sessionUserInfo);
}
private async Task Reply(IAutomationEngineInstance engine, MailItem mail, string body)
{
if (v_BodyType == "HTML")
{
mail.HTMLBody = body;
}
else
{
mail.Body = body;
}
if (!string.IsNullOrEmpty(v_Attachments))
{
var vAttachment = (List <string>) await v_Attachments.EvaluateCode(engine);
foreach (var attachment in vAttachment)
{
mail.Attachments.Add(attachment);
}
}
mail.Send();
}
public static void AddAppInstance(this object appObject, IAutomationEngineInstance engine, string instanceName)
{
if (engine.AutomationEngineContext.AppInstances.ContainsKey(instanceName) && engine.EngineSettings.OverrideExistingAppInstances)
{
engine.AutomationEngineContext.AppInstances.Remove(instanceName);
}
else if (engine.AutomationEngineContext.AppInstances.ContainsKey(instanceName) && !engine.EngineSettings.OverrideExistingAppInstances)
{
throw new Exception("App Instance already exists and override has been disabled in engine settings! " +
"Enable override existing app instances or use unique instance names!");
}
try
{
engine.AutomationEngineContext.AppInstances.Add(instanceName, appObject);
}
catch (Exception ex)
{
throw ex;
}
}
private async Tasks.Task <bool> DetermineMultiStatementTruth(IAutomationEngineInstance engine)
{
bool isTrueStatement = true;
foreach (DataRow rw in v_WhileConditionsTable.Rows)
{
var commandData = rw["CommandData"].ToString();
var whileCommand = JsonConvert.DeserializeObject <BeginWhileCommand>(commandData);
bool statementResult;
if (whileCommand.v_Option == "Builder")
{
statementResult = await CommandsHelper.DetermineStatementTruth(engine, whileCommand.v_ActionType, whileCommand.v_ActionParameterTable);
}
else
{
statementResult = (bool)await whileCommand.v_Condition.EvaluateCode(engine);
}
if (!statementResult && v_LogicType == "And")
{
isTrueStatement = false;
break;
}
if (statementResult && v_LogicType == "Or")
{
isTrueStatement = true;
break;
}
else if (v_LogicType == "Or")
{
isTrueStatement = false;
}
}
return(isTrueStatement);
}
/// <summary>
/// Replaces variable placeholders ({variable}) with variable text.
/// </summary>
/// <param name="sender">The script engine instance (AutomationEngineInstance) which contains session variables.</param>
public static string ConvertUserVariableToString(this string userInputString, IAutomationEngineInstance engine, bool requiresMarkers = true)
{
if (string.IsNullOrEmpty(userInputString))
{
return(string.Empty);
}
if (engine == null)
{
return(userInputString);
}
if (userInputString.Length < 2)
{
return(userInputString);
}
var variableList = engine.AutomationEngineContext.Variables;
var systemVariables = CommonMethods.GenerateSystemVariables();
var argumentsAsVariablesList = engine.AutomationEngineContext.Arguments.Select(arg => new ScriptVariable {
VariableName = arg.ArgumentName,
VariableType = arg.ArgumentType,
VariableValue = arg.ArgumentValue
})
.ToList();
var variableSearchList = new List <ScriptVariable>();
variableSearchList.AddRange(variableList);
variableSearchList.AddRange(systemVariables);
variableSearchList.AddRange(argumentsAsVariablesList);
//variable markers
string startVariableMarker = "{";
string endVariableMarker = "}";
if ((!userInputString.Contains(startVariableMarker) || !userInputString.Contains(endVariableMarker)) && requiresMarkers)
{
return(userInputString.CalculateVariables(engine));
}
//split by custom markers
string[] potentialVariables = userInputString.Split(new string[] { startVariableMarker, endVariableMarker }, StringSplitOptions.None);
foreach (var potentialVariable in potentialVariables)
{
if (potentialVariable.Length == 0)
{
continue;
}
string varcheckname = potentialVariable;
bool isSystemVar = systemVariables.Any(vars => vars.VariableName == varcheckname);
if (potentialVariable.Split('.').Length >= 2 && !isSystemVar)
{
varcheckname = potentialVariable.Split('.')[0];
}
var varCheck = variableSearchList.Where(v => v.VariableName == varcheckname)
.FirstOrDefault();
if (potentialVariable == "OpenBots.EngineContext")
{
varCheck.VariableValue = engine.GetEngineContext();
}
if (varCheck != null)
{
var searchVariable = startVariableMarker + potentialVariable + endVariableMarker;
if (userInputString.Contains(searchVariable))
{
if (varCheck.VariableType == typeof(string) || varCheck.VariableType.IsPrimitive)
{
userInputString = userInputString.Replace(searchVariable, varCheck.VariableValue?.ToString());
}
else if (varCheck.VariableValue is List <string> && potentialVariable.Split('.').Length == 2)
{
//get data from a string list using the index
string listIndexString = potentialVariable.Split('.')[1].ConvertUserVariableToString(engine, false);
var list = varCheck.VariableValue as List <string>;
string listItem;
if (int.TryParse(listIndexString, out int listIndex))
{
listItem = list[listIndex].ToString();
}
else
{
return(userInputString);
}
userInputString = userInputString.Replace(searchVariable, listItem);
}
else if (varCheck.VariableValue is DataRow && potentialVariable.Split('.').Length == 2)
{
//get data from a datarow using the column name/index
string columnName = potentialVariable.Split('.')[1].ConvertUserVariableToString(engine, false);
var row = varCheck.VariableValue as DataRow;
string cellItem;
if (int.TryParse(columnName, out var columnIndex))
{
cellItem = row[columnIndex].ToString();
}
else
{
cellItem = row[columnName].ToString();
}
userInputString = userInputString.Replace(searchVariable, cellItem);
}
else if (varCheck.VariableValue is DataTable && potentialVariable.Split('.').Length == 3)
{
//get data from datatable using the row index and column name/index
string rowIndexString = potentialVariable.Split('.')[1].ConvertUserVariableToString(engine, false);
string columnName = potentialVariable.Split('.')[2].ConvertUserVariableToString(engine, false);
var dt = varCheck.VariableValue as DataTable;
string cellItem;
if (int.TryParse(rowIndexString, out int rowIndex))
{
if (int.TryParse(columnName, out int columnIndex))
{
cellItem = dt.Rows[rowIndex][columnIndex].ToString();
}
else
{
cellItem = dt.Rows[rowIndex][columnName].ToString();
}
}
else
{
return(userInputString);
}
userInputString = userInputString.Replace(searchVariable, cellItem);
}
else if (varCheck.VariableValue?.GetType().Name == typeof(KeyValuePair <,>).Name && potentialVariable.Split('.').Length == 2)
{
//get data from a keyvaluepair using Key/Value
string resultType = potentialVariable.Split('.')[1].ConvertUserVariableToString(engine, false);
dynamic pair;
string resultItem;
pair = varCheck.VariableValue;
if (resultType.ToLower() == "key")
{
resultItem = pair.Key;
}
else if (resultType.ToLower() == "value")
{
resultItem = StringMethods.ConvertObjectToString(pair.Value, pair.Value.GetType());
}
else
{
throw new DataException("Only use of Key and Value is allowed using dot operater with KeyValuePair");
}
userInputString = userInputString.Replace(searchVariable, resultItem);
}
}
else if (!requiresMarkers)
{
if (varCheck.VariableValue is string)
{
userInputString = userInputString.Replace(potentialVariable, (string)varCheck.VariableValue);
}
}
}
else if (varCheck == null && userInputString.Contains(startVariableMarker + varcheckname + endVariableMarker))
{
throw new ArgumentNullException($"No variable/argument with the name '{varcheckname}' was found.");
}
}
return(userInputString.CalculateVariables(engine));
}
