static IExpressionTreeNode <double> BuildExpressionTree(string expression, IVariableProvider <double> variableProvider)
{
var tokenizer = new ExpressionTokenizer(AbstractTokenParser.DefaultTokenParserChain);
var tokenizedExpression = tokenizer.Tokenize(expression);
var expressionTree = ExpressionTreeBuilder.BuildTree(tokenizedExpression, variableProvider);
return(expressionTree);
}
public void ToBinaryTree_PropertyNotExists()
{
var filter = new Dictionary <string, string> {
{ "p", "d" }
};
ExpressionTreeBuilder.BuildBinaryTreeExpression <TestClass>(filter).ShouldBeNull();
}
public async Task IsExpressionVisitorResultEqualToCompiledExpression(string expression)
{
var serviceCollection = new ServiceCollection();
serviceCollection.AddScoped <ICalculator, DirectCalculator>();
var compiledResult = Expression.Lambda <Func <double> >(ExpressionTreeBuilder.Build(expression)).Compile()();
var visitorResult = await CalculatorExpression.Calculator.CalculateAsync(expression, serviceCollection);
Assert.Equal(compiledResult, visitorResult);
}
public CalculationEngine()
{
this.formulaCache = new Dictionary <string, Delegate>();
this.FunctionRegistry = new FunctionRegistry();
this.ConstantRegistry = new ConstantRegistry();
expressionBuilder = new ExpressionTreeBuilder();
optimizer = new Optimizer(new Interpreter()); // We run the optimizer with the interpreter
RegisterDefaultConstants();
RegisterDefaultFunctions();
}
/// <summary>
/// Evaluates the result value for the provided math expression.
/// </summary>
/// <param name="s">Input string (math expression in Infix notation).</param>
/// <returns>Result of evaluation of the expression.</returns>
public double Evaluate(string s)
{
if (string.IsNullOrEmpty(s))
{
throw new ArgumentException("Value cannot be null or empty.", nameof(s));
}
var builder = new ExpressionTreeBuilder();
var expr = builder.Build(s);
var visitor = new MathExpressionVisitor();
var result = visitor.Visit(expr);
return(result);
}
public async Task <IActionResult> TEST([FromQuery] string propName, string filterValue, string operand, string likeFilter)
{
if (!string.IsNullOrWhiteSpace(likeFilter))
{
var query1 = _ctx.Persons.Where(t => EF.Functions.Like(t.Name, $"%{likeFilter}%"));
var sql = query1.ToSql().Replace("\r\n", " ");
var result = await query1.ToListAsync();
return(Ok(new { GeneratedSql = sql, result }));
}
var helper = new ExpressionTreeBuilder <Person>();
var dn = helper.GetDynamicQueryWithExpressionTrees(propName, filterValue, operand);
var otherdn = helper.GetDynamicQueryWithExpressionTrees("gender", "1", "==");
var query = _ctx.Persons as IQueryable <Person>;
query = query.Where(dn);
query = query.Where(otherdn);
query = query.AsNoTracking();
var enumquer = query.AsQueryable();
try
{
var sql = query.ToSql().Replace("\r\n", " ");
var result = enumquer.ToList();
return(Ok(new { GeneratedSql = sql, result }));
}
catch (Exception e)
{
return(BadRequest(e.Message));
}
return(NoContent());
}
public Task <IEnumerable <TEntity> > GetAll(Pagination <TEntity> pagination)
{
var data = LiteDbUtility.Query <IEnumerable <TEntity> >(_dbName, db =>
{
var col = db.GetCollection <TEntity>();
if (pagination == null)
{
return(col.FindAll().ToArray());
}
var query = ExpressionTreeBuilder.BuildBinaryTreeExpression <TEntity>(pagination.QueryOrFilter);
if (query == null)
{
return(null);
}
return(col.Find(query).ToArray());
});
return(Task.FromResult(data));
}
public void ToBinaryTree_BuildsExpression()
{
var col = new[]
{
new TestClass {
Id = "1", NumericValue = 1, StringValue = "1"
},
new TestClass {
Id = "2", NumericValue = 1, StringValue = "2"
},
new TestClass {
Id = "3", NumericValue = 3
},
};
var filter1 = new Dictionary <string, string> {
{ nameof(TestClass.NumericValue), "1" }
};
var f1 = ExpressionTreeBuilder.BuildBinaryTreeExpression <TestClass>(filter1);
f1.ShouldNotBeNull();
var res1 = col.Where(f1).ToArray();
res1.Count().ShouldBe(2);
var filter2 = new Dictionary <string, string> {
{ nameof(TestClass.StringValue), "1" },
{ nameof(TestClass.NumericValue), "1" },
};
var f2 = ExpressionTreeBuilder.BuildBinaryTreeExpression <TestClass>(filter2);
f2.ShouldNotBeNull();
var res2 = col.Where(f2).ToArray();
res2.Count().ShouldBe(1);
}
public void ToBinaryTree_FromString(string query, string expResult)
{
var e = ExpressionTreeBuilder.BuildBinaryTreeExpression(typeof(TestClass), query);
e.ToString().ShouldBe(expResult);
}
[InlineData("\"this-is-id\" == id")] // property name is second
public void ToBinaryTree_FromString_ReturnsNull(string query)
{
ExpressionTreeBuilder.BuildBinaryTreeExpression(typeof(TestClass), query).ShouldBeNull();
}
public void ToBinaryTree_EmptyOrNullFilter_ReturnsNull(IDictionary <string, string> filter)
{
ExpressionTreeBuilder.BuildBinaryTreeExpression <TestClass>(filter).ShouldBeNull();
}
public void Init()
{
_factory = new ExpressionTreeBuilder();
}
public Validator()
{
_postfixConverter = new Postfixer(new TokenParser());
_treeBuilder = new ExpressionTreeBuilder();
_validationConditionResultDictionary = new Dictionary <int, bool>();
}
private async Task <Pagination <TEntity> > NormalizePagination(Pagination <TEntity> pagination)
{
var p = pagination ??= new Pagination <TEntity>();
if (!p.QueryOrFilter.HasValue() && p.QueryFunc == null)
{
p.QueryFunc = x => true;
}
var filter = p.QueryOrFilter.HasValue() ?
await FilterFactory.GetFilter <TEntity>(p.QueryOrFilter) : null;
if (filter != null)
{
var f = filter(new object());//payload is not supported yet
if (f == null)
{
return(null);
}
p.QueryFunc = c => f(c);
}
else
{
if (p.QueryFunc == null) //build only if func not exists
{
var right = ExpressionTreeBuilder.BuildBinaryTreeExpression <TEntity>(p.QueryOrFilter)?.Compile();
if (right == null)
{
return(null);
}
var ecr = WorkContext.CurrentEntityConfigRecord;
if (Config.ManageEntityPermissions)
{
var permittedIds = await PermissionManager.GetPermittedIds(WorkContext.CurrentUserId, ecr.EntityKey, ecr.PermissionRecord.ReadKey);
Func <TEntity, bool> left = a => permittedIds.Contains(a.Id);
p.QueryFunc = x => left(x) && right(x);
}
else
{
p.QueryFunc = x => right(x);
}
}
}
if (p.QueryFunc == null)
{
return(null);
}
if (!CurrentEntityConfigRecord.Metadata.ShowSoftDeleted && CurrentEntityConfigRecord.Metadata.IsSoftDeleted)
{
p.QueryFunc = p.QueryFunc.AndAlso(HideSoftDeletedFunc);
}
var paginationSettings = WorkContext.CurrentEntityConfigRecord.PaginationSettings;
p.OrderBy ??= paginationSettings.DefaultOrderBy;
p.Offset = p.Offset != 0 ? p.Offset : paginationSettings.DefaultOffset;
p.PageSize = p.PageSize != 0 ? p.PageSize : paginationSettings.DefaultPageSize;
p.IncludeNested = p.IncludeNested;
p.SortOrder ??= paginationSettings.DefaultSortOrder;
return(p);
}
