/// <summary>
/// notice to trim() _params
/// </summary>
/// <param name="className"></param>
/// <param name="functionName"></param>
/// <param name="_params">need to call Trim()</param>
/// <param name="ucParams"></param>
/// <returns></returns>
public void DoGenRawScripts(string className, string functionName, string[] _params, bool voidReturn,
UserCodeScriptGenerationParams ucParams, UserCodeScriptsExpression re, ScriptType scriptType = ScriptType.Normal)
{
string expressionRe = GetComment(ucParams) + NEW_LINE;
if (!voidReturn)
{
re.GlobalScripts = "object " + ucParams.SpecNode.Expression + ";";
expressionRe += ucParams.SpecNode.Expression + " = ";
}
expressionRe += className + "." + functionName + "(";
if (_params != null)
{
string tempParamsExp = "";
foreach (string param in _params)
{
string param1 = param.Trim();
if (param1.Equals(""))
{
continue;
}
if (tempParamsExp != "")
{
tempParamsExp += ", ";
}
tempParamsExp += ParamExp2String(param1, ucParams.ListUIElements, ucParams.MapAliasWithNode,
ucParams.MyLog, ucParams.InstanceName, scriptType);
}
expressionRe += tempParamsExp;
}
expressionRe += ");";
re.Expression = expressionRe;
}
public override ScriptsExpression HandleAndGenScripts(IScriptGenerationParams scriptGenerationParams, ScriptType scriptType = ScriptType.Normal)
{
string re = GetComment(scriptGenerationParams) + NEW_LINE;
if (scriptGenerationParams is ValidationUCScriptGenerationParams param)
{
string newFunctionContent = "";
if (param.SpecNode.Attribute == null ||
param.SpecNode.Attribute == "")
{
param.SpecNode.Attribute = TEXT;
}
foreach (string exp in param.ListExps)
{
if (newFunctionContent != "")
{
newFunctionContent += NEW_LINE;
}
if (scriptType == ScriptType.Normal)
{
newFunctionContent += ValidationSpecUserAction.GetRawScripts(param, exp).Expression;
}
else if (scriptType == ScriptType.Ranorex)
{
newFunctionContent += ValidationSpecUserAction.GetRawRanorexScripts(param as IRanorexScriptGenerationParams, exp).Expression;
}
}
string newClassName = param.ClassName;
string newFuncName = param.FunctionName;
re += newClassName + "." + newFuncName + "();";
var pair = CheckFunctionExisted(param.ClassExpressions, newClassName, newFuncName, 0, true);
// if not existed
if (!pair.Item1)
{
FunctionExpression func = new FunctionExpression(newFuncName);
func.setContent(newFunctionContent);
UserCodeScriptsExpression re1 = new UserCodeScriptsExpression(re);
re1.MapClassAndFuncsAddition = new Dictionary <string, List <FunctionExpression> >
{
{ newClassName, new List <FunctionExpression>()
{
func
} }
};
return(re1);
}
return(new ScriptsExpression(re));
}
else
{
re += ValidationSpecUserAction.GetRawScripts(scriptGenerationParams, this.Expression).Expression;
return(new ScriptsExpression(re));
}
}
public static void MergeUcScriptsEpx(List <UserCodeScriptsExpression> listUcScriptsEpx, UserCodeScriptsExpression ucScriptsEpx)
{
var addition = ucScriptsEpx.MapClassAndFuncsAddition;
foreach (UserCodeScriptsExpression existed in listUcScriptsEpx.ToList())
{
var @base = existed.MapClassAndFuncsAddition;
MergeClassAndFuncPairs(@base, addition);
}
}
public virtual ScriptsExpression HandleAndGenScripts(IScriptGenerationParams scriptGenerationParams, ScriptType scriptType = ScriptType.Normal)
{
if (scriptGenerationParams is UserCodeScriptGenerationParams ucParams)
{
Regex regex = new Regex("(?<class_group>.*?)\\.(?<func_group>.*)");
Match match = regex.Match(expression);
if (match.Success)
{
string className = match.Groups["class_group"].Value;
string funcName = match.Groups["func_group"].Value;
Regex regex2 = new Regex("(?<func_group>.*)\\((?<params_group>.*)\\)$");
Match match2 = regex2.Match(funcName);
int paramsCount = 0;
string[] _params = null;
if (match2.Success && match2.Groups["params_group"] != null &&
match2.Groups["params_group"].Value.Trim() != "")
{
funcName = match2.Groups["func_group"].Value;
_params = match2.Groups["params_group"].Value.Split(',');
paramsCount = _params.Count();
}
bool voidReturn = true;
if (Regex.IsMatch(ucParams.SpecNode.Expression, USER_CODE_WITH_VARIABLE_DECLARE))
{
voidReturn = false;
}
else if (!Regex.IsMatch(ucParams.SpecNode.Expression, AbstractSpecUserAction.USER_CODE))
{
logger.Error("Incorrect Expression: " + ucParams.SpecNode.Expression);
}
var re = new UserCodeScriptsExpression();
var pair = CheckFunctionExisted(ucParams.ClassExpressions, className, funcName, paramsCount, voidReturn);
if (!pair.Item1)
{
FunctionExpression func = new FunctionExpression(funcName);
if (_params != null)
{
foreach (string param in _params)
{
ParameterExpression parameterExpression = new ParameterExpression();
parameterExpression.setName(param);
if (func.getParams() == null)
{
func.setParams(new List <ParameterExpression>());
}
func.getParams().Add(parameterExpression);
}
}
func.setReturnDescription("no description");
ClassExpression classExpExisted = pair.Item2;
// if class existed
if (classExpExisted != null)
{
Utils.MergeFunctions(classExpExisted.getListFunction(), func);
}
else
{
re.AppendNewAdditionFunc(className, func);
}
}
DoGenRawScripts(className, funcName, _params, voidReturn, ucParams, re, scriptType);
return(re);
}
else
{
throw new NotImplementedException();
}
}
else
{
throw new NotImplementedException();
}
}
