private bool ExecuteRuleForDynamicJson(ISession session, RuleEngineRequestModel ruleEngineRequestModel)
{
var ruleModel = JsonConvert.DeserializeObject <ExecuteRuleRequestModel>(ruleEngineRequestModel.JsonData);
//foreach (var rule in ruleEngineRequestModel.Rules)
//{
// switch (rule.EntityType)
// {
// case EntityTypeEnum.Country:
// ruleModel = JsonConvert.DeserializeObject<ExecuteRuleRequestModel>(ruleEngineRequestModel.JsonData);
// break;
// case EntityTypeEnum.Aircraft:
// ruleModel.Aircraft = JsonConvert.DeserializeObject<AircraftRequestModel>(ruleEngineRequestModel.JsonData);
// break;
// case EntityTypeEnum.Airport:
// ruleModel.Airport = JsonConvert.DeserializeObject<AirportRequestModel>(ruleEngineRequestModel.JsonData);
// break;
// case EntityTypeEnum.Trips:
// ruleModel.Trip = JsonConvert.DeserializeObject<TripRequestModel>(ruleEngineRequestModel.JsonData);
// break;
// case EntityTypeEnum.Person:
// ruleModel = JsonConvert.DeserializeObject<ExecuteRuleRequestModel>(ruleEngineRequestModel.JsonData);
// break;
// }
//}
session.Insert(ruleModel);
return(session.Fire() == 1);
}
public async Task <bool> ExecuteRuleWithDynamicData(RuleEngineRequestModel ruleEngineRequestModel)
{
if (!ruleEngineRequestModel.Rules.Any())
{
return(false);
}
return(ExecuteRuleForDynamicJson(CompileRule(ruleEngineRequestModel), ruleEngineRequestModel));
}
public async Task <IActionResult> Put(RuleEngineRequestModel ruleEngineRequestModel)
{
var isSaved = await _ruleData.UpdateRule(ruleEngineRequestModel);
if (isSaved)
{
return(Ok(ruleEngineRequestModel));
}
return(BadRequest("bad request"));
}
private ISession CompileRule(RuleEngineRequestModel ruleEngineRequestModel)
{
foreach (var rule in ruleEngineRequestModel.Rules)
{
rule.EntityName.PropertyName = rule.EntityType.ToString();
}
_customRuleRepository.LoadRules <ExecuteRuleRequestModel>(ruleEngineRequestModel);
var factory = _customRuleRepository.Compile();
return(factory.CreateSession());
}
public async Task <bool> SaveRule(RuleEngineRequestModel ruleEngineRequestModel)
{
ruleEngineRequestModel.Rules.ForEach(rule =>
{
_ruleDbContext.RuleEngines.Add(_mapper.Map <Model.RuleEngine>(rule));
});
_ruleDbContext.NRules.Add(new NRule()
{
Name = ruleEngineRequestModel.RuleName
});
return(await _ruleDbContext.SaveChangesAsync() > 0);
}
public async Task <bool> ExecuteRuleWithDynamicDataAndByExistingRuleId(RuleEngineRequestModel ruleEngineRequestModel)
{
if (ruleEngineRequestModel.RuleId <= 0)
{
return(false);
}
var ruleEngines = _mapper.Map <IEnumerable <RuleEngineEntity> >(await _ruleDbContext.RuleEngines.Where(x => x.NRuleId == ruleEngineRequestModel.RuleId).ToListAsync());
if (!ruleEngines.Any())
{
return(false);
}
return(ExecuteRuleForDynamicJson(CompileRule(ruleEngineRequestModel), ruleEngineRequestModel));
}
public async Task <bool> UpdateRule(RuleEngineRequestModel ruleEngineRequestModel)
{
var nRule = await _ruleDbContext.NRules.FirstOrDefaultAsync(x => x.Id == ruleEngineRequestModel.RuleId);
if (nRule == null)
{
return(false);
}
nRule.Name = ruleEngineRequestModel.RuleName;
ruleEngineRequestModel.Rules.ForEach(rule =>
{
var dbRule = _ruleDbContext.RuleEngines.FirstOrDefault(x => x.Id == rule.Id);
if (dbRule != null)
{
_ruleDbContext.RuleEngines.Update(_mapper.Map(rule, dbRule));
}
});
return(await _ruleDbContext.SaveChangesAsync() > 0);
}
public async Task <IActionResult> ExecuteRuleWithDynamicDataAndByExistingRuleId(RuleEngineRequestModel ruleEngineRequestModel)
{
return(Ok(await _executeData.ExecuteRuleWithDynamicDataAndByExistingRuleId(ruleEngineRequestModel)));
}
private List <IRuleDefinition> BuildRule <T>(RuleEngineRequestModel ruleEngineRequestModel)
{
var builder = new RuleBuilder();
builder.Name("default");
var orGroup = builder.LeftHandSide().Group(GroupType.Or);
Expression expression = null;
var andGroup = orGroup.Group(GroupType.And);
PatternBuilder modelPattern = andGroup.Pattern(typeof(T), "x");
var modelParameter = modelPattern.Declaration.ToParameterExpression();
foreach (var item in ruleEngineRequestModel.Rules)
{
IDictionary <string, object> dictionary = item.EntityName;
var entityName = dictionary["PropertyName"];
var member = Expression.Property(modelParameter, entityName.ToString());
Expression condition = null;
switch (item.FilterOperation)
{
case FilterOperation.GreaterThan:
condition = Expression.GreaterThan(Expression.Property(member, item.PropertyName), Expression.Constant(Convert.ToInt32(item.Value.ToString())));
break;
case FilterOperation.GreaterThanOrEqualTo:
condition = Expression.GreaterThanOrEqual(Expression.Property(member, item.PropertyName), Expression.Constant(Convert.ToInt32(item.Value.ToString())));
break;
case FilterOperation.EqualTo:
if (Int32.TryParse(item.Value.ToString(), out int number))
{
condition = Expression.Equal(Expression.Property(member, item.PropertyName), Expression.Constant(Convert.ToInt32(item.Value.ToString())));
}
else if (Boolean.TryParse(item.Value.ToString(), out bool male))
{
condition = Expression.Equal(Expression.Property(member, item.PropertyName), Expression.Constant(Convert.ToBoolean(item.Value.ToString())));
}
else
{
condition = Expression.Equal(Expression.Property(member, item.PropertyName), Expression.Constant(item.Value.ToString().ToLower()));
}
break;
case FilterOperation.NotEqualTo:
if (Int32.TryParse(item.Value.ToString(), out int num))
{
condition = Expression.NotEqual(Expression.Property(member, item.PropertyName), Expression.Constant(Convert.ToInt32(item.Value.ToString())));
}
else if (Boolean.TryParse(item.Value.ToString(), out bool male))
{
condition = Expression.NotEqual(Expression.Property(member, item.PropertyName), Expression.Constant(Convert.ToBoolean(item.Value.ToString())));
}
else
{
condition = Expression.NotEqual(Expression.Property(member, item.PropertyName), Expression.Constant(item.Value.ToString().ToLower()));
}
break;
case FilterOperation.LessThan:
condition = Expression.LessThan(Expression.Property(member, item.PropertyName), Expression.Constant(Convert.ToInt32(item.Value.ToString())));
break;
case FilterOperation.LessThanOrEqualTo:
condition = Expression.LessThanOrEqual(Expression.Property(member, item.PropertyName), Expression.Constant(Convert.ToInt32(item.Value.ToString())));
break;
case FilterOperation.IsNull:
case FilterOperation.IsNotNull:
condition = Expression.Equal(Expression.Property(member, item.PropertyName), Expression.Constant(null));
break;
case FilterOperation.Contains:
var constantContainExpr = Expression.Constant(item.Value.ToString().ToLower());
condition = Expression.Call(Expression.Property(member, item.PropertyName), stringContainsMethod, constantContainExpr);
break;
case FilterOperation.StartsWith:
var constantStartExpr = Expression.Constant(item.Value.ToString().ToLower());
condition = Expression.Call(Expression.Property(member, item.PropertyName), stringStartsWithMethod, constantStartExpr);
break;
case FilterOperation.EndsWith:
var constantEndExpr = Expression.Constant(item.Value.ToString().ToLower());
condition = Expression.Call(Expression.Property(member, item.PropertyName), stringEndsWithMethod, constantEndExpr);
break;
case FilterOperation.Between:
var constant = Expression.Constant(item.Value.ToString().ToLower());
var constant2 = Expression.Constant(item.SecondValue.ToString().ToLower());
BinaryExpression leftBinaryExpression = null;
BinaryExpression rightBinaryExpression = null;
if (Int32.TryParse(item.Value.ToString(), out int idField))
{
leftBinaryExpression = Expression.GreaterThanOrEqual(Expression.Property(member, item.PropertyName), Expression.Constant(Convert.ToInt32(item.Value.ToString())));
rightBinaryExpression = Expression.LessThanOrEqual(Expression.Property(member, item.PropertyName), Expression.Constant(Convert.ToInt32(item.SecondValue.ToString())));
}
if (DateTime.TryParse(item.Value.ToString(), out DateTime dateTime))
{
leftBinaryExpression = Expression.GreaterThanOrEqual(Expression.Property(member, item.PropertyName), Expression.Constant(Convert.ToDateTime(item.Value.ToString())));
rightBinaryExpression = Expression.LessThanOrEqual(Expression.Property(member, item.PropertyName), Expression.Constant(Convert.ToDateTime(item.SecondValue.ToString())));
}
condition = CombineExpressions(leftBinaryExpression, rightBinaryExpression, FilterStatementConnector.And);
break;
case FilterOperation.In:
var values = new List <string>();
var obj = JsonConvert.DeserializeObject <string[]>(item.Value.ToString().ToLower());
values.AddRange(obj);
var constantInExpr = Expression.Constant(values);
condition = Contains(Expression.Property(member, item.PropertyName), constantInExpr);
break;
}
expression = expression == null ? condition : CombineExpressions(expression, condition, item.FilterConnector);
}
var finalexpression = Expression.Lambda(expression, modelParameter);
modelPattern.Condition(finalexpression);
Expression <Action <IContext> > action = ctx => Console.WriteLine("Action triggered");
builder.RightHandSide().Action(action);
var rule = builder.Build();
return(new List <IRuleDefinition> {
rule
});
}
public void LoadRules <T>(RuleEngineRequestModel list)
{
_ruleSet.Add(
BuildRule <T>(list)
);
}
