private void _RecurseExpression(IDataExpression exp, IDictionary <string, object> nameValuePairs, ref int totalUpdated)
{
if (totalUpdated < nameValuePairs.Count)
{
if (exp is ValueExpression)
{
var valueExp = exp as ValueExpression;
if (!valueExp.Name.IsNullOrEmpty() && nameValuePairs.ContainsKey(valueExp.Name))
{
valueExp.Value = nameValuePairs[valueExp.Name];
totalUpdated++;
}
}
if (exp is ICompositeExpression)
{
var compoundExp = exp as ICompositeExpression;
if (!compoundExp.Expressions.IsNullOrEmpty())
{
foreach (var childExp in compoundExp.Expressions)
{
_RecurseExpression(childExp, nameValuePairs, ref totalUpdated);
}
}
}
}
}
// ------------------------------------------
// EVALUATION
// ------------------------------------------
#region Evaluation
// Expression
/// <summary>
/// Evaluates the specified data expression.
/// </summary>
/// <param name="expression">The data expression to consider.</param>
/// <param name="scriptVariableSet">The script variable set to consider.</param>
/// <param name="log">The log to consider.</param>
/// <returns>Literal or script value according to the specified default mode.</returns>
public object Evaluate(
IDataExpression expression,
IScriptVariableSet scriptVariableSet = null,
IBdoLog log = null)
{
int index;
int scriptwordBeginIndex;
var script = expression?.Text ?? string.Empty;
switch (expression?.Kind)
{
case DataExpressionKind.Auto:
if (!string.IsNullOrEmpty(script))
{
var resultScript = script;
scriptwordBeginIndex = script.IndexOf("{{");
while (scriptwordBeginIndex > -1)
{
index = script.IndexOfNextString("}}", scriptwordBeginIndex + 1);
if ((scriptwordBeginIndex > -1) && (index > -1))
{
var subScript = script.Substring(2)[0..^ 2];
// Having -------------------------------------
/// <summary>
///
/// </summary>
public IDbSingleQuery Having(IDataExpression expression)
{
HavingClause = new DbQueryHavingClause()
{
Expression = expression as DataExpression
};
return(this);
}
/// <summary>
///
/// </summary>
public IDbSingleQuery GroupBy(IDataExpression expression)
{
GroupByClause = new DbQueryGroupByClause()
{
Expression = expression as DataExpression
};
return(this);
}
/// <summary>
///
/// </summary>
public IDbSingleQuery From(IDataExpression expression)
{
FromClause = new DbQueryFromClause()
{
Expression = expression as DataExpression
};
return(this);
}
// Where -------------------------------------
/// <summary>
///
/// </summary>
public IDbSingleQuery Where(IDataExpression expression)
{
var idFields = WhereClause?.IdFields;
WhereClause = new DbQueryWhereClause()
{
Expression = expression as DataExpression
};
WhereClause.IdFields = idFields;
return(this);
}
public static IDataExpression Create(Domain.Expression exp, IDataContext context)
{
IDataRepository<Domain.Expression> exprRepos = new EFDataRepository<Domain.Expression>(context);
var newExp = ExpressionFactory.Create((ExpressionType)exp.ExpressionTypeId);
IDataExpression outExp = newExp;
if (outExp is ICompositeExpression)
{
var compExp = newExp as ICompositeExpression;
var childExp = exprRepos.Query(x => x.ParentExpressionId == (long)exp.Id).ToArray();
if (!childExp.IsNullOrEmpty())
{
var childExpList = new List<IDataExpression>();
foreach (var child in childExp)
{
var newChild = _Create(child, context);
childExpList.Add(newChild);
}
compExp.Expressions = childExpList;
}
outExp = compExp;
}
if (outExp is ValueExpression)
{
var valExp = outExp as ValueExpression;
valExp.Value = BinarySerializer.Deserialize((NEMILTEC.Shared.Enums.Data.DataType)exp.DataTypeId, exp.Value);
outExp = valExp;
}
return outExp;
}
/// <summary>
/// Instantiates a new instance of the ScriptCondition class.
/// </summary>
/// <param name="trueValue">The true value to consider.</param>
/// <param name="expression">The expression to consider.</param>
public ScriptCondition(bool trueValue, IDataExpression expression) : base(trueValue)
{
Expression = expression as DataExpression;
}
