/// <summary>
/// Adds a TextBox filter in which users can specify text that
/// a string-value column will be filtered on.
/// </summary>
/// <param name="labelText">The label to appear before the control</param>
/// <param name="propertyName">The business object property on which to filter</param>
/// <param name="filterClauseOperator">The operator to use for the filter clause</param>
/// <returns>Returns the new TextBox added</returns>
public ITextBox AddStringFilterTextBox(string labelText, string propertyName,
FilterClauseOperator filterClauseOperator)
{
ICustomFilter filter = _filterControlManager.AddStringFilterTextBox(labelText, propertyName, filterClauseOperator);
filter.ValueChanged += (sender, e) => { if (this.FilterMode == FilterModes.Filter) FireFilterEvent(); };
return (ITextBox)filter.Control;
}
/// <summary>
/// Creates a new filter clause that filters integer values
/// </summary>
/// <param name="filterColumn">The column of data on which to do the
/// filtering</param>
/// <param name="clauseOperator">The clause operator</param>
/// <param name="filterValue">The filter value to be compared to</param>
/// <returns>Returns the new filter clause object</returns>
public IFilterClause CreateDateFilterClause(string filterColumn, FilterClauseOperator clauseOperator,
DateTime filterValue)
{
//BusinessObject b = new BusinessObject();
//b.Props["test"].PropertyValueString
return(new DataViewDateFilterClause(filterColumn, clauseOperator, filterValue));
}
/// <summary>
/// Creates a new filter clause that filters integer values
/// </summary>
/// <param name="filterColumn">The column of data on which to do the
/// filtering</param>
/// <param name="clauseOperator">The clause operator</param>
/// <param name="filterValue">The filter value to be compared to</param>
/// <returns>Returns the new filter clause object</returns>
public IFilterClause CreateDateFilterClause(string filterColumn, FilterClauseOperator clauseOperator,
DateTime filterValue)
{
//BusinessObject b = new BusinessObject();
//b.Props["test"].PropertyValueString
return new DataViewDateFilterClause(filterColumn, clauseOperator, filterValue);
}
/// <summary>
/// Adds a TextBox filter in which users can specify text that
/// a string-value column will be filtered on.
/// </summary>
/// <param name="labelText">The label to appear before the control</param>
/// <param name="propertyName">The business object property on which to filter</param>
/// <param name="filterClauseOperator">The operator to use for the filter clause</param>
/// <returns>Returns the new TextBox added</returns>
public ITextBox AddStringFilterTextBox(string labelText, string propertyName,
FilterClauseOperator filterClauseOperator)
{
ICustomFilter filter = _filterControlManager.AddStringFilterTextBox(labelText, propertyName, filterClauseOperator);
return((ITextBox)filter.Control);
}
///<summary>
/// An overridden constructor for controlFactory, propertyName and filterClauseOperator.
///</summary>
///<param name="controlFactory"></param>
///<param name="propertyName"></param>
///<param name="filterClauseOperator"></param>
public DateTimePickerFilter(IControlFactory controlFactory, string propertyName, FilterClauseOperator filterClauseOperator)
{
_controlFactory = controlFactory;
_propertyName = propertyName;
_filterClauseOperator = filterClauseOperator;
_dateTimePicker = _controlFactory.CreateDateTimePicker();
_dateTimePicker.ValueChanged += (sender, e) => FireValueChanged();
}
///<summary>
/// Constructor for <see cref="StringTextBoxFilter"/>
///</summary>
///<param name="controlFactory"></param>
///<param name="propertyName"></param>
///<param name="filterClauseOperator"></param>
public StringTextBoxFilter(IControlFactory controlFactory, string propertyName, FilterClauseOperator filterClauseOperator)
{
_controlFactory = controlFactory;
_propertyName = propertyName;
_filterClauseOperator = filterClauseOperator;
_textBox = _controlFactory.CreateTextBox();
_textBox.TextChanged += (sender, e) => FireValueChanged();
}
///<summary>
/// Constructor with controlFactory, propertyName and filterClauseOperator
///</summary>
///<param name="controlFactory"></param>
///<param name="propertyName"></param>
///<param name="filterClauseOperator"></param>
///<param name="enumType"></param>
public EnumComboBoxFilter(IControlFactory controlFactory, string propertyName
, FilterClauseOperator filterClauseOperator, Type enumType)
:this(controlFactory, propertyName, filterClauseOperator)
{
EnumType = enumType;
if (enumType == null) throw new ArgumentNullException("enumType");
EnumType = enumType;
}
/// <summary>
/// Constructor to create a new filter clause
/// </summary>
/// <param name="filterColumn">The column of data on which to do the
/// filtering</param>
/// <param name="clauseOperator">The clause operator</param>
/// <param name="filterValue">The filter value to compare to</param>
internal DataViewIntegerFilterClause(string filterColumn, FilterClauseOperator clauseOperator, int filterValue)
: base(filterColumn, clauseOperator, filterValue)
{
if (_clauseOperator == FilterClauseOperator.OpLike)
{
throw new HabaneroArgumentException("clauseOperator",
"Operator Like is not supported for non string operands");
}
}
///<summary>
/// Constructor with controlFactory, propertyName and filterClauseOperator
///</summary>
///<param name="controlFactory"></param>
///<param name="propertyName"></param>
///<param name="filterClauseOperator"></param>
public DateRangeComboBoxFilter(IControlFactory controlFactory, string propertyName, FilterClauseOperator filterClauseOperator)
{
_controlFactory = controlFactory;
_propertyName = propertyName;
_filterClauseOperator = filterClauseOperator;
_dateRangeComboBox = _controlFactory.CreateDateRangeComboBox();
_dateRangeComboBox.SelectedIndexChanged += (sender, e) => FireValueChanged();
_dateRangeComboBox.TextChanged += (sender, e) => FireValueChanged();
}
/// <summary>
/// Constructor to create a new filter clause
/// </summary>
/// <param name="filterColumn">The column of data on which to do the
/// filtering</param>
/// <param name="clauseOperator">The clause operator</param>
/// <param name="filterValue">The filter value to compare to</param>
internal DataViewEnumFilterClause(string filterColumn, FilterClauseOperator clauseOperator, object filterValue)
: base(filterColumn, clauseOperator, filterValue)
{
if (_clauseOperator == FilterClauseOperator.OpLike)
{
throw new HabaneroArgumentException("clauseOperator",
"Operator Like is not supported for non string operands");
}
}
///<summary>
/// A Constructor for the BoolCheckBoxFilter
///</summary>
///<param name="controlFactory"></param>
///<param name="propertyName"></param>
///<param name="filterClauseOperator"></param>
public BoolCheckBoxFilter(IControlFactory controlFactory, string propertyName, FilterClauseOperator filterClauseOperator)
{
_controlFactory = controlFactory;
_propertyName = propertyName;
_filterClauseOperator = filterClauseOperator;
_checkBox = _controlFactory.CreateCheckBox();
_checkBox.Width = 10;
_checkBox.Text = "";
_checkBox.CheckedChanged += (sender, e) => FireValueChanged();
}
/// <summary>
/// Adds a date-time picker that filters a date column on the date
/// chosen by the user. The given operator compares the chosen date
/// with the date shown in the given column name.
/// </summary>
/// <param name="labelText">The label to appear before the control</param>
/// <param name="propertyName">The business object property on which to filter</param>
/// <param name="defaultValue">The default date or null</param>
/// <param name="filterClauseOperator">The operator used to compare
/// with the date chosen by the user. The chosen date is on the
/// right side of the equation.</param>
/// <param name="nullable">Whether the datetime picker allows null values</param>
/// <returns>Returns the new DateTimePicker added</returns>
public IDateTimePicker AddDateFilterDateTimePicker(string labelText, string propertyName, DateTime? defaultValue,
FilterClauseOperator filterClauseOperator, bool nullable)
{
ICustomFilter filter =
_filterControlManager.AddDateFilterDateTimePicker(labelText, propertyName, filterClauseOperator, defaultValue);
filter.ValueChanged += delegate { if (this.FilterMode == FilterModes.Filter) FireFilterEvent(); };
return (IDateTimePicker)filter.Control;
}
///<summary>
/// Constructor for <see cref="MultiplePropStringTextBoxFilter"/>
///</summary>
///<param name="controlFactory"></param>
///<param name="propertyNames"></param>
///<param name="filterClauseOperator"></param>
public MultiplePropStringTextBoxFilter(IControlFactory controlFactory, List <string> propertyNames,
FilterClauseOperator filterClauseOperator)
{
_controlFactory = controlFactory;
_propertyNames = propertyNames;
_propertyNames.Sort((s, s1) => s1.CompareTo(s));
_filterClauseOperator = filterClauseOperator;
_textBox = _controlFactory.CreateTextBox();
_textBox.TextChanged += (sender, e) => FireValueChanged();
}
///<summary>
/// Constructor with controlFactory, propertyName and filterClauseOperator
///</summary>
///<param name="controlFactory"></param>
///<param name="propertyName"></param>
///<param name="filterClauseOperator"></param>
///<param name="enumType"></param>
public EnumComboBoxFilter(IControlFactory controlFactory, string propertyName
, FilterClauseOperator filterClauseOperator)
{
_controlFactory = controlFactory;
_propertyName = propertyName;
_filterClauseOperator = filterClauseOperator;
_comboBox = _controlFactory.CreateComboBox();
_comboBox.SelectedIndexChanged += (sender, e) => FireValueChanged();
_comboBox.TextChanged += (sender,e) => FireValueChanged();
}
///<summary>
/// Constructor for <see cref="MultiplePropStringTextBoxFilter"/>
///</summary>
///<param name="controlFactory"></param>
///<param name="propertyNames"></param>
///<param name="filterClauseOperator"></param>
public MultiplePropStringTextBoxFilter(IControlFactory controlFactory, List<string> propertyNames,
FilterClauseOperator filterClauseOperator)
{
_controlFactory = controlFactory;
_propertyNames = propertyNames;
_propertyNames.Sort((s, s1) => s1.CompareTo(s));
_filterClauseOperator = filterClauseOperator;
_textBox = _controlFactory.CreateTextBox();
_textBox.TextChanged += (sender, e) => FireValueChanged();
}
/// <summary>
/// Adds a date-time picker that filters a date column on the date
/// chosen by the user. The given operator compares the chosen date
/// with the date shown in the given column name.
/// </summary>
/// <param name="labelText">The label to appear before the control</param>
/// <param name="propertyName">The business object property on which to filter</param>
/// <param name="defaultValue">The default date or null</param>
/// <param name="filterClauseOperator">The operator used to compare
/// with the date chosen by the user. The chosen date is on the
/// right side of the equation.</param>
/// <param name="nullable">Whether the datetime picker allows null values</param>
/// <returns>Returns the new DateTimePicker added</returns>
public IDateTimePicker AddDateFilterDateTimePicker(string labelText, string propertyName, DateTime?defaultValue,
FilterClauseOperator filterClauseOperator, bool nullable)
{
//IDateTimePicker dtPicker =
// _filterControlManager.AddDateFilterDateTimePicker(labelText, propertyName, filterClauseOperator, nullable,
// defaultValue);
ICustomFilter customFilter =
_filterControlManager.AddDateFilterDateTimePicker(labelText, propertyName, filterClauseOperator, defaultValue);
return((IDateTimePicker)customFilter.Control);
}
///<summary>
/// Constructor with controlFactory, propertyName and filterClauseOperator
///</summary>
///<param name="controlFactory"></param>
///<param name="propertyName"></param>
///<param name="filterClauseOperator"></param>
///<param name="enumType"></param>
public EnumComboBoxFilter(IControlFactory controlFactory, string propertyName
, FilterClauseOperator filterClauseOperator, Type enumType)
: this(controlFactory, propertyName, filterClauseOperator)
{
EnumType = enumType;
if (enumType == null)
{
throw new ArgumentNullException("enumType");
}
EnumType = enumType;
}
/// <summary>
/// Standard constructor
/// </summary>
/// <param name="propertyName">See <see cref="PropertyName"/></param>
/// <param name="label">See <see cref="Label"/></param>
/// <param name="filterType">See <see cref="FilterType"/></param>
/// <param name="filterTypeAssembly">See <see cref="FilterTypeAssembly"/></param>
/// <param name="filterClauseOperator">See <see cref="FilterClauseOperator"/></param>
/// <param name="parameters">See <see cref="Parameters"/></param>
public FilterPropertyDef(string propertyName, string label, string filterType,
string filterTypeAssembly, FilterClauseOperator filterClauseOperator,
Dictionary<string, string> parameters)
{
PropertyName = propertyName;
Label = label;
FilterType = filterType;
FilterTypeAssembly = filterTypeAssembly;
FilterClauseOperator = filterClauseOperator;
Parameters = parameters;
if (string.IsNullOrEmpty(FilterTypeAssembly)) FilterTypeAssembly = "Habanero.Faces.Base";
}
public void Test_GetFilterClause()
{
//---------------Set up test pack-------------------
string propertyName = TestUtil.GetRandomString();
const FilterClauseOperator filterClauseOperator = FilterClauseOperator.OpGreaterThan;
const string filterValue = "constantValue";
StringStaticFilter filter = new StringStaticFilter(propertyName, filterClauseOperator, filterValue);
//---------------Execute Test ----------------------
IFilterClause filterClause = filter.GetFilterClause(new DataViewFilterClauseFactory());
//---------------Test Result -----------------------
Assert.AreEqual(string.Format("{0} > '{1}'", propertyName, filterValue), filterClause.GetFilterClauseString());
}
public void Test_GetFilterClause_WhenOpIs_ShouldNotSetValueDelimiters()
{
//---------------Set up test pack-------------------
string propertyName = TestUtil.GetRandomString();
const FilterClauseOperator filterClauseOperator = FilterClauseOperator.Is;
const string filterValue = "NULL";
StringStaticFilter filter = new StringStaticFilter(propertyName, filterClauseOperator, filterValue);
//---------------Execute Test ----------------------
IFilterClause filterClause = filter.GetFilterClause(new DataViewFilterClauseFactory());
//---------------Test Result -----------------------
Assert.AreEqual(string.Format("{0} Is {1}", propertyName, filterValue), filterClause.GetFilterClauseString());
}
/// <summary>
/// Constructor that creates a FilterPropertyDef class with a specified Filter control type using a type parameter.
/// </summary>
/// <param name="propertyName">See <see cref="PropertyName"/></param>
/// <param name="label">See <see cref="Label"/></param>
/// <param name="filterType"> The <see cref="Type"/> object that will determine the values of the <see cref="FilterType"/> and the <see cref="FilterTypeAssembly"/> properties.</param>
/// <param name="filterClauseOperator">See <see cref="FilterClauseOperator"/></param>
/// <param name="parameters">See <see cref="Parameters"/></param>
public FilterPropertyDef(string propertyName, string label, Type filterType,
FilterClauseOperator filterClauseOperator,
Dictionary<string, string> parameters)
{
PropertyName = propertyName;
Label = label;
string assemblyName;
string classNameFull;
TypeLoader.ClassTypeInfo(filterType, out assemblyName, out classNameFull);
FilterType = classNameFull;
FilterTypeAssembly = assemblyName;
FilterClauseOperator = filterClauseOperator;
Parameters = parameters;
}
public void Test_BuildCustomFilter_FilterClauseOperator()
{
//---------------Set up test pack-------------------
FilterControlBuilder builder = new FilterControlBuilder(GetControlFactory());
const FilterClauseOperator op = FilterClauseOperator.OpLessThanOrEqualTo;
FilterPropertyDef filterPropertyDef1 = CreateFilterPropertyDef(op);
//---------------Execute Test ----------------------
ICustomFilter customFilter = builder.BuildCustomFilter(filterPropertyDef1);
//---------------Test Result -----------------------
Assert.AreEqual(op, customFilter.FilterClauseOperator);
}
public void TestConstructor_WhenFilterValueNull_ShouldReturnNullFilterClause()
{
//---------------Set up test pack-------------------
string propertyName = TestUtil.GetRandomString();
const FilterClauseOperator filterClauseOperator = FilterClauseOperator.OpGreaterThan;
//---------------Execute Test ----------------------
StringStaticFilter filter = new StringStaticFilter(propertyName, filterClauseOperator, null);
//---------------Test Result -----------------------
Assert.IsNull(filter.Control);
Assert.AreEqual(propertyName, filter.PropertyName);
Assert.AreEqual(filterClauseOperator, filter.FilterClauseOperator);
Assert.IsInstanceOf(typeof(DataViewNullFilterClause), filter.GetFilterClause(new DataViewFilterClauseFactory()));
}
/// <summary>
/// Loads all the data out of the reader, assuming the document is
/// well-formed, otherwise the error must be caught and thrown.
/// By the end of this method the reader must be finished reading.
/// This method needs to be implemented by the sub-class.
/// </summary>
protected override void LoadFromReader()
{
if (_reader.Name == "filter")
{
_reader.Read();
string filterModeStr = _reader.GetAttribute("filterMode");
_filterMode = (FilterModes)Enum.Parse(typeof(FilterModes), filterModeStr);
_columns = Convert.ToInt32(_reader.GetAttribute("columns"));
}
_reader.Read();
while (_reader.Name == "filterProperty")
{
string propertyName = _reader.GetAttribute("name");
string label = _reader.GetAttribute("label");
string filterType = _reader.GetAttribute("filterType");
string filterTypeAssembly = _reader.GetAttribute("filterTypeAssembly");
string filterClauseOperatorStr = _reader.GetAttribute("operator");
FilterClauseOperator filterClauseOperator
= (FilterClauseOperator)Enum.Parse(typeof(FilterClauseOperator), filterClauseOperatorStr);
Dictionary <string, string> parameters = new Dictionary <string, string>();
IFilterPropertyDef filterPropertyDef =
_defClassFactory.CreateFilterPropertyDef(propertyName, label, filterType, filterTypeAssembly, filterClauseOperator, parameters);
_reader.Read();
if (_reader.Name == "parameter")
{
while (_reader.Name == "parameter")
{
string name = _reader.GetAttribute("name");
string value = _reader.GetAttribute("value");
parameters.Add(name, value);
_reader.Read();
}
_reader.Read();
}
_propertyDefs.Add(filterPropertyDef);
if (!_reader.IsStartElement())
{
_reader.ReadEndElement();
}
filterPropertyDef.Parameters = parameters;
}
while (_reader.Name == "filter")
{
_reader.Read();
}
}
/// <summary>
/// Constructor that creates a FilterPropertyDef class with a specified Filter control type using a type parameter.
/// </summary>
/// <param name="propertyName">See <see cref="PropertyName"/></param>
/// <param name="label">See <see cref="Label"/></param>
/// <param name="filterType"> The <see cref="Type"/> object that will determine the values of the <see cref="FilterType"/> and the <see cref="FilterTypeAssembly"/> properties.</param>
/// <param name="filterClauseOperator">See <see cref="FilterClauseOperator"/></param>
/// <param name="parameters">See <see cref="Parameters"/></param>
public FilterPropertyDef(string propertyName, string label, Type filterType,
FilterClauseOperator filterClauseOperator,
Dictionary <string, string> parameters)
{
PropertyName = propertyName;
Label = label;
string assemblyName;
string classNameFull;
TypeLoader.ClassTypeInfo(filterType, out assemblyName, out classNameFull);
FilterType = classNameFull;
FilterTypeAssembly = assemblyName;
FilterClauseOperator = filterClauseOperator;
Parameters = parameters;
}
/// <summary>
/// Standard constructor
/// </summary>
/// <param name="propertyName">See <see cref="PropertyName"/></param>
/// <param name="label">See <see cref="Label"/></param>
/// <param name="filterType">See <see cref="FilterType"/></param>
/// <param name="filterTypeAssembly">See <see cref="FilterTypeAssembly"/></param>
/// <param name="filterClauseOperator">See <see cref="FilterClauseOperator"/></param>
/// <param name="parameters">See <see cref="Parameters"/></param>
public FilterPropertyDef(string propertyName, string label, string filterType,
string filterTypeAssembly, FilterClauseOperator filterClauseOperator,
Dictionary <string, string> parameters)
{
PropertyName = propertyName;
Label = label;
FilterType = filterType;
FilterTypeAssembly = filterTypeAssembly;
FilterClauseOperator = filterClauseOperator;
Parameters = parameters;
if (string.IsNullOrEmpty(FilterTypeAssembly))
{
FilterTypeAssembly = "Habanero.Faces.Base";
}
}
public void TestConstructor()
{
//---------------Set up test pack-------------------
string propertyName = TestUtil.GetRandomString();
const FilterClauseOperator filterClauseOperator = FilterClauseOperator.OpGreaterThan;
//---------------Execute Test ----------------------
StringTextBoxFilter filter = new StringTextBoxFilter(GetControlFactory(), propertyName, filterClauseOperator);
//---------------Test Result -----------------------
Assert.IsInstanceOf(typeof(ITextBox), filter.Control);
Assert.AreEqual(propertyName, filter.PropertyName);
Assert.AreEqual(filterClauseOperator, filter.FilterClauseOperator);
Assert.IsInstanceOf(typeof(DataViewNullFilterClause), filter.GetFilterClause(new DataViewFilterClauseFactory()));
}
///<summary>
/// Returns the filter clause for this control
///</summary>
///<param name="filterClauseFactory"></param>
///<returns></returns>
public IFilterClause GetFilterClause(IFilterClauseFactory filterClauseFactory)
{
if (_dateRangeComboBox.SelectedIndex > 0)
{
FilterClauseOperator op = _includeStartDate ? FilterClauseOperator.OpGreaterThanOrEqualTo : FilterClauseOperator.OpGreaterThan;
IFilterClause startClause = filterClauseFactory.CreateDateFilterClause(_propertyName, op, _dateRangeComboBox.StartDate);
op = _includeEndDate
? FilterClauseOperator.OpLessThanOrEqualTo
: FilterClauseOperator.OpLessThan;
IFilterClause endClause = filterClauseFactory.CreateDateFilterClause(_propertyName, op, _dateRangeComboBox.EndDate);
return
(filterClauseFactory.CreateCompositeFilterClause(startClause, FilterClauseCompositeOperator.OpAnd,
endClause));
}
return(filterClauseFactory.CreateNullFilterClause());
}
public void Test_Construct_WhenFilterValueSet_ShouldReturnStringFilterClause()
{
//---------------Set up test pack-------------------
string propertyName = TestUtil.GetRandomString();
const FilterClauseOperator filterClauseOperator = FilterClauseOperator.OpGreaterThan;
const string filterValue = "constantValue";
//---------------Execute Test ----------------------
StringStaticFilter filter = new StringStaticFilter(propertyName, filterClauseOperator, filterValue);
//---------------Test Result -----------------------
Assert.IsNull(filter.Control);
Assert.AreEqual(propertyName, filter.PropertyName);
Assert.AreEqual(filterClauseOperator, filter.FilterClauseOperator);
IFilterClause filterClause = filter.GetFilterClause(new DataViewFilterClauseFactory());
Assert.IsInstanceOf <DataViewStringFilterClause>(filterClause);
}
public void TestFilterClause()
{
//---------------Set up test pack-------------------
string propertyName = TestUtil.GetRandomString();
const FilterClauseOperator filterClauseOperator = FilterClauseOperator.OpGreaterThan;
StringTextBoxFilter filter = new StringTextBoxFilter(GetControlFactory(), propertyName, filterClauseOperator);
ITextBox textBox = (ITextBox)filter.Control;
string text = TestUtil.GetRandomString();
textBox.Text = text;
//---------------Execute Test ----------------------
IFilterClause filterClause = filter.GetFilterClause(new DataViewFilterClauseFactory());
//---------------Test Result -----------------------
Assert.AreEqual(string.Format("{0} > '{1}'", propertyName, text), filterClause.GetFilterClauseString());
//---------------Tear Down -------------------------
}
/// <summary>
/// Converts the <see cref="FilterClauseOperator"/> enum to
/// a string.
/// </summary>
/// <param name="clauseOperator"></param>
/// <returns></returns>
public string ConvertToString(FilterClauseOperator clauseOperator)
{
string opClause;
switch (clauseOperator)
{
case FilterClauseOperator.OpEquals:
opClause = " = ";
break;
case FilterClauseOperator.OpLike:
opClause = " like ";
break;
case FilterClauseOperator.OpGreaterThanOrEqualTo:
opClause = " >= ";
break;
case FilterClauseOperator.OpLessThanOrEqualTo:
opClause = " <= ";
break;
case FilterClauseOperator.OpGreaterThan:
opClause = " > ";
break;
case FilterClauseOperator.OpLessThan:
opClause = " < ";
break;
case FilterClauseOperator.OpNotEqual:
opClause = " <> ";
break;
default:
opClause = " " + clauseOperator + " ";
//opClause = " <unsupported operator> ";
break;
}
return(opClause);
}
public void TestConstructor()
{
//---------------Set up test pack-------------------
string propertyName = "";
const FilterClauseOperator filterClauseOperator = FilterClauseOperator.OpGreaterThan;
List <string> props = new List <string> {
"prop1", "prop2", "prop3"
};
string name = propertyName;
//---------------Execute Test ----------------------
MultiplePropStringTextBoxFilter filter = new MultiplePropStringTextBoxFilter(GetControlFactory(), props, filterClauseOperator);
props.ForEach(s => name = s + "/" + name);
propertyName = name.Remove(name.Length - 1);
//---------------Test Result -----------------------
Assert.IsInstanceOf(typeof(ITextBox), filter.Control);
Assert.AreEqual(propertyName, filter.PropertyName);
Assert.AreEqual(filterClauseOperator, filter.FilterClauseOperator);
Assert.IsInstanceOf(typeof(DataViewNullFilterClause), filter.GetFilterClause(new DataViewFilterClauseFactory()));
}
public void Test_Constructor_WithStringParameters()
{
//---------------Set up test pack-------------------
string propName = TestUtil.GetRandomString();
string label = TestUtil.GetRandomString();
string filterType = TestUtil.GetRandomString();
string filterTypeAssembly = TestUtil.GetRandomString();
FilterClauseOperator filterClauseOperator = TestUtil.GetRandomEnum <FilterClauseOperator>();
Dictionary <string, string> parameters = new Dictionary <string, string>();
//---------------Assert PreConditions---------------
//---------------Execute Test ----------------------
FilterPropertyDef def = new FilterPropertyDef(propName, label, filterType, filterTypeAssembly, filterClauseOperator, parameters);
//---------------Test Result -----------------------
Assert.AreEqual(propName, def.PropertyName);
Assert.AreEqual(label, def.Label);
Assert.AreEqual(filterType, def.FilterType);
Assert.AreEqual(filterTypeAssembly, def.FilterTypeAssembly);
Assert.AreSame(parameters, def.Parameters);
Assert.AreEqual(filterClauseOperator, def.FilterClauseOperator);
}
public void TestFilterClause_2Prop()
{
//---------------Set up test pack-------------------
const FilterClauseOperator filterClauseOperator = FilterClauseOperator.OpGreaterThan;
List <string> props = new List <string> {
"prop1", "prop2"
};
MultiplePropStringTextBoxFilter filter = new MultiplePropStringTextBoxFilter(GetControlFactory(), props, filterClauseOperator);
ITextBox textBox = (ITextBox)filter.Control;
string text = TestUtil.GetRandomString();
textBox.Text = text;
//---------------Execute Test ----------------------
IFilterClause filterClause = filter.GetFilterClause(new DataViewFilterClauseFactory());
//---------------Test Result -----------------------
Assert.AreEqual(string.Format("({0} > '{2}') or ({1} > '{2}')", props[0], props[1], text), filterClause.GetFilterClauseString());
//---------------Tear Down -------------------------
}
public void Test_Constructor_WithTypeParameters()
{
//---------------Set up test pack-------------------
string propName = TestUtil.GetRandomString();
string label = TestUtil.GetRandomString();
Dictionary <string, string> parameters = new Dictionary <string, string>();
FilterClauseOperator filterClauseOperator = TestUtil.GetRandomEnum <FilterClauseOperator>();
Type filterType = typeof(MyFilterType);
//---------------Assert PreConditions---------------
//---------------Execute Test ----------------------
FilterPropertyDef def = new FilterPropertyDef(propName, label, filterType, filterClauseOperator, parameters);
//---------------Test Result -----------------------
Assert.AreEqual(propName, def.PropertyName);
Assert.AreEqual(label, def.Label);
string assemblyName;
string classNameFull;
TypeLoader.ClassTypeInfo(filterType, out assemblyName, out classNameFull);
Assert.AreEqual(classNameFull, def.FilterType);
Assert.AreEqual(assemblyName, def.FilterTypeAssembly);
Assert.AreSame(parameters, def.Parameters);
Assert.AreEqual(filterClauseOperator, def.FilterClauseOperator);
}
private static FilterPropertyDef CreateFilterPropertyDef
(string propName, FilterClauseOperator filterClauseOperator)
{
return CreateFilterPropertyDef(propName, "StringTextBoxFilter", "", filterClauseOperator);
}
/// <summary>
/// Adds a TextBox filter in which users can specify text that
/// multiple string-value columns will be filtered on.
/// </summary>
/// <param name="labelText">The label to appear before the control</param>
/// <param name="propertyNames">The business object propertys on which to filter</param>
/// <param name="filterClauseOperator">The operator to use for the filter clause</param>
/// <returns>Returns the new TextBox added</returns>
public ITextBox AddMultiplePropStringTextBox(string labelText, List<string> propertyNames, FilterClauseOperator filterClauseOperator)
{
ICustomFilter filter = _filterControlManager.AddMultiplePropStringTextBox(labelText, propertyNames,filterClauseOperator);
filter.ValueChanged += (sender, e) => { if (this.FilterMode == FilterModes.Filter) FireFilterEvent(); };
return (ITextBox)filter.Control;
}
///<summary>
/// A Constructor for the BoolCheckBoxFilter
///</summary>
///<param name="controlFactory"></param>
///<param name="propertyName"></param>
///<param name="filterClauseOperator"></param>
public BoolCheckBoxFilter(IControlFactory controlFactory, string propertyName, FilterClauseOperator filterClauseOperator)
{
_controlFactory = controlFactory;
_propertyName = propertyName;
_filterClauseOperator = filterClauseOperator;
_checkBox = _controlFactory.CreateCheckBox();
_checkBox.Width = 10;
_checkBox.Text = "";
_checkBox.CheckedChanged += (sender, e) => FireValueChanged();
}
///<summary>
/// Creates an individual <see cref="FilterPropertyDef"/> that will be used on the <see cref="FilterDef"/>
///</summary>
///<param name="propertyName">The Property Name that this <see cref="FilterPropertyDef"/> is mapped to</param>
///<param name="label">The Label Text that is displayed for this <see cref="FilterPropertyDef"/></param>
///<param name="filterType">The FilterType e.g. StringComboBoxFilter that is to use for this <see cref="FilterPropertyDef"/></param>
///<param name="filterTypeAssembly">The FilterType Assembly that is to use for this <see cref="FilterPropertyDef"/></param>
///<param name="filterClauseOperator">The <see cref="FilterClauseOperator"/> that is to use for this <see cref="FilterPropertyDef"/></param>
///<param name="parameters"></param>
///<returns></returns>
public IFilterPropertyDef CreateFilterPropertyDef(string propertyName, string label, string filterType, string filterTypeAssembly, FilterClauseOperator filterClauseOperator, Dictionary<string, string> parameters)
{
return new FilterPropertyDef(propertyName, label, filterType, filterTypeAssembly, filterClauseOperator, parameters);
}
/// <summary>
/// Constructor to create a new filter clause
/// </summary>
/// <param name="filterColumn">The column of data on which to do the
/// filtering</param>
/// <param name="clauseOperator">The clause operator</param>
/// <param name="filterValue">The filter value to compare to</param>
internal DataViewStringFilterClause(string filterColumn, FilterClauseOperator clauseOperator, string filterValue)
: base(filterColumn, clauseOperator, filterValue)
{
}
private static FilterPropertyDef CreateFilterPropertyDef(FilterClauseOperator op)
{
return CreateFilterPropertyDef(TestUtil.GetRandomString(), op);
}
/// <summary>
/// Adds a date-time picker that filters a date column on the date
/// chosen by the user. The given operator compares the chosen date
/// with the date shown in the given column name.
/// </summary>
/// <param name="labelText">The label to appear before the control</param>
/// <param name="propertyName">The business object property on which to filter</param>
/// <param name="defaultValue">The default date or null</param>
/// <param name="filterClauseOperator">The operator used to compare
/// with the date chosen by the user. The chosen date is on the
/// right side of the equation.</param>
/// <param name="nullable">Whether the datetime picker allows null values</param>
/// <returns>Returns the new DateTimePicker added</returns>
public IDateTimePicker AddDateFilterDateTimePicker(string labelText, string propertyName, DateTime? defaultValue,
FilterClauseOperator filterClauseOperator, bool nullable)
{
//IDateTimePicker dtPicker =
// _filterControlManager.AddDateFilterDateTimePicker(labelText, propertyName, filterClauseOperator, nullable,
// defaultValue);
ICustomFilter customFilter =
_filterControlManager.AddDateFilterDateTimePicker(labelText, propertyName, filterClauseOperator, defaultValue);
return (IDateTimePicker) customFilter.Control;
}
#pragma warning disable 168
public SimpleFilterStub
(IControlFactory controlFactory, string propertyName, FilterClauseOperator filterClauseOperator)
#pragma warning restore 168
{
_textBox = controlFactory.CreateTextBox();
}
#pragma warning disable 168
public SimpleFilterStub
(IControlFactory controlFactory, string propertyName, FilterClauseOperator filterClauseOperator)
#pragma warning restore 168
{
_textBox = controlFactory.CreateTextBox();
}
private static FilterPropertyDef CreateFilterPropertyDef
(string propName, string filterType, string filterTypeAssembly, FilterClauseOperator filterClauseOperator)
{
return(new FilterPropertyDef
(propName, TestUtil.GetRandomString(), filterType, filterTypeAssembly, filterClauseOperator, new Dictionary <string, string>()));
}
///<summary>
/// An overridden constructor for controlFactory, propertyName and filterClauseOperator.
///</summary>
///<param name="controlFactory"></param>
///<param name="propertyName"></param>
///<param name="filterClauseOperator"></param>
public DateTimePickerFilter(IControlFactory controlFactory, string propertyName, FilterClauseOperator filterClauseOperator)
{
_controlFactory = controlFactory;
_propertyName = propertyName;
_filterClauseOperator = filterClauseOperator;
_dateTimePicker = _controlFactory.CreateDateTimePicker();
_dateTimePicker.ValueChanged += (sender, e) => FireValueChanged();
}
/// <summary>
/// Adds a TextBox filter in which users can specify text that
/// a string-value column will be filtered on.
/// </summary>
/// <param name="labelText">The label to appear before the control</param>
/// <param name="propertyName">The business object property on which to filter</param>
/// <param name="filterClauseOperator">The operator to use for the filter clause</param>
/// <returns>Returns the new TextBox added</returns>
public ITextBox AddStringFilterTextBox(string labelText, string propertyName,
FilterClauseOperator filterClauseOperator)
{
ICustomFilter filter = _filterControlManager.AddStringFilterTextBox(labelText, propertyName, filterClauseOperator);
return (ITextBox) filter.Control;
}
/// <summary>
/// Adds a TextBox filter in which users can specify text that
/// multiple string-value columns will be filtered on.
/// </summary>
/// <param name="labelText">The label to appear before the control</param>
/// <param name="propertyNames">The business object propertys on which to filter</param>
/// <param name="filterClauseOperator">The operator to use for the filter clause</param>
/// <returns>Returns the new TextBox added</returns>
public ITextBox AddMultiplePropStringTextBox(string labelText, List<string> propertyNames, FilterClauseOperator filterClauseOperator)
{
ICustomFilter filter = _filterControlManager.AddMultiplePropStringTextBox(labelText, propertyNames, filterClauseOperator);
return (ITextBox)filter.Control;
}
/// <summary>
/// Constructor to create a new filter clause
/// </summary>
/// <param name="filterColumn">The column of data on which to do the
/// filtering</param>
/// <param name="clauseOperator">The clause operator</param>
/// <param name="filterValue">The filter value to compare to</param>
protected DataViewFilterClause(string filterColumn, FilterClauseOperator clauseOperator, object filterValue)
{
_filterColumn = filterColumn;
_clauseOperator = clauseOperator;
_filterValue = filterValue;
}
///<summary>
/// Adds a static string filter <see cref="StringStaticFilter"/> to the Filter Control.
/// This allows the developer to set a filter that is always applied and is not modifiable by or visible to the end user.
///</summary>
///<param name="propertyName"></param>
///<param name="filterClauseOperator"></param>
///<param name="filterValue"></param>
public void AddStaticStringFilterClause(string propertyName, FilterClauseOperator filterClauseOperator, string filterValue)
{
_filterControlManager.AddStaticStringFilterClause(propertyName, filterClauseOperator, filterValue);
}
/// <summary>
/// See <see cref="IFilterControl.AddStringFilterTextBox(string,string,FilterClauseOperator)"/>
/// </summary>
public ICustomFilter AddMultiplePropStringTextBox(string labelText, List<string> propertyNames, FilterClauseOperator filterClauseOperator)
{
MultiplePropStringTextBoxFilter filter = new MultiplePropStringTextBoxFilter(_controlFactory, propertyNames, filterClauseOperator);
AddCustomFilter(labelText, filter);
return filter;
}
/// <summary>
/// Creates a new filter clause that filters string values
/// </summary>
/// <param name="filterColumn">The column of data on which to do the
/// filtering</param>
/// <param name="clauseOperator">The clause operator</param>
/// <param name="filterValue">The filter value to be compared to</param>
/// <returns>Returns the new filter clause object</returns>
public IFilterClause CreateStringFilterClause(string filterColumn, FilterClauseOperator clauseOperator,
string filterValue)
{
return new DataViewStringFilterClause(filterColumn, clauseOperator, filterValue);
}
///<summary>
/// Constructor for <see cref="StringStaticFilter"/>
///</summary>
///<param name="propertyName"></param>
///<param name="filterClauseOperator"></param>
///<param name="constantvalue">The Constant Value that is being used in this filter</param>
public StringStaticFilter(string propertyName, FilterClauseOperator filterClauseOperator, string constantvalue)
{
_propertyName = propertyName;
_filterClauseOperator = filterClauseOperator;
_constantvalue = constantvalue;
}
/// <summary>
/// Creates an Filter Clause for an enum data Type.
/// </summary>
/// <param name="columnName"/><param name="clauseOperator"/><param name="enumValue"/>
/// <returns/>
public IFilterClause CreateEnumFilterClause(string columnName, FilterClauseOperator clauseOperator, object enumValue)
{
return new DataViewEnumFilterClause(columnName, clauseOperator, enumValue);
}
private static FilterPropertyDef CreateFilterPropertyDef
(string propName, string filterType, string filterTypeAssembly, FilterClauseOperator filterClauseOperator)
{
return new FilterPropertyDef
(propName, TestUtil.GetRandomString(), filterType, filterTypeAssembly, filterClauseOperator, new Dictionary<string, string>());
}
/// <summary>
/// See <see cref="IFilterControl.AddStringFilterTextBox(string,string,FilterClauseOperator)"/>
/// </summary>
public ICustomFilter AddStringFilterTextBox(string labelText, string propertyName, FilterClauseOperator filterClauseOperator)
{
StringTextBoxFilter filter = new StringTextBoxFilter(_controlFactory, propertyName, filterClauseOperator);
AddCustomFilter(labelText, filter);
return filter;
}
///<summary>
/// Adds a static string filter <see cref="StringStaticFilter"/> to the Filter Control.
/// This allows the developer to set a filter that is always applied and is not editable by or visible to the End user.
///</summary>
///<param name="propertyName"></param>
///<param name="filterClauseOperator"></param>
///<param name="filterValue"></param>
public void AddStaticStringFilterClause(string propertyName, FilterClauseOperator filterClauseOperator, string filterValue)
{
StringStaticFilter filter = new StringStaticFilter(propertyName, filterClauseOperator, filterValue);
_filterControls.Add(filter);
}
/// <summary>
/// See <see cref="IFilterControl.AddDateFilterDateTimePicker"/>
/// </summary>
public ICustomFilter AddDateFilterDateTimePicker(string labelText, string propertyName, FilterClauseOperator filterClauseOperator, DateTime? defaultDate)
{
DateTimePickerFilter filter = new DateTimePickerFilter(_controlFactory, propertyName, filterClauseOperator);
AddCustomFilter(labelText, filter);
if (defaultDate != null)
{
filter.DefaultDate = defaultDate.Value;
}
return filter;
}
/// <summary>
/// Converts the <see cref="FilterClauseOperator"/> enum to
/// a string.
/// </summary>
/// <param name="clauseOperator"></param>
/// <returns></returns>
public string ConvertToString(FilterClauseOperator clauseOperator)
{
string opClause;
switch (clauseOperator)
{
case FilterClauseOperator.OpEquals:
opClause = " = ";
break;
case FilterClauseOperator.OpLike:
opClause = " like ";
break;
case FilterClauseOperator.OpGreaterThanOrEqualTo:
opClause = " >= ";
break;
case FilterClauseOperator.OpLessThanOrEqualTo:
opClause = " <= ";
break;
case FilterClauseOperator.OpGreaterThan:
opClause = " > ";
break;
case FilterClauseOperator.OpLessThan:
opClause = " < ";
break;
case FilterClauseOperator.OpNotEqual:
opClause = " <> ";
break;
default:
opClause = " " + clauseOperator + " ";
//opClause = " <unsupported operator> ";
break;
}
return opClause;
}
