private void CreatePropertyCondition(XbimQueryBuilder qBuilder, XmlNode propGroupNode)
{
GroupRule pGrpRule = GetGroupRule(propGroupNode);
//apply logical operators according to the "select"
XmlNodeList pSets = ((XmlElement)propGroupNode).GetElementsByTagName("propertySet");
foreach (XmlNode pSet in pSets)
{
string pSetName = GetName(pSet);
NameRule pSetNameRule = GetNameRule(pSet);
XmlNode propNode = ((XmlElement)pSet).GetElementsByTagName("property").Item(0);
string propName = GetName(propNode);
NameRule propNameRule = GetNameRule(propNode);
if (string.IsNullOrEmpty(propName))
{
errLog.WriteLine("Name of the property must be specified. Property set: '" + pSetName + "', element: '" + eName + "'.");
continue;
}
XmlNode valNode = (propNode as XmlElement).GetElementsByTagName("value").Item(0);
string value = valNode.InnerText;
ValueRule valRule = GetValueRule(valNode);
if (string.IsNullOrEmpty(value))
{
errLog.WriteLine("Value of the property '" + propName + "' must be specified. Property set: '" + pSetName + "', element: '" + eName + ".");
continue;
}
qBuilder.AddPropertyCondition(pSetName, pSetNameRule, propName, propNameRule, value, valRule, pGrpRule);
}
}
private ValueRule GetValueRule(XmlNode node)
{
XmlAttribute attr = node.Attributes["type"];
string type = "is"; //default value
if (attr != null && !String.IsNullOrEmpty(attr.Value))
{
type = attr.Value;
}
ValueRule result = ValueRule.IS;
if (type.ToLower() == "isnot")
{
result = ValueRule.IS_NOT;
}
if (type.ToLower() == "contains")
{
result = ValueRule.CONTAINS;
}
if (type.ToLower() == "notcontains")
{
result = ValueRule.NOT_CONTAINS;
}
if (type.ToLower() == "greater")
{
result = ValueRule.GREATER_THAN;
}
if (type.ToLower() == "less")
{
result = ValueRule.LESS_THAN;
}
return(result);
}
private void TestPropertyNameWithNullEquivalent(string Value)
{
// Arrange
var rule = new ValueRule("TestRule");
// Act
rule.Property(Value);
}
private void TestNotEqualsWithNullEquivalent(string Value)
{
// Arrange
var r = new ValueRule("RuleName").Property("APropertyName");
// Act
r.NotEquals(Value);
}
public void TestWhereClause()
{
VersionRule rule = new VersionRule("Field");
ValueRule val = rule.GetWhereClause(3);
Assert.AreEqual(3, val.Value);
Assert.AreEqual(ActionRule.Check, val.Action);
}
public void TestWhereClause()
{
CreationDateRule rule = new CreationDateRule("Field");
ValueRule val = rule.GetWhereClause(null);
Assert.IsNull(val.Value);
Assert.AreEqual(ActionRule.DoNothing, val.Action);
}
public void TestInsertValue()
{
CreationDateRule rule = new CreationDateRule("Field");
ValueRule val = rule.GetInsertValue(null);
Assert.IsNotNull(val.Value);
Assert.AreEqual(ActionRule.Update, val.Action);
}
public void TestInsertValue()
{
VersionRule rule = new VersionRule("Field");
ValueRule val = rule.GetInsertValue(null);
Assert.AreEqual(1, val.Value);
Assert.AreEqual(ActionRule.Update, val.Action);
}
public void PropertyNameThrowsExceptionWhenPropertyNameCalledTwice()
{
// Arrange
var rule = new ValueRule("TestRule").Property("ANane").Equals("A Value");
// Act
rule.Property("BName");
}
public void NotEqualsThrowsExceptionIfPropertyNameIsNotSet()
{
// Arrange
var rule = new ValueRule("TestRule");
// Act
rule.NotEquals("A Value");
}
public void EqualsThrowsExceptionIfComparisonAlreadySetup()
{
// Arrange
var rule = new ValueRule("A Rule").Property("A name").Equals("A Value");
// Act
rule.Equals("B Value");
}
public void TestUpdateValue()
{
VersionRule rule = new VersionRule("Field");
ValueRule val = rule.GetUpdateValue(2);
Assert.AreEqual(1, val.Value);
Assert.AreEqual(ActionRule.IncrementalUpdate, val.Action);
}
public void TestUpdateValue()
{
ModificationDateRule rule = new ModificationDateRule("Field");
ValueRule val = rule.GetUpdateValue(null);
Assert.IsNotNull(val.Value);
Assert.AreEqual(ActionRule.Update, val.Action);
}
public void TestWhereClause()
{
using (new TestSecurityContext()) {
CreationUserRule rule = new CreationUserRule("Field");
ValueRule val = rule.GetWhereClause(null);
Assert.IsNull(val.Value);
Assert.AreEqual(ActionRule.DoNothing, val.Action);
}
}
public void TestInsertValue()
{
using (new TestSecurityContext()) {
CreationUserRule rule = new CreationUserRule("Field");
ValueRule val = rule.GetInsertValue(null);
Assert.IsNotNull(val.Value);
Assert.AreEqual(ActionRule.Update, val.Action);
}
}
public void ConstructorPopulatesRuleName()
{
// Arrange
var ruleName = "This is a rule name.";
// Act
var rule = new ValueRule(ruleName);
// Assert
Assert.AreEqual(ruleName, rule.RuleName);
}
/// <summary>
/// Tries the get value.
/// </summary>
/// <typeparam name="T">Strong type of the value.</typeparam>
/// <param name="rule">The rule.</param>
/// <param name="input">The input.</param>
/// <param name="value">The value.</param>
/// <returns><c>true</c> if rule matches the input, <c>false</c> otherwise.</returns>
public static bool TryGetValue <T>(this ValueRule <T> rule, string input, out T value)
{
if (rule.Match(input))
{
return(rule.ParseTree(input).TryGetValue(out value));
}
value = default(T);
return(false);
}
public static bool EvaluatePropertyValue(IPersistIfcEntity element, string pSetName, NameRule pSetNameRule, string propertyName, NameRule propNameRule, string value, ValueRule valueRule)
{
Dictionary<IfcLabel, Dictionary<IfcIdentifier, IfcValue>> allProperties = null;
if (string.IsNullOrEmpty(propertyName)) return false;
//properties could be defined in IfcTypeObject as HasProperties
IfcTypeObject typeObject = element as IfcTypeObject;
if (typeObject != null)
{
allProperties = typeObject.GetAllPropertySingleValues();
}
//or properties could be defined in IfcObject in IsDefinedBy
IfcObject ifcObject = element as IfcObject;
if (ifcObject != null)
{
allProperties = ifcObject.GetAllPropertySingleValues();
}
//or properties could be defined for material as ExtendedMaterialProperties
IfcMaterial material = element as IfcMaterial;
if (material != null)
{
allProperties = material.GetAllPropertySingleValues();
}
//getting properties is not supported otherwise
if (allProperties != null)
{
foreach (var p in allProperties)
{
//if pSetName is null all property sets are inspected
if (pSetName != null)
{
if (!IsRightName(pSetName, p.Key, pSetNameRule))
{
continue;
}
}
foreach (var prop in p.Value)
{
//if name is not specified all values are returned
if (IsRightName(propertyName, prop.Key, propNameRule))
{
Type t = ((ExpressType)(prop.Value)).UnderlyingSystemType;
Expression right = XbimQueryFactory.PromoteToConstant(t, value);
Expression left = XbimQueryFactory.PromoteToConstant(t, prop.Value.ToString()); //todo: this should be more sofisticated than 'ToString()'
Expression eval = CreateValueExpression(left, right, valueRule);
return Expression.Lambda<Func<bool>>(eval).Compile()();
}
}
}
}
return false;
}
private void TestNOTINWithNullEquivalent(string Value)
{
// Arrange
var r = new ValueRule("ARuleName").Property("APropertyName");
// Act
r.NotIn(new List <string>(1)
{
Value
});
}
public void NotInThrowsExceptionIfPropertyNameIsNotSet()
{
// Arrange
var rule = new ValueRule("TestRule");
// Act
rule.NotIn(new List <string>()
{
"A Value"
});
}
public void IsValidThrowsExceptionWhenComparisonNotSet()
{
// Arrange
var rule = new ValueRule("TestRule").Property("APropertyName");
// Act
rule.IsValid(new Dictionary <string, string>(1)
{
{ "APropertyName", "A Value" }
});
}
public void PropertyNameSetsPropertyName()
{
// Arrange
var r = new ValueRule("ARuleName");
// Act
r.Property("APropertyName");
// Assert
Assert.AreEqual("APropertyName", r.PropertyName);
}
public void NotInThrowsExceptionIfComparisonAlreadySetup()
{
// Arrange
var rule = new ValueRule("A Rule").Property("A name").Equals("A Value");
// Act
rule.NotIn(new List <string>(1)
{
"A Value"
});
}
public void IsValidReturnsTrueWhenNotRequiredAndValueIsWhiteSpace()
{
// Arrange
var rule = new ValueRule("TestRule").Property("APropertyName").Equals("Value");
// Act
var result = rule.IsValid(new Dictionary <string, string>(1)
{
{ "APropertyName", " " }
});
// Assert
Assert.IsTrue(result);
}
public void IsValidReturnsTrueWhenNotEqualsIsTrue()
{
// Arrange
var rule = new ValueRule("TestRule").Property("APropertyName").NotEquals("I Am Valid");
// Act
var result = rule.IsValid(new Dictionary <string, string>(1)
{
{ "APropertyName", "I Am NOT Valid" }
});
// Assert
Assert.IsTrue(result);
}
public void IsValidReturnsFalseWhenRequiredButValueIsWhiteSpace()
{
// Arrange
var rule = new ValueRule("TestRule").Property("APropertyName").Equals("Value").Required();
// Act
var result = rule.IsValid(new Dictionary <string, string>(1)
{
{ "APropertyName", " " }
});
// Assert
Assert.IsFalse(result);
Assert.AreEqual("APropertyName is required, but is null, an empty string, or whitespace.",
rule.ErrorMessage);
}
public void IsValidReturnsFalseWhenNotEqualsIsFalse()
{
// Arrange
var rule = new ValueRule("TestRule").Property("APropertyName").NotEquals("hello");
// Act
var result = rule.IsValid(new Dictionary <string, string>(1)
{
{ "APropertyName", "hello" }
});
// Assert
Assert.IsFalse(result);
Assert.AreEqual("APropertyName value of 'hello' is invalid.",
rule.ErrorMessage);
}
public void NotEqualsCreatedValueComparison()
{
// Arrange
var r = new ValueRule("ARuleName").Property("APropertyName");
// Act
var returnedRule = r.NotEquals("A Value");
// Assert
Assert.AreSame(r, returnedRule);
Assert.IsNotNull(r.Comparison);
Assert.AreEqual("APropertyName", r.Comparison.PropertyName);
Assert.AreEqual(Enums.ComparisonOperators.NOTEQ, r.Comparison.ComparisonOperator);
Assert.AreEqual(1, r.Comparison.ValidValues.Count);
Assert.AreEqual("A Value", r.Comparison.ValidValues[0]);
}
public void IsValidReturnsTrueWhenNotInIsTrue()
{
// Arrange
var rule = new ValueRule("TestRule").Property("APropertyName").NotIn(new List <string>()
{
"one", "two", "three"
});
// Act
var result = rule.IsValid(new Dictionary <string, string>(1)
{
{ "APropertyName", "four" }
});
// Assert
Assert.IsTrue(result);
}
public void IsValidReturnsFalseWhenInIsFalse()
{
// Arrange
var rule = new ValueRule("TestRule").Property("APropertyName").In(new List <string>()
{
"one", "two", "three"
});
// Act
var result = rule.IsValid(new Dictionary <string, string>(1)
{
{ "APropertyName", "four" }
});
// Assert
Assert.IsFalse(result);
Assert.AreEqual("APropertyName value of 'four' is invalid.",
rule.ErrorMessage);
}
public void NotInSanitizesValueList()
{
// Arrange
var r = new ValueRule("ARuleName").Property("APropertyName");
// Act
var returnedRule = r.NotIn(new List <string>(5)
{
"A Value", null, string.Empty, " ", "B Value"
});
// Assert
Assert.AreSame(r, returnedRule);
Assert.IsNotNull(r.Comparison);
Assert.AreEqual("APropertyName", r.Comparison.PropertyName);
Assert.AreEqual(Enums.ComparisonOperators.NOTIN, r.Comparison.ComparisonOperator);
Assert.AreEqual(2, r.Comparison.ValidValues.Count);
Assert.AreEqual("A Value", r.Comparison.ValidValues[0]);
Assert.AreEqual("B Value", r.Comparison.ValidValues[1]);
}
private static Expression CreateValueExpression(Expression left, Expression right, ValueRule valueRule)
{
switch (valueRule)
{
case ValueRule.IS: return XbimQueryFactory.GenerateEqual(left, right);
case ValueRule.IS_NOT: return XbimQueryFactory.GenerateNotEqual(left, right);
case ValueRule.CONTAINS: return XbimQueryFactory.GenerateContains(left, right);
case ValueRule.NOT_CONTAINS: return Expression.Not(XbimQueryFactory.GenerateContains(left, right));
case ValueRule.GREATER_THAN: return XbimQueryFactory.GenerateGreaterThan(left, right);
case ValueRule.LESS_THAN: return XbimQueryFactory.GenerateLessThan(left, right);
default:
throw new Exception("Unexpected enumeration value: " + Enum.GetName(typeof(GroupRule), valueRule));
}
}
public void AddPropertyCondition(string pSetName, NameRule pSetNameRule, string propertyName, NameRule propNameRule, string value, ValueRule valueRule, GroupRule groupRule)
{
Expression psn = Expression.Constant(pSetName);
Expression psnRl = Expression.Constant(pSetNameRule);
Expression pn = Expression.Constant(propertyName);
Expression pnRl = Expression.Constant(propNameRule);
Expression valConst = Expression.Constant(value);
Expression valRul = Expression.Constant(valueRule);
MethodInfo getPropMeth = typeof(PropertyHelper).GetMethod("EvaluatePropertyValue");
if (getPropMeth == null) throw new Exception("Wrong method definition.");
//public static IfcValue GetPropertyValue(IPersistIfcEntity element, string pSetName, NameRule pSetNameRule, string propertyName, NameRule propNameRule)
Expression property = Expression.Call(getPropMeth, new Expression[] {input ,psn, psnRl, pn, pnRl, valConst, valRul}); //bool result of the test
AddToGroup(property, groupRule);
}
public void AddAttributeCondition(string attributName, string value, ValueRule valueRule, GroupRule groupRule)
{
if (attributName == null) { Err("Attribute name not specified"); return; }
//check attribut existence in the specified type
PropertyInfo attr = Type.GetProperty(attributName);
if (attr == null) { Err("Attribute name '" + attributName + "' does not exist in specified type '" + Type.Name + "'."); return; }
//create expression to access attribute
Expression attrExp = Expression.Property(input, attr);
//get value from the string
Expression val = XbimQueryFactory.PromoteToConstant(attr.PropertyType, value);
if (val == null) { Err("Value '" + value + "' could not be converted to the type of the attribute '" + attributName + "'."); return; }
//create binary expression according to valueRule
Expression expression = CreateValueExpression(attrExp, val, valueRule);
if (expression == null) { Err("Value rule'" + Enum.GetName(typeof(ValueRule), valueRule)+ "' cannot be applied on the attribute '" + attributName + "'."); return; }
//add resulting expression to the group
AddToGroup(expression, groupRule);
}
public RequiredIfBoolValueAttribute(string dependentProperty, bool targetValue, ValueRule valueRule)
{
this.DependentProperty = dependentProperty;
this.TargetValue = targetValue;
this.ValueRule = valueRule;
}
