/// <summary>
/// 注册全局过滤器
/// </summary>
/// <param name="filters"></param>
private void RegisterGlobalFilters(FilterCollection filters)
{
//filters.Add(new GmpHandleLogAttribute());
//filters.Add(new GmpRoleLimitAttribute());
filters.Add(typeof(ApiThrottleActionFilter));
filters.Add(new GmpValidateRequestAttribute());
filters.Add(new GmpUserBehaviorAttribute());
filters.Add(new GmpResponseCacheAttribute());
filters.Add(new GmpExceptionFilterAttribute());
}
public AccountingController()
{
filters.Add(authFilter);
filters.Add(logFilter);
antiDosFilter.AttributeEnable = true;
securityFilter.Filters.Add(antiDosFilter);
securityFilter.Filters.Add(ipFilter);
filters.Add(securityFilter);
}
public TreasuryController()
{
//filters.Add(authFilter);
filters.Add(logFilter);
antiDosFilter.AttributeEnable = true;
securityFilter.Filters.Add(authFilter);
securityFilter.Filters.Add(antiDosFilter);
securityFilter.Filters.Add(ipFilter);
filters.Add(securityFilter);
}
public void Add_FilterTwice_OnlyAddsOnce()
{
int filterAddedEventRaised = 0;
FilterCollection<int> filters = new FilterCollection<int>();
filters.FilterAdded += (sender, args) => filterAddedEventRaised++;
Filter<int> filter = new Mock<Filter<int>>().Object;
filters.Add(filter);
filters.Add(filter);
Assert.AreEqual(1, filters.Count);
Assert.IsTrue(filters.Contains(filter));
Assert.AreEqual(1, filterAddedEventRaised);
}
void forId(string id, Action what, Activities activity = Activities.Update, Action onEnd = null)
{
if (string.IsNullOrWhiteSpace(id))
{
throw new InvalidOperationException("id was not provided");
}
try
{
init();
if (_bp.From.PrimaryKeyColumns.Length == 1)
{
var x = new equalToFilter();
Caster.Cast(_idColumn, id, x);
_tempFilter.Add(x.result);
}
else
{
var sr = new SeperatedReader(id);
int i = 0;
foreach (var item in _bp.From.PrimaryKeyColumns)
{
var x = new equalToFilter();
Caster.Cast(item, sr[i++], x);
_tempFilter.Add(x.result);
}
}
if (onEnd != null)
{
_bp.End += onEnd;
}
_bp.Activity = activity;
what();
}
finally
{
if (_bp.Counter == 0)
{
throw new NotFoundException();
}
_bp.Activity = Activities.Update;
if (onEnd != null)
{
_bp.End -= onEnd;
}
_tempFilter.Clear();
}
}
public override Object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, Object value)
{
if (value == null)
{
return(null);
}
if (value is String)
{
var r = new FilterCollection();
var vals = value.ToString().Split(',');
foreach (var v in vals)
{
if (Enum.TryParse <Filter>(v.Trim(), out Filter filter))
{
r.Add(filter);
}
else
{
throw new XamlException($"Invalid filter value '{v}'");
}
}
return(r);
}
throw new XamlException($"Invalid FilterCollection value '{value}'");
}
void item_Click(object sender, EventArgs e)
{
Type filterType = (sender as ToolStripItem).Tag as Type;
IFilter filter = (IFilter)Activator.CreateInstance(filterType);
filters.Add(filter);
}
private void CleanAdditionalFilters(ReportSet reportSet)
{
FilterCollection filters = new FilterCollection();
foreach (Filter filter in reportSet.Filters)
{
if (!(filter is AdditionalFilter))
{
filters.Add(filter);
}
}
reportSet.Filters.Clear();
reportSet.Filters.AddRange(filters.ToArray());
// Make sure accessing reportSet.ReportName does not throw an exception.
string reportName = null;
try
{
reportName = Utility.GetWebReportName(reportSet);
}
catch (Exception)
{
// Do nothing.
}
if (reportName != null)
{
AdditionalFiltersStorage.CleanAdditionalFilterFromSession(reportName);
}
}
public static void AddFilterSafe(FilterCollection filters, Filter filterToAdd)
{
if (filters == null)
{
throw new ArgumentNullException("filters");
}
if (filterToAdd == null)
{
throw new ArgumentNullException("filterToAdd");
}
var found = false;
foreach (Filter filter in filters)
{
if (filter.dbColumn == filterToAdd.dbColumn)
{
found = true;
filter.Operator = filterToAdd.Operator;
filter.Value = filterToAdd.Value;
filter.Values = filterToAdd.Values;
break;
}
}
if (!found)
{
filters.Add(filterToAdd);
}
}
internal void SaveTo(FiltersSection section)
{
FilterCollection filterCollection = section.Filters;
filterCollection.Clear();
foreach (IFilter filter in list)
{
Type filterType = filter.GetType();
FilterElement filterElement = new FilterElement();
filterElement.Name = filterType.Name;
filterElement.Type = filterType;
filterCollection.Add(filterElement);
foreach (PropertyInfo propertyInfo in filterType.GetProperties())
{
if (propertyInfo.Name != "LastResult")
{
FilterParameterElement parameter = new FilterParameterElement();
parameter.Name = propertyInfo.Name;
object propertyValue = propertyInfo.GetValue(filter, null);
parameter.Type = propertyValue.GetType();
TypeConverter converter = TypeDescriptor.GetConverter(propertyValue);
parameter.Value = converter.ConvertToString(propertyValue);
filterElement.Parameters.Add(parameter);
}
}
}
}
public Task <List <M> > FindAllByEntity(Dictionary <string, string> request, ServerCallContext context)
{
return(Task.Run(() =>
{
FilterCollection _filterCollection = new FilterCollection();
Type tType = typeof(M);
PropertyInfo propertyInfo;
foreach (var key in request.Keys)
{
propertyInfo = tType.GetProperty(key);
List <Filter> filter = new List <Filter>
{
new Filter
{
PropertyName = key,
Value = request[key].ChangeTypeExtend(propertyInfo),
Operation = AttributeModel.ExpressionOptions.Equals
}
};
_filterCollection.Add(filter);
}
List <M> mList = baseService().FindAll(LambdaExpressionBuilder.GetExpression <M>(_filterCollection)).Result;
return mList;
}));
}
public WhereClass Where(ICustomFilterMember filter)
{
var fc = new FilterCollection();
fc.Add("{0}", filter);
return(new WhereClass(this, new WhereItem[] { fc }));
}
void CreateTypesView()
{
foreach (var type in typesToObjectsListMap)
{
typesCollection.Add(Tuple.Create(type.Key, session.GetTypeName(type.Key), type.Value.Count));
}
typesGrid = new GridView {
DataStore = typesCollection
};
typesGrid.AllowMultipleSelection = false;
typesGrid.Columns.Add(new GridColumn {
DataCell = new TextBoxCell {
Binding = Binding.Delegate <Tuple <long, string, int>, string>(r => r.Item3.ToString())
},
HeaderText = "Objects #"
});
typesGrid.Columns.Add(new GridColumn {
DataCell = new TextBoxCell {
Binding = Binding.Delegate <Tuple <long, string, int>, string>(r => r.Item2)
},
HeaderText = "Type Name"
});
typesGrid.SelectedRowsChanged += Grid_SelectedRowsChanged;
}
private void LoadFilterHelper(Filter filter)
{
filter.UpdateMethod = APMCore.UpdateMethod.Update;
filter.StatusChanged += Filter_StatusChangedAsync;
filter.Updated += Filter_Updated;
_filters.Add(filter);
}
private void OnButtonNewClick()
{
using (var dialog = new AddressBookEditDialog(DataSourceAddressBook)
{
Owner = ParentWindow
}) {
if (dialog.ShowModal())
{
var overwriteIndex = dialog.OverwriteIndex;
if (overwriteIndex < 0)
{
// Add new item
DataSourceAddressBook.Add(new SettingsManager.ConfigElementContact(dialog.Label, dialog.Address));
overwriteIndex = DataSourceAddressBook.Count - 1;
}
else
{
// Overwrite existing item
DataSourceAddressBook.RemoveAt(overwriteIndex);
DataSourceAddressBook.Insert(overwriteIndex, new SettingsManager.ConfigElementContact(dialog.Label, dialog.Address));
}
GridViewAddressBook.SelectRow(overwriteIndex);
}
}
GridViewAddressBook.Focus();
}
public SearchViewModel()
{
LogOffCommand = new DelegateCommand(OnLogOffCommand);
Patients = new ObservableCollection <PatientEntity>();
ViewProfileCommand = new DelegateCommand(OnViewProfileCommand);
ViewReportCommand = new DelegateCommand(OnViewReportCommand);
SearchCommand = new DelegateCommand(OnSearchCommand);
Patients = new Patient().GetAll();
FtpTransferCommand = new DelegateCommand(OnFtpTransferCommand);
FilterCollection.Add(new IdName()
{
Id = "p_id", Name = "Patient ID"
});
FilterCollection.Add(new IdName()
{
Id = "name", Name = "Patient Name"
});
FilterCollection.Add(new IdName()
{
Id = "p_email", Name = "Email"
});
FilterCollection.Add(new IdName()
{
Id = "mobile", Name = "Mobile"
});
}
// This method gets called by the runtime. Use this method to add services to the container.
// For more information on how to configure your application, visit https://go.microsoft.com/fwlink/?LinkID=398940
public void ConfigureServices(IServiceCollection services)
{
// register Azure AD Settings to be able to use the IOptions pattern via DI
services.Configure <AzureAdOptions>(_configuration.GetSection("Authentication:AzureAd"));
var azureAdSettings = _configuration.Get <AzureAdOptions>();
// register Azure B2C Settings to be able to use the IOptions pattern via DI
services.Configure <AzureAdB2COptions>(_configuration.GetSection("Authentication:AzureAdB2C"));
var azureAdB2CSettings = _configuration.Get <AzureAdB2COptions>();
// Add JwtBearerAuthentication for Azure AD and B2C
services.AddAzureAdAndB2CJwtBearerAuthentication(azureAdSettings, azureAdB2CSettings, typeof(Startup).Assembly);
// You can also only register for Azure AD
//services.AddAzureAdJwtBearerAuthentication(azureAdSettings, typeof(Startup).Assembly);
// You can also only register for Azure B2C
//services.AddAzureB2CJwtBearerAuthentication(azureAdB2CSettings, typeof(Startup).Assembly);
var filterCollection = new FilterCollection();
if (!azureAdSettings.Enabled)
{
// No authentication
filterCollection.Add(new AllowAnonymousFilter());
}
// Register MVC
services.AddMvc(options =>
{
filterCollection.ToList().ForEach(filter => options.Filters.Add(filter));
});
}
public static void TargetPackage(ITaskContext context)
{
FilterCollection installBinFilters = new FilterCollection();
installBinFilters.Add(new RegexFileFilter(@".*\.xml$"));
installBinFilters.Add(new RegexFileFilter(@".svn"));
context.Tasks().PackageTask("builds")
.AddDirectoryToPackage("FlubuExample", "FlubuExample", false, new RegexFileFilter(@"^.*\.(svc|asax|aspx|config|js|html|ico|bat|cgn)$").NegateFilter())
.AddDirectoryToPackage("FlubuExample\\Bin", "FlubuExample\\Bin", false, installBinFilters)
.AddDirectoryToPackage("FlubuExample\\Content", "FlubuExample\\Content", true)
.AddDirectoryToPackage("FlubuExample\\Images", "FlubuExample\\Images", true)
.AddDirectoryToPackage("FlubuExample\\Scripts", "FlubuExample\\Scripts", true)
.AddDirectoryToPackage("FlubuExample\\Views", "FlubuExample\\Views", true)
.ZipPackage("FlubuExample.zip")
.Execute(context);
}
public DataColumn AddColumn(string caption, Func <EntityType, decimal> value)
{
return(AddColumn <decimal>(caption, value, y => value(y), (y, v) => {
var fc = new FilterCollection();
fc.Add(() => value(y) == (decimal)v);
return fc;
}, y => false));
}
/// <summary>
/// Adds an MVC filter that will only activate during a request if the specified feature is enabled.
/// </summary>
/// <typeparam name="TFilterType">The MVC filter to add and use if the feature is enabled.</typeparam>
/// <param name="filters">The filter collection to add to.</param>
/// <param name="feature">The feature that will need to enabled to trigger the execution of the MVC filter.</param>
/// <returns></returns>
public static IFilterMetadata AddForFeature <TFilterType>(this FilterCollection filters, string feature) where TFilterType : IFilterMetadata
{
IFilterMetadata filterMetadata = null;
filters.Add(new FeatureGatedFilter <TFilterType>(feature));
return(filterMetadata);
}
/// <summary>
/// Adds an filter item to the collection if it doesn't already exist.
/// </summary>
/// <param name="col">The col.</param>
/// <param name="value">The value.</param>
/// ///
/// <param name="order">Filter order</param>
/// <returns>TCollection.</returns>
public static FilterCollection TryAdd(this FilterCollection col, Type value, int?order = null)
{
if (col.Any(t => t.GetType() == value))
{
return(col);
}
if (order.HasValue)
{
col.Add(value, order.Value);
}
else
{
col.Add(value);
}
return(col);
}
/// <summary>
/// Add <see cref="EnableActionResultExceptionAttribute" /> as a exception filter in the
/// <paramref name="filterCollection" />.
/// </summary>
/// <param name="filterCollection">The <see cref="FilterCollection" /> object.</param>
/// <exception cref="ArgumentNullException">The <paramref name="filterCollection" /> is <c>null</c>.</exception>
public static void EnableActionResultExceptionFilter(this FilterCollection filterCollection)
{
if (filterCollection == null)
{
throw new ArgumentNullException(nameof(filterCollection));
}
filterCollection.Add(typeof(EnableActionResultExceptionAttribute));
}
public static void Add(this FilterCollection collection, IFilterMetadata filter, Action <IFilterCriteriaBuilder> criteria)
{
collection.Add(filter);
var builder = new FilterCriteriaBuilder();
criteria(builder);
Records.Add(filter, new FilterRecord(builder.GetResults()));
}
DataColumn AddDateColumnPart(string name, Func <EntityType, DateColumn> column, Func <EntityType, int> getValue)
{
return(AddColumn <int>(column(_instance).Caption + " " + name,
getValue,
y => getValue(y),
(y, v) =>
{
var fc = new FilterCollection();
if (v == null)
{
fc.Add(column(y).IsEqualTo(Date.Empty));
}
else
{
fc.Add(() => getValue(y) == (int)v);
}
return fc;
}, y => Date.IsNullOrEmpty(column(y))));
}
protected async Task ApplyButtonClicked()
{
FilterCollection filters = new FilterCollection(_filters);
if (filters.Count() > 1)
{
filters.Add(GridFilterType.Condition.ToString("d"), "2");
}
await GridHeaderComponent.AddFilter(filters);
}
public void Add_Filter_RaisesFilterAddedEvent()
{
int filterAddedEventRaised = 0;
FilterCollection<int> filters = new FilterCollection<int>();
filters.FilterAdded += (sender, args) => filterAddedEventRaised++;
filters.Add(new Mock<Filter<int>>().Object);
Assert.AreEqual(1, filterAddedEventRaised);
}
public override void What <T>(TypedColumnBase <T> col, T val)
{
var tcol = col as TextColumn;
if (tcol != null)
{
var fc = new FilterCollection();
var e = col.Entity as ENV.Data.Entity;
if (e != null && e.DataProvider is ENV.Data.DataProvider.DynamicSQLSupportingDataProvider)
{
fc.Add("{0} like {1}", col, "%" + val + "%");
}
else
{
fc.Add(() => tcol.Value.Contains(val.ToString()));
}
result = fc;
}
}
/// <summary>
/// Adds a filter that will only execute during a request if the specified feature is enabled.
/// </summary>
/// <typeparam name="TFilter">Type representing a <see cref="IAsyncActionFilter" />.</typeparam>
/// <param name="filters">The filter collection to add to.</param>
/// <param name="feature">
/// The feature that is required to be enabled to trigger the execution of the filter.
/// </param>
/// <returns>A <see cref="IFilterMetadata" /> representing the added type.</returns>
public static IFilterMetadata AddForFeature <TFilter, TFeature>(this FilterCollection filters, TFeature feature)
where TFilter : IAsyncActionFilter
where TFeature : struct, Enum
{
var filter = new FeatureGatedAsyncActionFilter <TFilter, TFeature>(feature);
filters.Add(filter);
return(filter);
}
public void Constructor_Collection_AddsFilters()
{
FilterCollection<int> filters = new FilterCollection<int>();
Filter<int> filter = new Mock<Filter<int>>().Object;
filters.Add(filter);
FilterCollection<int> filtersCopy = new FilterCollection<int>(filters);
Assert.AreEqual(1, filtersCopy.Count);
Assert.IsTrue(filtersCopy.Contains(filter));
}
public static FilterCollection RequireAuthenticatedUser(this FilterCollection filters)
{
var policy = new AuthorizationPolicyBuilder()
.RequireAuthenticatedUser()
.Build();
filters.Add(new AuthorizeFilter(policy));
return(filters);
}
public void Add_WithOrder_SetsOrder()
{
// Arrange
var collection = new FilterCollection();
// Act
var added = collection.Add(typeof(MyFilter), 17);
// Assert
Assert.Equal(17, Assert.IsAssignableFrom<IOrderedFilter>(added).Order);
}
public void GenericAdd_WithOrder_SetsOrder()
{
// Arrange
var collection = new FilterCollection();
// Act
var added = collection.Add <MyFilter>(17);
// Assert
Assert.Equal(17, Assert.IsAssignableFrom <IOrderedFilter>(added).Order);
}
public static IFilterMetadata Add(this FilterCollection collection, Type filterType, int order, Action <IFilterCriteriaBuilder> criteria)
{
IFilterMetadata filter = collection.Add(filterType, order);
var builder = new FilterCriteriaBuilder();
criteria(builder);
Records.Add(filter, new FilterRecord(builder.GetResults()));
return(filter);
}
//Document Properties Panel Buttons
#region Document Properties Panel Buttons
private void Btn_doc_add_Click(object sender, EventArgs e)
{
ResetFilter();
m_grid.DataStore = m_filter_collection;
//Add a new Document String
m_filter_collection.Add(new UserStringItem {
Key = string.Empty, Value = string.Empty
});
m_grid.BeginEdit(m_filter_collection.Count - 1, 0);
}
public void Add_UsesTypeFilterAttribute()
{
// Arrange
var collection = new FilterCollection();
// Act
var added = collection.Add(typeof(MyFilter));
// Assert
var typeFilter = Assert.IsType<TypeFilterAttribute>(added);
Assert.Equal(typeof(MyFilter), typeFilter.ImplementationType);
Assert.Same(typeFilter, Assert.Single(collection));
}
public void FilterCollectionTest()
{
byte[] source = new byte[]
{ 0X21, 0X58, 0X44, 0XAA, 0XDD, 0XDD, 0XDD, 0X0B, 0XAA, 0XAA, 0X22, 0X23, 0X24 };
string pattern = "21 58 44";
Filter f = new Filter(pattern);
string pattern2 = "22 23 24";
Filter f2 = new Filter(pattern2);
string pattern3 = "dd dd dd";
Filter f3 = new Filter(pattern3);
FilterCollection fs = new FilterCollection();
fs.Add(f);
fs.Add(f2);
fs.Add(f3);
source = fs.Filt(source);
string str = HexStringConverter.Default.ConvertToObject(source).ToString();
Console.WriteLine(str);
Assert.AreEqual(3, source.Length);
}
public void Add_ThrowsOnNonIFilter()
{
// Arrange
var collection = new FilterCollection();
var expectedMessage =
$"The type '{typeof(NonFilter).FullName}' must derive from " +
$"'{typeof(IFilterMetadata).FullName}'." + Environment.NewLine +
"Parameter name: filterType";
// Act & Assert
var ex = Assert.Throws<ArgumentException>(() => { collection.Add(typeof(NonFilter)); });
// Assert
Assert.Equal(expectedMessage, ex.Message);
}
public void Remove_Filter_RaisesFilterRemovedEvent()
{
int filtersRemovedRaised = 0;
FilterCollection<int> filters = new FilterCollection<int>();
filters.FilterRemoved += (sender, args) => filtersRemovedRaised++;
Filter<int> filter = new Mock<Filter<int>>().Object;
filters.Add(filter);
filters.Remove(filter);
Assert.AreEqual(1, filtersRemovedRaised);
}
public void Add_Null_ThrowsException()
{
FilterCollection<int> filters = new FilterCollection<int>();
filters.Add(null);
}
public void IndexOperator_Set_RaisesFilterRemovedAndFilterAddedEvent()
{
int filterRemovedRaised = 0;
int filterAddedRaised = 0;
FilterCollection<int> filters = new FilterCollection<int>();
Filter<int> filterA = new Mock<Filter<int>>().Object;
Filter<int> filterB = new Mock<Filter<int>>().Object;
filters.Add(filterA);
filters.FilterRemoved += (sender, args) => filterRemovedRaised++;
filters.FilterAdded += (sender, args) => filterAddedRaised++;
filters[0] = filterB;
Assert.AreEqual(1, filterRemovedRaised);
Assert.AreEqual(1, filterAddedRaised);
}
public void IndexOperator_Set_ReplacesFilter()
{
FilterCollection<int> filters = new FilterCollection<int>();
Filter<int> filterA = new Mock<Filter<int>>().Object;
Filter<int> filterB = new Mock<Filter<int>>().Object;
filters.Add(filterA);
filters[0] = filterB;
Assert.IsFalse(filters.Contains(filterA));
Assert.IsTrue(filters.Contains(filterB));
Assert.AreEqual(filterB, filters[0]);
}
public void AddItemShouldTriggerCorrectChange()
{
var model = GridViewUtils.CreateModel();
var filtered = new FilterCollection<DataItem>(model);
filtered.Sort = GridViewUtils.SortEvenItemsBeforeOdd;
int newIndex = -1;
filtered.CollectionChanged += (sender, e) =>
{
Assert.AreEqual(NotifyCollectionChangedAction.Add, e.Action, "Action should be add");
newIndex = e.NewStartingIndex;
};
var item = new DataItem(1000);
filtered.Add(item);
var index = filtered.IndexOf(item);
Assert.AreEqual(filtered[index].Id, item.Id, "Index reported does not have correct item");
Assert.AreEqual(index, newIndex, "Triggered event should have correct index");
Assert.AreEqual(model.Count - 1, model.IndexOf(item), "Item should be added to the end of the model");
}
public void Contains_Type_ReturnsFiltersOfType()
{
FilterCollection<int> filters = new FilterCollection<int>();
Filter<int> filterInt = new Mock<Filter<int>>().Object;
Filter<double> filterDouble = new Mock<Filter<double>>().Object;
filters.Add(filterInt);
Assert.IsTrue(filters.Contains(filterInt.GetType()));
Assert.IsFalse(filters.Contains(filterDouble.GetType()));
}
public void Remove_ByType()
{
FilterCollection<int> filters = new FilterCollection<int>();
Filter<int> filter = new Mock<Filter<int>>().Object;
filters.Add(filter);
filters.Remove(filter.GetType());
Assert.IsFalse(filters.Contains(filter));
}
private void _initFilters()
{
_filterCollection = new FilterCollection<KeyValuePair<ILinie, List<IHaltestelle>>>();
_filterCollection.Add("Metro", new MapFilter(EVerkehrsmittel.Metro));
_filterCollection.Add("SBahn", new MapFilter(EVerkehrsmittel.SBahn));
_filterCollection.Add("Tram", new MapFilter(EVerkehrsmittel.Tram));
_filterCollection.Add("TramVrt", new MapFilter(EVerkehrsmittel.TramVrt));
_filterCollection.Add("CityBus", new MapFilter(EVerkehrsmittel.CityBus));
_filterCollection.Add("NachtBus", new MapFilter(EVerkehrsmittel.NachtBus));
}
public void Get_ByType()
{
FilterCollection<int> filters = new FilterCollection<int>();
Filter<int> filter = new Mock<Filter<int>>().Object;
filters.Add(filter);
Assert.AreEqual(filter, filters.Get(filter.GetType()));
}
public void IndexOperator_Get_ReturnsFilterAtIndex()
{
FilterCollection<int> filters = new FilterCollection<int>();
Filter<int> filterA = new Mock<Filter<int>>().Object;
Filter<int> filterB = new Mock<Filter<int>>().Object;
filters.Add(filterA);
filters.Add(filterB);
Assert.AreEqual(filterA, filters[0]);
Assert.AreEqual(filterB, filters[1]);
}
// Apply filters to selected file
private void filter_apply_Click(object sender, EventArgs e)
{
// get model to filter
int rowIndex = this.parsedFilesGridView.SelectedRows[0].Index;
DatabaseDataSet data = (DatabaseDataSet)this.parsedFilesGridView.Rows[rowIndex].DataBoundItem;
FilterCollection filterCollection = new FilterCollection();
// get filter method
FilterMethod filterMethod = FilterMethod.ALL ;
if (this.filter_method_all.Checked)
{
filterMethod = FilterMethod.ALL;
}
else if (this.filter_method_either.Checked)
{
filterMethod = FilterMethod.EITHER;
}
else if (this.filter_method_none.Checked)
{
filterMethod = FilterMethod.NONE;
}
// setup time based filter
if (this.filter_time_enabled.Checked)
{
TimeSpan startTime = TimeSpan.Parse(this.filter_time_start.Text);
TimeSpan endTime = TimeSpan.Parse(this.filter_time_end.Text);
Filter.Filters.Time timeFilter = new Filter.Filters.Time(
startTime, endTime
);
filterCollection.Add(timeFilter);
}
// setup day based filter
if (this.filter_days_enabled.Checked)
{
List<DateTime> dates = new List<DateTime>();
foreach (Object day in this.filter_days_list.CheckedItems)
{
dates.Add((DateTime)day);
}
Filter.Filters.Day dayFilter = new Filter.Filters.Day(
dates
);
filterCollection.Add(dayFilter);
}
// do filtering
this.commandManager.addCommand(new FilterCommand(data, filterCollection, filterMethod, this.filter_command_callback));
}
