private IEnumerable <EnumExtension.EnumMember> GetAllowedValueOperators(ExtendedAttributeType type) { if (AdvancedComparisonRuleViewModel.valueOperatorValues.Count == 0) { var enumValues = Enum.GetValues(typeof(ValueOperator)); EnumExtension.EnumMember enumMember; foreach (var value in enumValues) { enumMember = new EnumExtension.EnumMember(); enumMember.Value = value; enumMember.Description = ((Enum)value).GetEnumDescription(); valueOperatorValues.Add(enumMember); } enumMember = new EnumExtension.EnumMember(); enumMember.Value = ValueOperator.IsPresent; enumMember.Description = ((Enum)enumMember.Value).GetEnumDescription(); valueOperatorValues.Add(enumMember); enumMember = new EnumExtension.EnumMember(); enumMember.Value = ValueOperator.NotPresent; enumMember.Description = ((Enum)enumMember.Value).GetEnumDescription(); valueOperatorValues.Add(enumMember); } foreach (var value in ComparisonEngine.GetAllowedValueOperators(type)) { yield return(valueOperatorValues.FirstOrDefault(t => (int)t.Value == ((int)value))); } yield return(valueOperatorValues.FirstOrDefault(t => (ValueOperator)t.Value == ValueOperator.IsPresent)); yield return(valueOperatorValues.FirstOrDefault(t => (ValueOperator)t.Value == ValueOperator.NotPresent)); }
/// <summary> /// Gets the matching single value from the multivalued attribute /// </summary> /// <param name="source">The source attribute array</param> /// <returns>An attribute value</returns> private DateTime GetValueFromMvDateTime(IList <object> source) { DateTime?lastValue = null; foreach (object value in source) { DateTime valueDateTime = TypeConverter.ConvertData <DateTime>(value); switch (this.SelectorOperator) { case ValueOperator.Equals: case ValueOperator.NotEquals: case ValueOperator.GreaterThan: case ValueOperator.LessThan: case ValueOperator.GreaterThanOrEq: case ValueOperator.LessThanOrEq: case ValueOperator.And: case ValueOperator.Or: if (ComparisonEngine.CompareDateTime(valueDateTime, DateTime.Parse(this.SelectorValue), this.SelectorOperator)) { return(valueDateTime); } break; case ValueOperator.Largest: if (!lastValue.HasValue || valueDateTime > lastValue) { lastValue = valueDateTime; } break; case ValueOperator.Smallest: if (!lastValue.HasValue || valueDateTime < lastValue) { lastValue = valueDateTime; } break; case ValueOperator.Contains: case ValueOperator.NotContains: case ValueOperator.StartsWith: case ValueOperator.EndsWith: case ValueOperator.IsPresent: case ValueOperator.NotPresent: default: throw new UnknownOrUnsupportedValueOperatorException(this.SelectorOperator, typeof(long)); } } if (lastValue.HasValue) { return(lastValue.Value); } throw new NotFoundException(); }
/// <summary> /// Determines if this AttributeValue object has the same value as another object /// </summary> /// <param name="obj">The value to compare</param> /// <returns>A boolean value indicating if the two values are the same</returns> public bool ValueEquals(object obj) { if (this.Value == null && obj == null) { return(true); } if (this.Value == null ^ obj == null) { return(false); } object comparisonValue; if (obj is AttributeValue) { AttributeValue otherValue = (AttributeValue)obj; if (this.IsNull && otherValue.IsNull) { //// If both values are null return(true); } else if (this.IsNull || otherValue.IsNull) { //// If one of the two values are null return(false); } else if (this.Attribute != otherValue.Attribute) { //// If the types don't match return(false); } comparisonValue = otherValue.Value; } else { comparisonValue = obj; } switch (this.attribute.Type) { case ExtendedAttributeType.Boolean: case ExtendedAttributeType.Integer: case ExtendedAttributeType.DateTime: case ExtendedAttributeType.Reference: case ExtendedAttributeType.Binary: return(ComparisonEngine.Compare(comparisonValue, this.Value, ValueOperator.Equals, this.Attribute.Type)); case ExtendedAttributeType.String: return(ComparisonEngine.CompareString(TypeConverter.ConvertData <string>(comparisonValue), this.ValueString, ValueOperator.Equals, StringComparison.CurrentCulture)); case ExtendedAttributeType.Undefined: default: throw new ArgumentException("Unknown or unsupported attribute type"); } }
public void CompareBinaryFromStringEqualsTest() { ValueOperator valueOperator = ValueOperator.Equals; string actualValue = "AAECAwQ="; string matchingValue = "AAECAwQ="; string nonMatchingValue = "AAACAwQ="; Assert.AreEqual(true, ComparisonEngine.CompareBinary(actualValue, matchingValue, valueOperator)); Assert.AreEqual(false, ComparisonEngine.CompareBinary(actualValue, nonMatchingValue, valueOperator)); }
public void CompareStringNotEqualsTest() { ValueOperator valueOperator = ValueOperator.NotEquals; string actualValue = "abcd"; string matchingValue = "defg"; string nonMatchingValue = "abcd"; Assert.AreEqual(true, ComparisonEngine.CompareString(actualValue, matchingValue, valueOperator)); Assert.AreEqual(false, ComparisonEngine.CompareString(actualValue, nonMatchingValue, valueOperator)); }
public void CompareBooleanNotEqualsTest() { ValueOperator valueOperator = ValueOperator.NotEquals; bool actualValue = true; bool matchingValue = false; bool nonMatchingValue = true; Assert.AreEqual(true, ComparisonEngine.CompareBoolean(actualValue, matchingValue, valueOperator)); Assert.AreEqual(false, ComparisonEngine.CompareBoolean(actualValue, nonMatchingValue, valueOperator)); }
public void CompareBooleanFromStringEqualsTest() { ValueOperator valueOperator = ValueOperator.Equals; string actualValue = "true"; string matchingValue = "true"; string nonMatchingValue = "false"; Assert.AreEqual(true, ComparisonEngine.CompareBoolean(actualValue, matchingValue, valueOperator)); Assert.AreEqual(false, ComparisonEngine.CompareBoolean(actualValue, nonMatchingValue, valueOperator)); }
public void CompareDateTimeLessThanTest() { ValueOperator valueOperator = ValueOperator.LessThan; DateTime actualValue = DateTime.Parse("1/1/1999"); DateTime matchingValue = DateTime.Parse("1/1/2000"); DateTime nonMatchingValue = DateTime.Parse("1/1/1989"); Assert.AreEqual(true, ComparisonEngine.CompareDateTime(actualValue, matchingValue, valueOperator)); Assert.AreEqual(false, ComparisonEngine.CompareDateTime(actualValue, nonMatchingValue, valueOperator)); }
public void CompareLongOrTest() { ValueOperator valueOperator = ValueOperator.Or; long actualValue = 514L; long matchingValue = 2L; long nonMatchingValue = 5L; Assert.AreEqual(true, ComparisonEngine.CompareLong(actualValue, matchingValue, valueOperator)); Assert.AreEqual(false, ComparisonEngine.CompareLong(actualValue, nonMatchingValue, valueOperator)); }
public void CompareLongLessThanTest() { ValueOperator valueOperator = ValueOperator.LessThan; long actualValue = 10L; long matchingValue = 20L; long nonMatchingValue = 5L; Assert.AreEqual(true, ComparisonEngine.CompareLong(actualValue, matchingValue, valueOperator)); Assert.AreEqual(false, ComparisonEngine.CompareLong(actualValue, nonMatchingValue, valueOperator)); }
public void CompareLongNotEqualsTest() { ValueOperator valueOperator = ValueOperator.NotEquals; long actualValue = 1234567890L; long matchingValue = 9876543210L; long nonMatchingValue = 1234567890L; Assert.AreEqual(true, ComparisonEngine.CompareLong(actualValue, matchingValue, valueOperator)); Assert.AreEqual(false, ComparisonEngine.CompareLong(actualValue, nonMatchingValue, valueOperator)); }
public void CompareLongFromStringEqualsTest() { ValueOperator valueOperator = ValueOperator.Equals; string actualValue = "1234567890"; string matchingValue = "1234567890"; string nonMatchingValue = "9876543210"; Assert.AreEqual(true, ComparisonEngine.CompareLong(actualValue, matchingValue, valueOperator)); Assert.AreEqual(false, ComparisonEngine.CompareLong(actualValue, nonMatchingValue, valueOperator)); }
public void CompareStringEndsWithTest() { ValueOperator valueOperator = ValueOperator.EndsWith; string actualValue = "abcdefghijklmnop"; string matchingValue = "mnop"; string nonMatchingValue = "zzz"; Assert.AreEqual(true, ComparisonEngine.CompareString(actualValue, matchingValue, valueOperator)); Assert.AreEqual(false, ComparisonEngine.CompareString(actualValue, nonMatchingValue, valueOperator)); }
public override bool Evaluate(CSEntry csentry, MVEntry mventry) { if (mventry == null) { throw new NotSupportedException(string.Format("The rule type {0} is not supported in this context", this.GetType().Name)); } int actual = mventry.ConnectedMAs.OfType <ConnectedMA>().Count(t => t.Name == this.MAName); return(ComparisonEngine.CompareLong(actual, this.Count, this.Operator)); }
public void CompareStringNotPresentTest() { ValueOperator valueOperator = ValueOperator.NotPresent; string actualValue = null; string matchingValue = null; string nonMatchingValue = null; Assert.AreEqual(true, ComparisonEngine.CompareString(actualValue, matchingValue, valueOperator)); actualValue = "abds"; Assert.AreEqual(false, ComparisonEngine.CompareString(actualValue, nonMatchingValue, valueOperator)); }
public void CompareBinaryNoPresenceTest() { ValueOperator valueOperator = ValueOperator.NotPresent; byte[] actualValue = null; byte[] matchingValue = new byte[] { 0, 1, 2, 3 }; byte[] nonMatchingValue = new byte[] { 0, 1, 2, 4 }; Assert.AreEqual(true, ComparisonEngine.CompareBinary(actualValue, matchingValue, valueOperator)); actualValue = new byte[] { 0, 1, 2, 3, 4 }; Assert.AreEqual(false, ComparisonEngine.CompareBinary(actualValue, matchingValue, valueOperator)); }
public void CompareLongGreaterThanOrEqTest() { ValueOperator valueOperator = ValueOperator.GreaterThanOrEq; long actualValue = 20L; long matchingValue = 10L; long nonMatchingValue = 30L; Assert.AreEqual(true, ComparisonEngine.CompareLong(actualValue, matchingValue, valueOperator)); matchingValue = 20L; Assert.AreEqual(true, ComparisonEngine.CompareLong(actualValue, matchingValue, valueOperator)); Assert.AreEqual(false, ComparisonEngine.CompareLong(actualValue, nonMatchingValue, valueOperator)); }
/// <summary> /// Gets the matching single value from the multivalued attribute /// </summary> /// <param name="source">The source attribute array</param> /// <returns>An attribute value</returns> private Guid GetValueFromMvReference(IList <object> source) { foreach (object value in source) { Guid valueGuid = TypeConverter.ConvertData <Guid>(value); if (ComparisonEngine.CompareString(valueGuid.ToString(), this.SelectorValue, this.SelectorOperator)) { return(valueGuid); } } throw new NotFoundException(); }
/// <summary> /// Gets the matching single value from the multivalued attribute /// </summary> /// <param name="source">The source attribute array</param> /// <returns>An attribute value</returns> private string GetValueFromMvString(IList <object> source) { foreach (object value in source) { string valueString = TypeConverter.ConvertData <string>(value); if (ComparisonEngine.CompareString(valueString, this.SelectorValue, this.SelectorOperator)) { return(valueString); } } throw new NotFoundException(); }
/// <summary> /// Gets the matching single value from the multivalued attribute /// </summary> /// <param name="source">The source attribute array</param> /// <returns>An attribute value</returns> private byte[] GetValueFromMvBinary(IList <object> source) { foreach (object value in source) { byte[] valueByte = TypeConverter.ConvertData <byte[]>(value); if (ComparisonEngine.CompareBinary(valueByte, this.SelectorValue, this.SelectorOperator)) { return(valueByte); } } throw new NotFoundException(); }
/// <summary> /// Validates a change to a property /// </summary> /// <param name="propertyName">The name of the property that has changed</param> protected override void ValidatePropertyChange(string propertyName) { base.ValidatePropertyChange(propertyName); switch (propertyName) { case "SearchAttribute": if (this.SearchAttribute == null) { this.AddError("SearchAttribute", "A search attribute must be provided"); } else { this.RemoveError("SearchAttribute"); if (!ComparisonEngine.IsAllowedOperator(this.Operator, this.SearchAttribute.Type) && (!ComparisonEngine.IsAllowedPresenceOperator(this.Operator))) { this.AddError("Operator", "The specified search operator is not valid for this data type"); } else { this.RemoveError("Operator"); } } break; case "Operator": if (this.SearchAttribute != null) { if (!ComparisonEngine.IsAllowedOperator(this.Operator, this.SearchAttribute.Type) && (!ComparisonEngine.IsAllowedPresenceOperator(this.Operator))) { this.AddError("Operator", "The specified search operator is not valid for this data type"); } else { this.RemoveError("Operator"); } } break; default: break; } }
/// <summary> /// Evaluates a specific value against the rule /// </summary> /// <param name="actualValue">The value to evaluate</param> /// <returns>A value indicating whether the rule conditions were met</returns> protected bool EvaluateAttributeValue(object actualValue, IList <object> expectedValues) { if (actualValue == null) { if (this.CompareAs == ExtendedAttributeType.Boolean) { actualValue = false; } else { this.RaiseRuleFailure(string.Format("The source value was null")); return(false); } } bool result = false; foreach (object expectedValue in expectedValues) { switch (this.CompareAs) { case ExtendedAttributeType.Binary: result = ComparisonEngine.CompareBinary(TypeConverter.ConvertData <byte[]>(actualValue), TypeConverter.ConvertData <byte[]>(expectedValue), this.ValueOperator); break; case ExtendedAttributeType.Boolean: result = ComparisonEngine.CompareBoolean(TypeConverter.ConvertData <bool>(actualValue), TypeConverter.ConvertData <bool>(expectedValue), this.ValueOperator); break; case ExtendedAttributeType.Integer: result = ComparisonEngine.CompareLong(TypeConverter.ConvertData <long>(actualValue), TypeConverter.ConvertData <long>(expectedValue), this.ValueOperator); break; case ExtendedAttributeType.DateTime: result = ComparisonEngine.CompareDateTime(TypeConverter.ConvertData <DateTime>(actualValue), TypeConverter.ConvertData <DateTime>(expectedValue), this.ValueOperator); break; case ExtendedAttributeType.String: result = ComparisonEngine.CompareString(TypeConverter.ConvertData <string>(actualValue), TypeConverter.ConvertData <string>(expectedValue), this.ValueOperator); break; case ExtendedAttributeType.Reference: result = ComparisonEngine.CompareString(TypeConverter.ConvertData <string>(actualValue), TypeConverter.ConvertData <string>(expectedValue), this.ValueOperator); break; default: throw new UnknownOrUnsupportedDataTypeException(); } if (result) { break; } } if (!result) { this.RaiseRuleFailure("Comparison failed\nComparison Operator: {0}\nExpected Values: {1}\nActual Value: {2}", this.ValueOperator.ToString(), expectedValues.Select(t => t.ToSmartStringOrNull()).ToCommaSeparatedString(), actualValue.ToSmartString()); } return(result); }