public void InitializationForStateCheckTest()
{
var input = new List <string> {
"x<10:1",
"5 > y : 2",
"rubbish:3"
};
var element = new ConditionElement(null, input);
var state = new StateModel {
Variables = new Dictionary <string, decimal> {
{ "x", 100 },
{ "y", 100 }
}
};
//first check - no state - rubbish should fire as a default route
element.Execute(state);
Assert.Contains(3, element.NextElementIds);
//second check - no conditions met from state - rubbish should fire as a default route
state.Variables["y"] = 10;
element.Execute(state);
Assert.Contains(3, element.NextElementIds);
//third check - second condition from state is true
state.Variables["y"] = 2;
element.Execute(state);
Assert.Contains(2, element.NextElementIds);
//fourth check - first condition from state is true
state.Variables["x"] = 1;
element.Execute(state);
Assert.Contains(1, element.NextElementIds);
}
private bool Equals(ConditionElement <T> other)
{
return(Equals(_logicalConjunction, other._logicalConjunction) &&
Equals(_condition, other._condition) &&
_customDescription == other._customDescription &&
_reason == other._reason);
}
/// <summary>
/// Adds a condition expression to the pattern.
/// </summary>
/// <param name="expression">Condition expression.</param>
public void Condition(LambdaExpression expression)
{
IEnumerable <Declaration> declarations = expression.Parameters.Select(p => Scope.Lookup(p.Name, p.Type));
var condition = new ConditionElement(declarations, expression);
_conditions.Add(condition);
}
/// <summary>
/// Binds the data.
/// </summary>
/// <param name="expressionPlace">The expression place.</param>
/// <param name="expressionKey">The expression key.</param>
/// <param name="node">The node.</param>
/// <param name="condition">The condition.</param>
public void BindData(string expressionPlace, string expressionKey, FilterExpressionNode node, ConditionElement condition)
{
if (node.Attributes == null)
BindFromValue(string.Empty);
else if (node.Attributes["ReferenceToMetaClassName"] != null)
BindFromValue(node.Attributes["ReferenceToMetaClassName"]);
else
throw new ArgumentNullException("ReferenceToMetaClassName");
}
public void BindData(string expressionPlace, string expressionKey, FilterExpressionNode node, ConditionElement condition)
{
MetaField mf = Mediachase.Ibn.Core.MetaDataWrapper.GetMetaFieldByName(Mediachase.Ibn.Core.MetaViewGroupUtil.GetIdFromUniqueKey(expressionPlace), node.Key.Split('-')[0]);
if (mf.Attributes[McDataTypeAttribute.DecimalPrecision] != null && mf.Attributes[McDataTypeAttribute.DecimalScale] != null)
{
this.Scale = Convert.ToInt32(mf.Attributes[McDataTypeAttribute.DecimalScale].ToString(), CultureInfo.InvariantCulture);
this.Precision = Convert.ToInt32(mf.Attributes[McDataTypeAttribute.DecimalPrecision].ToString(), CultureInfo.InvariantCulture);
}
BindFromValue();
}
public static IAlphaCondition CompileAlphaCondition(ConditionElement element)
{
var optimizer = new ExpressionSingleParameterOptimizer <Func <object, bool> >();
var optimizedExpression = optimizer.ConvertParameter(element.Expression);
var @delegate = optimizedExpression.Compile();
var fastDelegate = Create(@delegate, element.Expression.Parameters.Count);
var condition = new AlphaCondition(element.Expression, fastDelegate);
return(condition);
}
/// <summary>
/// Creates the condition eement by him definitions
/// </summary>
/// <param name="conditionDef">The condition def.</param>
/// <param name="condElType">Type of the cond el.</param>
/// <param name="customControlPath">The custom control path.</param>
/// <returns></returns>
protected virtual ConditionElement CreateConditionEement(ElementDefs conditionDef, ConditionElementType condElType,
string customControlPath)
{
ConditionElement retVal = new ConditionElement(condElType, conditionDef.Key,
conditionDef.Descr, conditionDef.Descr);
retVal.CustomControlPath = customControlPath;
conditionDef.Tag = retVal;
return(retVal);
}
public static IBetaCondition CompileBetaCondition(ConditionElement element, IEnumerable <Declaration> declarations)
{
var optimizer = new ExpressionMultiParameterOptimizer <Func <object[], bool> >();
var optimizedExpression = optimizer.CompactParameters(element.Expression, 0);
var @delegate = optimizedExpression.Compile();
var fastDelegate = Create(@delegate, element.Expression.Parameters.Count);
var factMap = IndexMap.CreateMap(element.Imports, declarations);
var condition = new BetaCondition(element.Expression, fastDelegate, factMap);
return(condition);
}
public override bool Eval()
{
Log.GetInstance().Write("evaluating value condition");
if (ConditionElement.IsBound == false)
{
if (!ConditionElement.Bind(this.DAL, this.IE))
{
return(false);
}
}
return(ConditionElement.Value == value);
}
virtual public bool Eval()
{
Log.GetInstance().Write("evaluating base condition");
if (ConditionElement.IsBound == false)
{
if (!ConditionElement.Bind(DAL, IE))
{
throw new SiteObjectNotBoundException(ConditionElement);
}
}
return(true);
}
private void BuildSelectionNode(ReteBuilderContext context, ConditionElement condition)
{
var alphaCondition = ExpressionCompiler.CompileAlphaCondition(condition);
SelectionNode selectionNode = context.CurrentAlphaNode
.ChildNodes.OfType <SelectionNode>()
.FirstOrDefault(sn => sn.Condition.Equals(alphaCondition));
if (selectionNode == null)
{
selectionNode = new SelectionNode(alphaCondition);
context.CurrentAlphaNode.ChildNodes.Add(selectionNode);
}
context.CurrentAlphaNode = selectionNode;
}
/// <summary>
/// Creates a condition element that represents a condition applied to elements matched by a pattern.
/// </summary>
/// <param name="expression">Condition expression. It must have <c>Boolean</c> as its return type.</param>
/// <returns>Created element.</returns>
public static ConditionElement Condition(LambdaExpression expression)
{
if (expression == null)
{
throw new ArgumentNullException(nameof(expression), "Condition expression not provided");
}
if (expression.ReturnType != typeof(bool))
{
throw new ArgumentException($"Pattern condition must return a Boolean result. Condition={expression}");
}
var element = new ConditionElement(expression);
return(element);
}
/// <summary>
/// 转换Xml为Dictionary，以便程序处理
/// </summary>
/// <returns></returns>
public Dictionary <string, object> ToDictionary()
{
base.Init();
//1.从配置文件:autocode.config.xml获取配置信息
string Save_Dir = App_Dir + "autocode.config.xml";
if (!File.Exists(Save_Dir))
{
return(null);
}
XDocument xmlDoc = XDocument.Load(Save_Dir);
Dictionary <string, object> dict = new Dictionary <string, object>();
List <XElement> lists = xmlDoc.XPathSelectElements("classes/class").ToList();
string className = "";
foreach (XElement ClassElement in lists)
{
className = ClassElement.Attribute("name").Value;
List <XElement> listConditions = ClassElement.XPathSelectElements("conditions/condition").ToList();
List <Dictionary <string, string> > conditions = new List <Dictionary <string, string> >();
Dictionary <string, object> ClassDict = new Dictionary <string, object>();
foreach (XElement ConditionElement in listConditions)
{
Dictionary <string, string> dictCondition = new Dictionary <string, string>();
dictCondition.Add("ConditionName", ConditionElement.Value);
if (ConditionElement.HasAttributes)
{
dictCondition.Add("RelationClass", ConditionElement.Attribute("relation_class").Value);
dictCondition.Add("ShowName", ConditionElement.Attribute("show_name").Value);
}
conditions.Add(dictCondition);
}
ClassDict.Add("Conditions", conditions);
dict.Add(className, ClassDict);
}
return(dict);
}
private void SetupProcessElements(InputProcessModel inputModel)
{
ProcessElements = new Dictionary <int, IProcessElement>();
foreach (var processModel in inputModel.Elements)
{
IProcessElement element = null;
switch (processModel.ElementType)
{
case ElementType.Block:
element = new BlockElement(processModel.PreviousElementIds, processModel.NextElementIds, processModel.Actions);
break;
case ElementType.Condition:
element = new ConditionElement(processModel.PreviousElementIds, processModel.Actions);
break;
case ElementType.Event:
element = new EventElement(processModel.PreviousElementIds, processModel.NextElementIds, processModel.Actions);
break;
}
ProcessElements[processModel.Id] = element;
}
}
protected internal override void VisitCondition(Context context, ConditionElement element)
{
}
/// <summary>
/// Creates a new Condition using the reference to the condition definition in the policy document.
/// </summary>
/// <param name="condition">The condition definition of the policy document.</param>
public Condition2(ConditionElement condition)
: base(condition)
{
}
public void BindData(string expressionPlace, string expressionKey, FilterExpressionNode node, ConditionElement condition)
{
BindFromValue();
}
public void BindData(string expressionPlace, string expressionKey, FilterExpressionNode node, ConditionElement condition)
{
MetaField mf = Mediachase.Ibn.Core.MetaDataWrapper.GetMetaFieldByName(Mediachase.Ibn.Core.MetaViewGroupUtil.GetIdFromUniqueKey(expressionPlace), node.Key.Split('-')[0]);
if (mf.Attributes[McDataTypeAttribute.DecimalPrecision] != null && mf.Attributes[McDataTypeAttribute.DecimalScale] != null)
{
this.Scale = Convert.ToInt32(mf.Attributes[McDataTypeAttribute.DecimalScale].ToString(), CultureInfo.InvariantCulture);
this.Precision = Convert.ToInt32(mf.Attributes[McDataTypeAttribute.DecimalPrecision].ToString(), CultureInfo.InvariantCulture);
}
BindFromValue();
}
public void BindData(string expressionPlace, string expressionKey, FilterExpressionNode node, ConditionElement condition)
{
BindFromValue();
}
public void BindData(string expressionPlace, string expressionKey, FilterExpressionNode node, ConditionElement condition)
{
string controlId = node["TmpKey"];
if (controlId == null)
{
controlId = Guid.NewGuid().ToString();
node["TmpKey"] = controlId;
}
ControlId = controlId;
Dictionary <string, string> dicItems = Value as Dictionary <string, string>;
if (dicItems != null && dicItems.Count > 0)
{
StringBuilder sb = new StringBuilder();
sb.Append(dicItems.ElementAt(0).Value);
if (dicItems.Count > 1)
{
sb.Append("+ (" + (dicItems.Count - 1).ToString() + ")");
}
lbSelectedEntries.Text = sb.ToString();
}
else
{
lbSelectedEntries.Text = "Please select catalog entries";
}
}
protected internal virtual void VisitCondition(TContext context, ConditionElement element)
{
}
/// <summary>
/// Binds the data.
/// </summary>
/// <param name="expressionPlace">The expression place.</param>
/// <param name="expressionKey">The expression key.</param>
/// <param name="node">The node.</param>
/// <param name="condition">The condition.</param>
public void BindData(string expressionPlace, string expressionKey, FilterExpressionNode node, ConditionElement condition)
{
if (node.Attributes == null)
{
BindFromValue(string.Empty);
}
else if (node.Attributes["ReferenceToMetaClassName"] != null)
{
BindFromValue(node.Attributes["ReferenceToMetaClassName"]);
}
else
{
throw new ArgumentNullException("ReferenceToMetaClassName");
}
}
