protected virtual bool CheckForValue(string src, FilterOperatorEnum @operator, string value)
{
switch (@operator)
{
case FilterOperatorEnum.StartsWith:
return(src.StartsWith(value, StringComparison.InvariantCultureIgnoreCase));
case FilterOperatorEnum.Equals:
return(src.Equals(value, StringComparison.InvariantCultureIgnoreCase));
case FilterOperatorEnum.NotEquals:
return(!src.Equals(value, StringComparison.InvariantCultureIgnoreCase));
case FilterOperatorEnum.EndsWith:
return(src.EndsWith(value, StringComparison.InvariantCultureIgnoreCase));
case FilterOperatorEnum.Regex:
return(Regex.IsMatch(src, value, RegexOptions.CultureInvariant | RegexOptions.IgnoreCase));
case FilterOperatorEnum.Contains:
return(src.Contains(value, StringComparison.InvariantCultureIgnoreCase));
}
return(false);
}
///// <summary>
///// Initializes a new instance of the <see cref="Filter" /> class.
///// </summary>
///// <param name="columnName">Name of the column.</param>
///// <param name="value">The value.</param>
//public Filter(string columnName, FilterOperatorEnum filterOperator)
// : this(columnName, null, filterOperator)
//{
//}
/// <summary>
/// Initializes a new instance of the <see cref="Filter" /> class.
/// </summary>
/// <param name="columnName">Name of the column.</param>
/// <param name="value">The value.</param>
/// <param name="filterOperator">The filter operator.</param>
public Filter(string columnName, object value, FilterOperatorEnum filterOperator)
{
Check.Require(string.IsNullOrEmpty(columnName) == false);
CheckValueTypeRegardingTheOperator(value, filterOperator);
_ColumnName = columnName;
_Operator = filterOperator;
CheckValueTypeRegardingTheOperator(value, this.Operator);
_Value = value;
}
public void FilterConstructorTest1()
{
string columnName = vTestCaseTester.ColumnNames.FieldString;
object value = "(Select * from TestCaseTester)";
FilterOperatorEnum op = FilterOperatorEnum.InSelect;
Filter target = new Filter(columnName, value, op);
Assert.AreEqual(target.ColumnName, columnName);
Assert.AreEqual(target.Value, value);
Assert.AreEqual(target.Operator, op);
}
public void OperatorTest()
{
string columnName = vTestCaseTester.ColumnNames.FieldString;
FilterOperatorEnum filterOperator = FilterOperatorEnum.Contains;
Filter target = new Filter(columnName, "Ali", filterOperator);
FilterOperatorEnum expected = FilterOperatorEnum.Contains;
FilterOperatorEnum actual;
actual = target.Operator;
Assert.AreEqual(expected, actual);
}
public void ColumnNameTest()
{
string columnName = vTestCaseTester.ColumnNames.FieldString;
FilterOperatorEnum filterOperator = FilterOperatorEnum.Like;
Filter target = new Filter(columnName, "Ali", filterOperator);
string expected = vTestCaseTester.ColumnNames.FieldString;
string actual;
actual = target.ColumnName;
Assert.AreEqual(expected, actual);
}
public void ValueTest()
{
string columnName = vTestCaseTester.ColumnNames.FieldString;
FilterOperatorEnum filterOperator = FilterOperatorEnum.EqualTo;
Guid g = Guid.NewGuid();
Filter target = new Filter(columnName, g, filterOperator);
object expected = g;
object actual;
actual = target.Value;
Assert.AreEqual(expected, actual);
}
public void GetFilterStringTest()
{
string columnName = vTestCaseTester.ColumnNames.FieldString;
FilterOperatorEnum filterOperator = FilterOperatorEnum.Like;
Filter target = new Filter(columnName, "C1", filterOperator);
ICollection <object> values = new List <object>();
string expected = "[" + vTestCaseTester.ColumnNames.FieldString + "] like " + Filter.ParameterPrefix + "0";
string actual;
actual = target.GetFilterString(values);
Assert.AreEqual(expected, actual);
}
/// <summary>
/// Checks the value type regarding the operator.
/// </summary>
/// <param name="value">The value.</param>
/// <param name="filterOperator">The filter operator.</param>
private static void CheckValueTypeRegardingTheOperator(object value, FilterOperatorEnum filterOperator)
{
switch (filterOperator)
{
case FilterOperatorEnum.NoFilter:
break;
case FilterOperatorEnum.Contains:
Check.Require(value is string);
break;
case FilterOperatorEnum.DoesNotContain:
Check.Require(value is string);
break;
case FilterOperatorEnum.StartsWith:
Check.Require(value is string);
break;
case FilterOperatorEnum.EndsWith:
Check.Require(value is string);
break;
case FilterOperatorEnum.EqualTo:
Check.Require(value != null);
break;
case FilterOperatorEnum.NotEqualTo:
Check.Require(value != null);
break;
case FilterOperatorEnum.GreaterThan:
Check.Require(value != null);
break;
case FilterOperatorEnum.LessThan:
Check.Require(value != null);
break;
case FilterOperatorEnum.GreaterThanOrEqualTo:
Check.Require(value != null);
break;
case FilterOperatorEnum.LessThanOrEqualTo:
Check.Require(value != null);
break;
case FilterOperatorEnum.IsEmpty:
Check.Require(value == null);
break;
case FilterOperatorEnum.NotIsEmpty:
Check.Require(value == null);
break;
case FilterOperatorEnum.IsNull:
Check.Require(value == null);
break;
case FilterOperatorEnum.NotIsNull:
Check.Require(value == null);
break;
case FilterOperatorEnum.Like:
Check.Require(value is string);
break;
case FilterOperatorEnum.In:
Check.Require(value is string || value is IEnumerable);
break;
case FilterOperatorEnum.InSelect:
Check.Require(value is string);
break;
default:
throw new NotImplementedException();
}
}
bool _FilterOperatorSingleRow; // false for Top/Bottom N and Percent; otherwise true
internal Filter(ReportDefn r, ReportLink p, XmlNode xNode)
: base(r, p)
{
_FilterExpression = null;
_FilterOperator = FilterOperatorEnum.Unknown;
_FilterValues = null;
// Loop thru all the child nodes
foreach (XmlNode xNodeLoop in xNode.ChildNodes)
{
if (xNodeLoop.NodeType != XmlNodeType.Element)
{
continue;
}
switch (xNodeLoop.Name)
{
case "FilterExpression":
_FilterExpression = new Expression(r, this, xNodeLoop, ExpressionType.Variant);
break;
case "Operator":
_FilterOperator = Rdl.FilterOperator.GetStyle(xNodeLoop.InnerText);
if (_FilterOperator == FilterOperatorEnum.Unknown)
{
OwnerReport.rl.LogError(8, "Unknown Filter operator '" + xNodeLoop.InnerText + "'.");
}
break;
case "FilterValues":
_FilterValues = new FilterValues(r, this, xNodeLoop);
break;
default:
// don't know this element - log it
OwnerReport.rl.LogError(4, "Unknown Filter element '" + xNodeLoop.Name + "' ignored.");
break;
}
}
if (_FilterExpression == null)
{
OwnerReport.rl.LogError(8, "Filter requires the FilterExpression element.");
}
if (_FilterValues == null)
{
OwnerReport.rl.LogError(8, "Filter requires the FilterValues element.");
return; // some of the filter operator checks require values
}
_FilterOperatorSingleRow = true;
switch (_FilterOperator)
{
case FilterOperatorEnum.Like:
case FilterOperatorEnum.Equal:
case FilterOperatorEnum.NotEqual:
case FilterOperatorEnum.GreaterThan:
case FilterOperatorEnum.GreaterThanOrEqual:
case FilterOperatorEnum.LessThan:
case FilterOperatorEnum.LessThanOrEqual:
if (_FilterValues.Items.Count != 1)
{
OwnerReport.rl.LogError(8, "Filter Operator requires exactly 1 FilterValue.");
}
break;
case FilterOperatorEnum.TopN:
case FilterOperatorEnum.BottomN:
case FilterOperatorEnum.TopPercent:
case FilterOperatorEnum.BottomPercent:
_FilterOperatorSingleRow = false;
if (_FilterValues.Items.Count != 1)
{
OwnerReport.rl.LogError(8, "Filter Operator requires exactly 1 FilterValue.");
}
break;
case FilterOperatorEnum.In:
break;
case FilterOperatorEnum.Between:
if (_FilterValues.Items.Count != 2)
{
OwnerReport.rl.LogError(8, "Filter Operator Between requires exactly 2 FilterValues.");
}
break;
default:
OwnerReport.rl.LogError(8, "Valid Filter operator must be specified.");
break;
}
}
FilterValues _FilterValues; // The values to compare to the FilterExpression.
#endregion Fields
#region Constructors
internal Filter(ReportDefn r, ReportLink p, XmlNode xNode)
: base(r, p)
{
_FilterExpression=null;
_FilterOperator=FilterOperatorEnum.Unknown;
_FilterValues=null;
// Loop thru all the child nodes
foreach(XmlNode xNodeLoop in xNode.ChildNodes)
{
if (xNodeLoop.NodeType != XmlNodeType.Element)
continue;
switch (xNodeLoop.Name)
{
case "FilterExpression":
_FilterExpression = new Expression(r, this, xNodeLoop, ExpressionType.Variant);
break;
case "Operator":
_FilterOperator = RDL.FilterOperator.GetStyle(xNodeLoop.InnerText);
if (_FilterOperator == FilterOperatorEnum.Unknown)
OwnerReport.rl.LogError(8, "Unknown Filter operator '" + xNodeLoop.InnerText + "'.");
break;
case "FilterValues":
_FilterValues = new FilterValues(r, this, xNodeLoop);
break;
default:
// don't know this element - log it
OwnerReport.rl.LogError(4, "Unknown Filter element '" + xNodeLoop.Name + "' ignored.");
break;
}
}
if (_FilterExpression == null)
OwnerReport.rl.LogError(8, "Filter requires the FilterExpression element.");
if (_FilterValues == null)
{
OwnerReport.rl.LogError(8, "Filter requires the FilterValues element.");
return; // some of the filter operator checks require values
}
_FilterOperatorSingleRow = true;
switch (_FilterOperator)
{
case FilterOperatorEnum.Like:
case FilterOperatorEnum.Equal:
case FilterOperatorEnum.NotEqual:
case FilterOperatorEnum.GreaterThan:
case FilterOperatorEnum.GreaterThanOrEqual:
case FilterOperatorEnum.LessThan:
case FilterOperatorEnum.LessThanOrEqual:
if (_FilterValues.Items.Count != 1)
OwnerReport.rl.LogError(8, "Filter Operator requires exactly 1 FilterValue.");
break;
case FilterOperatorEnum.TopN:
case FilterOperatorEnum.BottomN:
case FilterOperatorEnum.TopPercent:
case FilterOperatorEnum.BottomPercent:
_FilterOperatorSingleRow = false;
if (_FilterValues.Items.Count != 1)
OwnerReport.rl.LogError(8, "Filter Operator requires exactly 1 FilterValue.");
break;
case FilterOperatorEnum.In:
break;
case FilterOperatorEnum.Between:
if (_FilterValues.Items.Count != 2)
OwnerReport.rl.LogError(8, "Filter Operator Between requires exactly 2 FilterValues.");
break;
default:
OwnerReport.rl.LogError(8, "Valid Filter operator must be specified.");
break;
}
}
protected virtual bool CheckForValue(string src, FilterOperatorEnum @operator, string value)
{
switch (@operator)
{
case FilterOperatorEnum.StartsWith:
return src.StartsWith(value, StringComparison.InvariantCultureIgnoreCase);
case FilterOperatorEnum.Equals:
return src.Equals(value, StringComparison.InvariantCultureIgnoreCase);
case FilterOperatorEnum.NotEquals:
return !src.Equals(value, StringComparison.InvariantCultureIgnoreCase);
case FilterOperatorEnum.EndsWith:
return src.EndsWith(value, StringComparison.InvariantCultureIgnoreCase);
case FilterOperatorEnum.Regex:
return Regex.IsMatch(src, value, RegexOptions.CultureInvariant | RegexOptions.IgnoreCase);
case FilterOperatorEnum.Contains:
return src.Contains(value, StringComparison.InvariantCultureIgnoreCase);
}
return false;
}
/// <summary>
/// Turns a guid array into a dynamic filter expression that openaccess can use
/// </summary>
public static string GenerateFilterExpression(this Guid[] elements, string fieldname, FilterOperatorEnum decision, bool wrapInBraces = true)
{
string filter = String.Empty;
foreach (var c in elements)
{
filter += "{0}.Contains(\"{{{1}}}\") {2} ".Arrange(fieldname, c, decision.ToString());
}
if (String.IsNullOrEmpty(filter))
{
return(filter);
}
else
{
//Strip the end operator
filter = filter.Substring(0, filter.Length - (decision.ToString().Length + 2));
return((wrapInBraces) ? " (" + filter + ") " : filter);
}
}
// This is only override method to simplify programming
/// <summary>
/// Adds a new filter to filter expression
/// </summary>
/// <param name="columnName">column Name</param>
/// <param name="value">value</param>
public void AddFilter(string columnName, object value, FilterOperatorEnum filterOperator)
{
FiltersList.Add(new Filter(columnName, value, filterOperator));
}
// This is only override method to simplify programming
/// <summary>
/// Adds a new filter to filter expression
/// </summary>
/// <param name="columnName">column Name</param>
/// <param name="value">value</param>
/// <param name="filterOperator">filter operator</param>
public FilterExpression(string columnName, object value, FilterOperatorEnum filterOperator)
{
this.AddFilter(columnName, value, filterOperator);
}
