/// <summary>
/// Eliminates the empty nodes (nodes that consist of only logical elements).
/// </summary>
/// <param name="nodes">The nodes.</param>
/// <returns></returns>
protected virtual FilterExpressionNodeCollection EliminateEmptyNodes(FilterExpressionNodeCollection nodes)
{
FilterExpressionNodeCollection expressions = new FilterExpressionNodeCollection();
foreach (FilterExpressionNode node in nodes)
{
if (node.NodeType == FilterExpressionNodeType.Element ||
node.NodeType == FilterExpressionNodeType.MethodBlock)
{
expressions.Add(node);
}
else
{
// Only add node if it has the actual "Element's" and does not consist of only logical AND's and OR's
if (node.HasChildNodes)
{
FilterExpressionNodeCollection subTree = EliminateEmptyNodes(node.ChildNodes);
if (subTree != null && subTree.Count > 0)
{
expressions.Add(node);
}
}
}
}
return(expressions);
}
private FilterExpressionNodeCollection SaveFilters(string expressionKey)
{
FilterExpressionNodeCollection coll = ctrlFilter.NodeCollection;
ctrlFilter.Provider.SaveFilters(string.Format("{0}::{1}", _className, _placeName), expressionKey, ctrlFilter.NodeCollection[0].ChildNodes);
return(coll);
}
/// <summary>
/// Adds the expression as node.
/// </summary>
/// <param name="col">The col.</param>
/// <param name="expr">The expr.</param>
protected virtual void AddExpressionAsNode(ref FilterExpressionNodeCollection col, CodeExpression expr)
{
if (expr is CodeBinaryOperatorExpression)
{
AddExpressionAsNode(ref col, (CodeBinaryOperatorExpression)expr);
}
else if (expr is CodeMethodInvokeExpression)
{
col.Add(ConvertExpressionToNode((CodeMethodInvokeExpression)expr));
}
}
/// <summary>
/// Loads the expression.
/// </summary>
/// <param name="expressionId">The expression id.</param>
/// <returns></returns>
protected virtual FilterExpressionNodeCollection LoadExpressionNodeCollectionFromXaml(string xaml)
{
FilterExpressionNodeCollection col = new FilterExpressionNodeCollection();
if (!String.IsNullOrEmpty(xaml))
{
RuleSet rules = DeserializeRuleSet(xaml);
col = ConvertRuleSetToExpressionNodes(rules);
}
return(col);
}
/// <summary>
/// Converts the rule set to expression nodes.
/// </summary>
/// <param name="rules">The rules.</param>
/// <returns></returns>
protected virtual FilterExpressionNodeCollection ConvertRuleSetToExpressionNodes(RuleSet rules)
{
FilterExpressionNodeCollection col = new FilterExpressionNodeCollection();
foreach (Rule rule in rules.Rules)
{
if (rule.Condition != null)
{
CodeExpression expr = ((RuleExpressionCondition)rule.Condition).Expression;
AddExpressionAsNode(ref col, expr);
}
}
return(col);
}
protected virtual string ConvertNodesToStringExpression(FilterExpressionNodeCollection nodes, string separator)
{
FilterExpressionNodeCollection newNodes = EliminateEmptyNodes(nodes);
// If not nodes found return null
if (newNodes.Count == 0)
{
return(null);
}
// If only one node, return it as an expression
if (newNodes.Count == 1)
{
return(ConvertNodeToStringExpression(newNodes[0]));
}
// Start processing more than 1 node
string masterExpression = String.Empty;
//And block default
separator = separator ?? "&&";
foreach (FilterExpressionNode node in newNodes)
{
CodeBinaryOperatorExpression currentExpression = new CodeBinaryOperatorExpression();
if (node.NodeType == FilterExpressionNodeType.Element)
{
masterExpression = AddStringExpression(masterExpression, separator, ConvertNodeToStringExpression(node));
}
else if (node.NodeType == FilterExpressionNodeType.AndBlock)
{
masterExpression = AddStringExpression(masterExpression, separator, ConvertNodesToStringExpression(node.ChildNodes, "&&"));
}
else if (node.NodeType == FilterExpressionNodeType.OrBlock)
{
masterExpression = AddStringExpression(masterExpression, separator, ConvertNodesToStringExpression(node.ChildNodes, "||"));
}
else if (node.NodeType == FilterExpressionNodeType.MethodBlock)
{
masterExpression = AddStringExpression(masterExpression, separator, ConvertNodeToStringExpression(node));
}
}
return(string.Format("({0})", masterExpression));
}
protected virtual Rule CreateRule(string expressionKey, FilterExpressionNodeCollection filters)
{
Rule rule = new Rule();
//Mediachase.Web.Console.Providers.DomParser
CodeBinaryOperatorExpression expr = ConvertNodesToExpression(filters);
if (expr != null)
{
rule.Condition = new RuleExpressionCondition(expr);
}
/*
* CodeAssignStatement ruleSurchargeAction = new CodeAssignStatement(SurchargeRef, new CodePrimitiveExpression(500));
* carChargeRule.ThenActions.Add(new RuleStatementAction(ruleSurchargeAction));
* */
return(rule);
}
protected virtual IEnumerable <Rule> CreateRuleActions(string expressionKey, FilterExpressionNodeCollection filters)
{
int index = 0;
foreach (FilterExpressionNode filterExp in filters)
{
string expr = ConvertNodeToStringExpression(filterExp);
if (!String.IsNullOrEmpty(expr))
{
Parser p = new Parser();
Rule rule = new Rule();
rule.Active = true;
rule.Priority = index;
rule.Name = expressionKey + "_action" + index.ToString();
rule.ReevaluationBehavior = RuleReevaluationBehavior.Never;
//condition
// this.ValidationResult.IsValid == True
CodeThisReferenceExpression thisRef = new CodeThisReferenceExpression();
CodePropertyReferenceExpression resultRef = new CodePropertyReferenceExpression(thisRef, "ValidationResult");
CodePropertyReferenceExpression leftRef = new CodePropertyReferenceExpression(resultRef, "IsValid");
CodePrimitiveExpression righRef = new CodePrimitiveExpression(true);
CodeBinaryOperatorExpression isValidOperator = new CodeBinaryOperatorExpression();
isValidOperator.Operator = CodeBinaryOperatorType.ValueEquality;
isValidOperator.Left = leftRef;
isValidOperator.Right = righRef;
rule.Condition = new RuleExpressionCondition(isValidOperator);
//then action
rule.ThenActions.Add(new RuleStatementAction(p.ParseExpression(expr)));
index++;
yield return(rule);
}
}
}
/*
* public static RuleSet CreateRuleSet(string ruleSetName, FilterExpressionNodeCollection filters)
* {
* RuleSet customerRuleSet = new RuleSet(ruleSetName);
* customerRuleSet.ChainingBehavior = RuleChainingBehavior.None;
* customerRuleSet.Rules.Add(CreateRule(expressionKey, filters));
* return customerRuleSet;
* }
* */
/// <summary>
/// Creates the rule.
/// </summary>
/// <param name="stringRuleName">Name of the string rule.</param>
/// <param name="priority">The priority.</param>
/// <param name="filters">The filters.</param>
/// <returns></returns>
public static Rule CreateRule(string stringRuleName, int priority, FilterExpressionNodeCollection filters)
{
Rule rule = new Rule();
rule.Active = true;
rule.Priority = priority;
rule.Name = stringRuleName;
rule.ReevaluationBehavior = RuleReevaluationBehavior.Never;
//Mediachase.Web.Console.Providers.DomParser
string expr = ConvertNodesToStringExpression(filters);
if (!String.IsNullOrEmpty(expr))
{
Parser p = new Parser();
rule.Condition = new RuleExpressionCondition(p.ParseExpression(expr));
}
return(rule);
}
/// <summary>
/// Gets the new elements.
/// </summary>
/// <param name="expressionPlace">The expression place.</param>
/// <param name="parent"></param>
/// <returns></returns>
public override FilterExpressionNodeCollection GetNewElements(string expressionPlace, FilterExpressionNode parent)
{
FilterExpressionNodeCollection retVal = new FilterExpressionNodeCollection();
//set default group
string currentPromotionGroup = PromotionGroup.GetPromotionGroup(PromotionGroup.PromotionGroupKey.Order).Key;
string[] expressionPlaceParts = expressionPlace.Split(':');
if (expressionPlaceParts.Length != 0)
{
currentPromotionGroup = expressionPlaceParts[0];
}
IEnumerable <FilterExpressionNode> resultColl;
_filterElementsMap.TryGetValue(currentPromotionGroup, out resultColl);
if (resultColl != null)
{
retVal.AddRange(resultColl.Select(x => x.Clone()).ToArray());
}
return(retVal);
}
/// <summary>
/// Handles the Click event of the SaveButton control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="System.EventArgs"/> instance containing the event data.</param>
protected void SaveButton_Click(object sender, EventArgs e)
{
ExpressionDto dto = (ExpressionDto)HttpContext.Current.Session[_ExpressionDtoEditSessionKey];
if (dto != null)
{
ExpressionFilter = ExprFilter.NodeCollection[0].ChildNodes;
ExprFilter.Visible = true;
ExprFilter.DataSource = dto;
ExprFilter.Provider.SaveFilters(_RulesPrefix, ExpressionId.ToString(), ExpressionFilter);
ExpressionDto.ExpressionRow row = null;
if (ExpressionId == 0) // get the last row added
{
row = dto.Expression[dto.Expression.Count - 1];
}
else
{
row = dto.Expression.FindByExpressionId(ExpressionId);
}
row.Name = ExpressionName.Text;
}
else
{
ExprFilter.Visible = false;
}
////Serialize FilterExpression in segment table
//if (_SegmentDto != null && _SegmentDto.Segment.Count > 0)
//{
// SegmentDto.SegmentRow row = _SegmentDto.Segment[0];
// row.ExpressionFilter = SerializeFilterExpressions(ExpressionFilters);
//}
CommandParameters cp = new CommandParameters(_RuleEditCommandString);
CommandHandler.RegisterCloseOpenedFrameScript(this.Page, cp.ToString());
}
private static string ConvertNodesToStringExpression(FilterExpressionNodeCollection nodes)
{
FilterExpressionNodeCollection newNodes = EliminateEmptyNodes(nodes);
// If not nodes found return null
if (newNodes.Count == 0)
{
return(null);
}
// If only one node, return it as an expression
if (newNodes.Count == 1)
{
return(ConvertNodeToStringExpression(newNodes[0]));
}
// Start processing more than 1 node
string masterExpression = String.Empty;
foreach (FilterExpressionNode node in newNodes)
{
CodeBinaryOperatorExpression currentExpression = new CodeBinaryOperatorExpression();
if (node.NodeType == FilterExpressionNodeType.Element)
{
masterExpression = AddStringExpression(masterExpression, "&&", ConvertNodeToStringExpression(node));
}
else if (node.NodeType == FilterExpressionNodeType.AndBlock)
{
masterExpression = AddStringExpression(masterExpression, "&&", ConvertNodesToStringExpression(node.ChildNodes));
}
else if (node.NodeType == FilterExpressionNodeType.OrBlock)
{
masterExpression = AddStringExpression(masterExpression, "||", ConvertNodesToStringExpression(node.ChildNodes));
}
}
return(masterExpression);
}
protected virtual Rule CreateRule2(string expressionKey, FilterExpressionNodeCollection filters)
{
Rule rule = new Rule();
rule.Active = true;
//Mediachase.Web.Console.Providers.DomParser
string expr = ConvertNodesToStringExpression(filters);
RuleExpressionCondition conditionExpr = new RuleExpressionCondition();
if (!String.IsNullOrEmpty(expr))
{
Parser p = new Parser();
conditionExpr.Expression = p.ParseExpression(expr);
rule.Name = expressionKey;
}
else
{
CodePrimitiveExpression truePrimitive = new CodePrimitiveExpression(true);
conditionExpr.Expression = truePrimitive;
rule.Name = "AlwaysTrue";
}
rule.Condition = conditionExpr;
rule.Priority = 9999; //Nust be first evaluate
rule.ReevaluationBehavior = RuleReevaluationBehavior.Never;
// Create succeeded assignment
// this.ValidationResult.IsValid = True
CodeThisReferenceExpression thisRef = new CodeThisReferenceExpression();
CodePropertyReferenceExpression resultRef = new CodePropertyReferenceExpression(thisRef, "ValidationResult");
CodePropertyReferenceExpression validRef = new CodePropertyReferenceExpression(resultRef, "IsValid");
CodeAssignStatement ruleIsValidAction = new CodeAssignStatement(validRef, new CodePrimitiveExpression(true));
rule.ThenActions.Add(new RuleStatementAction(ruleIsValidAction));
return(rule);
}
/// <summary>
/// Converts the nodes to expression.
/// </summary>
/// <param name="nodes">The nodes.</param>
/// <returns></returns>
protected virtual CodeBinaryOperatorExpression ConvertNodesToExpression(FilterExpressionNodeCollection nodes)
{
FilterExpressionNodeCollection newNodes = EliminateEmptyNodes(nodes);
// If not nodes found return null
if (newNodes.Count == 0)
{
return(null);
}
// If only one node, return it as an expression
if (newNodes.Count == 1)
{
return(ConvertNodeToExpression(newNodes[0]));
}
// Start processing more than 1 node
CodeBinaryOperatorExpression masterExpression = null;
foreach (FilterExpressionNode node in newNodes)
{
CodeBinaryOperatorExpression currentExpression = new CodeBinaryOperatorExpression();
if (node.NodeType == FilterExpressionNodeType.Element)
{
masterExpression = AddExpression(masterExpression, CodeBinaryOperatorType.BooleanAnd, ConvertNodeToExpression(node));
}
else if (node.NodeType == FilterExpressionNodeType.AndBlock)
{
masterExpression = AddExpression(masterExpression, CodeBinaryOperatorType.BooleanAnd, ConvertNodesToExpression(node.ChildNodes));
}
else if (node.NodeType == FilterExpressionNodeType.OrBlock)
{
masterExpression = AddExpression(masterExpression, CodeBinaryOperatorType.BooleanOr, ConvertNodesToExpression(node.ChildNodes));
}
}
return(masterExpression);
}
/// <summary>
/// Adds the expression as node.
/// </summary>
/// <param name="col">The col.</param>
/// <param name="expr">The expr.</param>
protected virtual void AddExpressionAsNode(ref FilterExpressionNodeCollection col, CodeBinaryOperatorExpression expr)
{
if (expr.Left is CodeMethodInvokeExpression)
{
col.Add(ConvertExpressionToNode((CodeMethodInvokeExpression)expr.Left));
}
else if (expr.Left is CodeBinaryOperatorExpression)
{
AddExpressionAsNode(ref col, expr.Left);
}
// Only need an operator if right is an expression
FilterExpressionNode blockNode = null;
if (expr.Right is CodeBinaryOperatorExpression)
{
if (expr.Operator == CodeBinaryOperatorType.BooleanAnd)
{
blockNode = new FilterExpressionNode(FilterExpressionNodeType.AndBlock, String.Empty);
}
else if (expr.Operator == CodeBinaryOperatorType.BooleanOr)
{
blockNode = new FilterExpressionNode(FilterExpressionNodeType.OrBlock, String.Empty);
}
col.Add(blockNode);
FilterExpressionNodeCollection blockCol = new FilterExpressionNodeCollection();
AddExpressionAsNode(ref blockCol, expr.Right);
blockNode.ChildNodes = blockCol;
}
if (expr.Right is CodeMethodInvokeExpression)
{
col.Add(ConvertExpressionToNode((CodeMethodInvokeExpression)expr.Right));
}
}
protected virtual RuleSet CreateRuleSet(string expressionPlace, string expressionKey, FilterExpressionNodeCollection filters)
{
RuleSet customerRuleSet = new RuleSet(String.Format("{0}-{1}-CustomerRuleSet", expressionPlace, expressionKey));
customerRuleSet.ChainingBehavior = RuleChainingBehavior.None;
customerRuleSet.Rules.Add(CreateRule2(expressionKey, filters));
return(customerRuleSet);
}
/// <summary>
/// Saves the filters.
/// </summary>
/// <param name="expressionPlace">The expression place.</param>
/// <param name="expressionKey">The expression key.</param>
/// <param name="filters">The filters.</param>
public override void SaveFilters(string expressionPlace, string expressionKey, FilterExpressionNodeCollection filters)
{
RuleSet ruleSet = GetPromotionRuleSet(expressionPlace, expressionKey);
if (ruleSet != null)
{
foreach (Rule actionRule in CreateRuleActions(expressionKey, filters))
{
ruleSet.Rules.Add(actionRule);
}
}
SaveExpression(ruleSet, Int32.Parse(expressionKey));
}
protected virtual string ConvertNodesToStringExpression(FilterExpressionNodeCollection nodes)
{
return(ConvertNodesToStringExpression(nodes, "&&"));
}
/// <summary>
/// Saves the filters.
/// </summary>
/// <param name="expressionPlace">The expression place.</param>
/// <param name="expressionKey">The expression key, should be passed in the format of segmentid:expressionid</param>
/// <param name="filters">The filters.</param>
public override void SaveFilters(string expressionPlace, string expressionKey, FilterExpressionNodeCollection filters)
{
RuleSet set = CreateRuleSet(expressionPlace, expressionKey, filters);
SaveExpression(set, Int32.Parse(expressionKey));
}
/// <summary>
/// Saves the filters.
/// </summary>
/// <param name="expressionPlace">The expression place.</param>
/// <param name="expressionKey">The expression key.</param>
/// <param name="filters">The filters.</param>
public override void SaveFilters(string expressionPlace, string expressionKey, FilterExpressionNodeCollection filters)
{
}
