private static QueryFilter ReduceSecurityPrincipalFilter(QueryFilter filter) { if (filter.ToString() == FfoRecipientSession.userOrRoleGroupForExtendedSecurityPrincipal) { return(null); } CompositeFilter compositeFilter = filter as CompositeFilter; if (compositeFilter == null) { return(filter); } QueryFilter[] array = (from childFilter in compositeFilter.Filters.Select(new Func <QueryFilter, QueryFilter>(FfoRecipientSession.ReduceSecurityPrincipalFilter)) where childFilter != null select childFilter).ToArray <QueryFilter>(); if (array.Length == 0) { return(null); } if (array.Length == 1) { return(array[0]); } if (compositeFilter is AndFilter) { return(QueryFilter.AndTogether(array)); } if (compositeFilter is OrFilter) { return(QueryFilter.OrTogether(array)); } throw new NotSupportedException(HygieneDataStrings.ErrorQueryFilterType(filter.ToString())); }
internal IFilter ToFilter() { if (Type == FilterType.Composite) { var ret = new CompositeFilter { And = And, Type = FilterType.Composite }; if (Filters == null) { ret.Filters = new List <IFilter>(); } else { ret.Filters = Filters.Select(t => t.ToFilter()).ToList(); } return(ret); } else { return(new SimpleFilter { And = And, CaseInsensitive = CaseInsensitive, Type = Type, Not = Not, Path = Path, Value = Value.GetRawObjectValue() }); } }
protected override void RenderContents(HtmlTextWriter output) { var extensionPointManager = new ExtensionPointManager(); var str = new StringBuilder(); var filter = new CompositeFilter() .And(new FilterByHostMenu(this.IsHost)) .And(new FilterByUnauthenticated(HttpContext.Current.Request.IsAuthenticated)); foreach (var extension in extensionPointManager.GetToolBarButtonExtensionPoints(Module, Group, filter)) { if (extension is IToolBarMenuButtonExtensionPoint) { btnRenderer = new ToolBarMenuButtonRenderer(); str.AppendFormat(btnRenderer.GetOutput(extension)); } else { btnRenderer = new ToolBarButtonRenderer(); str.AppendFormat(btnRenderer.GetOutput(extension)); } } output.Write(str.ToString()); }
/// <summary> /// Initializes a new instance of the <see cref="RegistrationConventionHandler" /> class. /// </summary> /// <param name="serviceLocator">The service locator.</param> /// <param name="typeFactory">The type factory.</param> public RegistrationConventionHandler(IServiceLocator serviceLocator = null, ITypeFactory typeFactory = null) { _serviceLocator = serviceLocator ?? this.GetServiceLocator(); _typeFactory = typeFactory ?? this.GetTypeFactory(); TypeFilter = new CompositeFilter <Type>(); AssemblyFilter = new CompositeFilter <Assembly>(); _assemblies = new HashSet <Assembly>(AssemblyHelper.GetLoadedAssemblies()); AssemblyFilter.Excludes += assembly => { var assemblyName = assembly.FullName; return(!string.IsNullOrWhiteSpace(assemblyName) && ( assemblyName.StartsWith("System") || assemblyName.StartsWith("WindowsBase") || assemblyName.StartsWith("Microsoft") || assemblyName.StartsWith("Presentation") || assemblyName.StartsWith("NuGet") || assemblyName.StartsWith("EntityFramework") || assemblyName.StartsWith("FluentValidation") || assemblyName.StartsWith("mscorlib") || assemblyName.StartsWith("UIAutomationProvider") || assemblyName.StartsWith("Anonymously") || assemblyName.StartsWith("SMDiagnostics") )); }; TypeFilter.Excludes += type => !type.IsInterfaceEx() && !type.GetParentTypes().Any(parentType => parentType.IsInterfaceEx()); }
public Option <PropertyTree> SelectFilter(CompositeFilter <PropertyTree> filter, Func <IFilter <PropertyTree>, PropertyTree> getModelHierarchy) { GetModelHierarchy = getModelHierarchy; OriginalFilter = filter; filterTreeView.Nodes.Clear(); var filterNodes = ToTreeNodes(filter.Filters); filterTreeView.Nodes.AddRange(filterNodes.ToArray()); UpdateHierarchyTreeView(); var result = ShowDialog(); if (result == System.Windows.Forms.DialogResult.OK) { var hierarchyRoot = hierarchyTreeView.Nodes[0]; return(Options.Some(ToHierarchy(ModelHierarchy, hierarchyRoot.Nodes.Cast <TreeNode>()))); } else { return(Options.None <PropertyTree>()); } }
private static Expression BuildComposite <T>(CompositeFilter filter, Expression parameter) { var first = filter.Children.FirstOrDefault(); if (first != null) { Expression rootEx = BuildExpression <T>(first, parameter); for (int i = 1; i < filter.Children.Length; i++) { var tp = BuildExpression <T>(filter.Children[i], parameter); if (filter.Operator == BoolOperator.And) { rootEx = Expression.AndAlso(rootEx, tp); } else { rootEx = Expression.OrElse(rootEx, tp); } } return(rootEx); } return(Expression.Constant(true)); }
public void SetUp() { action1 = ActionCall.For<ControllerTarget>(x => x.OneInZeroOut(null)); action2 = ActionCall.For<ActionCallFilterController>(x => x.DifferentMethod()); filter = new CompositeFilter<ActionCall>(); expression = new ActionCallFilterExpression(filter); }
public AssemblyScanner() { _types = new TypePool(GetType().Assembly); _typeFilters = new CompositeFilter <Type>(); IncludeTypes(t => true); }
public void Wrap_Creates_CompositeFilter_ForTwoParameters() { var filter = CompositeFilter.Wrap(new CountFilter(0, 1), new TypeFilter(typeof(INode))); Assert.That(filter, Is.InstanceOf <CompositeFilter>()); Assert.That((filter as CompositeFilter).Filters.Length, Is.EqualTo(2)); }
public void CompositeFilter_ItemsMustMatchByAll() { var filter = CompositeFilter.Wrap(new DelegateFilter(i => false), new CountFilter(1, 1)); var items = filter.Pipe(CreateItems(3)).ToList(); Assert.That(items.Count(), Is.EqualTo(0)); }
public OperationsManagerViewModel( BusyIndicatorViewModel busyIndicator, IOperationsManager operationsManager, IImportManager importManager) { _busyIndicator = busyIndicator; _operationsManager = operationsManager; _importManager = importManager; BeginExportCommand = new RelayCommand(BeginExport); BeginDataQualityAnalysisCommand = new AsyncCommand(BeginDataQualityAnalysis); CommitExportCommand = new AsyncCommand(CommitExport); CommitPendingChangesCommand = new AsyncCommand(SaveChanges); _sfd = new SaveFileDialog { OverwritePrompt = true, Filter = "csv files (*.csv)|*.csv|All Files (*.*)|*.*" }; SelectTargetFileToExportCommand = new RelayCommand(SelectTargetFileToExport); MessengerInstance.Register <AccountViewModel>(this, OnAccountViewModelReceived); _asyncMessageReceiver = new AsyncMessageReceiver(MessengerInstance); _asyncMessageReceiver.RegisterAsync <AccountImportDataChanged>(this, data => ReplayImports(data.AccountId)); DateFilter = new DateRangeFilter(); NoteFilter = new TextFilter(); _anyFilter = new CompositeFilter(DateFilter, NoteFilter); _anyFilter.FilterInvalidated += OnAnyFilterInvalidated; ResetFilterCommad = new RelayCommand(() => _anyFilter.Reset(), () => IsFiltering); }
public void match_with_no_includes_an_no_excludes() { var filter = new CompositeFilter <string>(); filter.Excludes.DoesNotMatchAny("a").ShouldBeTrue(); filter.Matches("a").ShouldBeTrue(); }
public virtual IList <T> Select <T>() where T : ContentItem { var retrievedItems = CreateQuery().List <T>(); ItemList <T> items; if (retrievedItems.Count == 0) { items = new ItemList <T>(); } else if (Filters != null) { var filter = CompositeFilter.Wrap(Filters); items = ToListWithFillup <T>(retrievedItems, filter, /*maxRequeries*/ 10); } else { items = new ItemList <T>(retrievedItems); } if (SortExpression != null) { items.Sort(SortExpression); } return(items); }
private static Query BuildQueryInternal(QueryFilter filter, Dictionary <PropertyDefinition, int> propertyDefinitionToColumnMap, int depth) { if (depth == 0) { throw new ArgumentException("Depth greater then max depth specified"); } SinglePropertyFilter singlePropertyFilter = filter as SinglePropertyFilter; if (singlePropertyFilter != null) { return(Query.BuildSinglePropertyQuery(singlePropertyFilter, propertyDefinitionToColumnMap)); } CompositeFilter compositeFilter = filter as CompositeFilter; if (compositeFilter != null) { return(Query.BuildCompositeFilter(compositeFilter, propertyDefinitionToColumnMap, depth - 1)); } NotFilter notFilter = filter as NotFilter; if (notFilter != null) { return(new NotQuery(Query.BuildQueryInternal(notFilter.Filter, propertyDefinitionToColumnMap, depth - 1))); } return(null); }
public static ICompositeFilter ReplaceByCompositeOn(this IFilter filter, params string[] paths) { var simpleFilter = filter as ISimpleFilter; if (simpleFilter == null) { throw new Exception("Must be a simple filter"); } var compositeFilter = new CompositeFilter(); compositeFilter.And = filter.And; compositeFilter.Type = FilterType.Composite; compositeFilter.Filters = paths .Select(t => new SimpleFilter { Type = filter.Type, Path = t, And = false, Value = simpleFilter.Value }) .AsEnumerable <IFilter>() .ToList(); return(compositeFilter); }
/// <summary> /// Converts a <see cref="TcmCDService.Contracts.TaxonomyFilter" /> to <see cref="T:Tridion.ContentDelivery.Taxonomies.TaxonomyFilter" /> /// </summary> /// <param name="taxonomyFilter"><see cref="TcmCDService.Contracts.TaxonomyFilter" /></param> /// <returns><see cref="T:Tridion.ContentDelivery.Taxonomies.TaxonomyFilter" /> or null</returns> internal static TaxonomyFilter ToTaxonomyFilter(this Contracts.TaxonomyFilter taxonomyFilter) { if (taxonomyFilter != null) { CompositeFilter filter = new CompositeFilter(); if (taxonomyFilter.FilterConcrete.HasValue || taxonomyFilter.FilterAbstract.HasValue) { filter.AbstractKeywordFiltering(taxonomyFilter.FilterConcrete.GetValueOrDefault(false), taxonomyFilter.FilterAbstract.GetValueOrDefault(false)); } if (taxonomyFilter.DepthFilteringLevel.HasValue) { filter.DepthFiltering(taxonomyFilter.DepthFilteringLevel.GetValueOrDefault(-1), (int)taxonomyFilter.DepthFilteringDirection); } if (taxonomyFilter.FilterHasChildren.HasValue || taxonomyFilter.FilterNavigable.HasValue) { filter.PropertyKeywordFiltering(taxonomyFilter.FilterHasChildren.GetValueOrDefault(false), taxonomyFilter.FilterNavigable.GetValueOrDefault(false)); } return(filter); } return(null); }
public void SetUp() { action1 = ActionCall.For <ControllerTarget>(x => x.OneInZeroOut(null)); action2 = ActionCall.For <ActionCallFilterController>(x => x.DifferentMethod()); filter = new CompositeFilter <ActionCall>(); expression = new ActionCallFilterExpression(filter); }
public void apply_a_filter_on_fixture_graph_at_the_namespace_level() { var filter = new FixtureFilter() { Name = "ST.Grammars", Type = FilterType.Namespace }; var composite = new CompositeFilter <FixtureGraph>(); filter.Apply(composite); composite.Matches(new FixtureGraph() { FixtureNamespace = "ST.Grammars" }).ShouldBeTrue(); composite.Matches(new FixtureGraph() { FixtureNamespace = "ST.Grammars.More" }).ShouldBeTrue(); composite.Matches(new FixtureGraph() { FixtureNamespace = "More.ST.Grammars.More" }).ShouldBeFalse(); composite.Matches(new FixtureGraph() { FixtureNamespace = "SomethingDifferent" }).ShouldBeFalse(); }
public static QueryFilter ConvertQueryFilter(QueryFilter filter) { if (filter == null) { return(null); } if (filter is CompositeFilter) { CompositeFilter compositeFilter = (CompositeFilter)filter; QueryFilter[] array = new QueryFilter[compositeFilter.FilterCount]; bool flag = false; int num = 0; foreach (QueryFilter queryFilter in compositeFilter.Filters) { array[num] = DateTimeConverter.ConvertQueryFilter(queryFilter); if (array[num] != queryFilter) { flag = true; } num++; } if (!flag) { return(filter); } if (filter is AndFilter) { return(new AndFilter(array)); } if (filter is OrFilter) { return(new OrFilter(array)); } throw new Exception("Invalid filter type"); } else if (filter is NotFilter) { NotFilter notFilter = filter as NotFilter; QueryFilter queryFilter2 = DateTimeConverter.ConvertQueryFilter(notFilter.Filter); if (queryFilter2 != notFilter) { return(new NotFilter(queryFilter2)); } return(filter); } else { if (!(filter is ComparisonFilter)) { return(filter); } ComparisonFilter comparisonFilter = filter as ComparisonFilter; if (comparisonFilter.PropertyValue is DateTime) { return(new ComparisonFilter(comparisonFilter.ComparisonOperator, comparisonFilter.Property, ((DateTime)comparisonFilter.PropertyValue).ToUniversalTime())); } return(filter); } }
public void CompositeFilter_PipesItem_MatchedByAllFilters() { var filter = CompositeFilter.Wrap(new DelegateFilter(i => true), new CountFilter(1, 1)); var items = filter.Pipe(CreateItems(3)).ToList(); Assert.That(items.Count(), Is.EqualTo(1)); Assert.That(items.First().Name, Is.EqualTo("1")); }
public void Wrap_Creates_SameFilter_ForOneCountList() { var filter = CompositeFilter.Wrap(new List <ItemFilter> { new CountFilter(0, 1) }); Assert.That(filter, Is.InstanceOf <CountFilter>()); }
private QueryFilter BuildQueryFilter(IEnumerable <ComparisonFilter> optionalFilters) { CompositeFilter compositeFilter = (CompositeFilter)base.BuildQueryFilter(); List <ComparisonFilter> list = new List <ComparisonFilter>(compositeFilter.Filters.Cast <ComparisonFilter>()); list.AddRange(optionalFilters); return(new AndFilter(list.ToArray <QueryFilter>())); }
private TreeNode ToTreeNode(CompositeFilter <PropertyTree> filter) { var node = new TreeNode(filter.Name, ToTreeNodes(filter.Filters)); node.Tag = filter; return(node); }
public void match_with_includes_and_no_excludes() { var filter = new CompositeFilter<string>(); filter.Includes += x => x == "a"; filter.Matches("a").ShouldBeTrue(); filter.Matches("b").ShouldBeFalse(); }
public CompositeFilter <FixtureGraph> CreateFixtureFilter() { var filter = new CompositeFilter <FixtureGraph>(); _filters.Each(x => x.Apply(filter)); return(filter); }
public CompositeFilter <Type> CreateTypeFilter() { var filter = new CompositeFilter <Type>(); _filters.Each(x => x.Apply(filter)); return(filter); }
public PartsList CalculateTemp(string item, decimal quantity = 1) { var preferred = new PreferredFilter(); // Iron Gear using Iron Bar preferred.Add("Iron Gear", _gameContext.Recipes.GetRecipes(r => r.Products.Any(p => p.Name == "Iron Gear") && r.Ingredients.Any(i => i.Name == "Iron Bar")).Single()); // Steel using Coal preferred.Add("Steel", _gameContext.Recipes.GetRecipes(r => r.Products.Any(p => p.Name == "Steel") && r.Ingredients.Any(i => i.Name == "Coal")).Single()); // Raw Meat using Bison Carcass preferred.Add("Raw Meat", _gameContext.Recipes.GetRecipes(r => r.Products.Any(p => p.Name == "Raw Meat") && r.Ingredients.Any(i => i.Name == "Bison Carcass")).Single()); // Scrap Meat using Raw Meat preferred.Add("Scrap Meat", _gameContext.Recipes.GetRecipes(r => r.Products.All(p => p.Name == "Scrap Meat") && r.Ingredients.Any(i => i.Name == "Raw Meat")).Single()); // Sugar preferred.Add("Sugar", _gameContext.Recipes.GetRecipes(r => r.Products.Any(p => p.Name == "Sugar")).First()); // Vegetable Medley preferred.Add("Vegetable Medley", _gameContext.Recipes.GetRecipes(r => r.Products.Any(p => p.Name == "Vegetable Medley")).First()); // Fruit Salad preferred.Add("Fruit Salad", _gameContext.Recipes.GetRecipes(r => r.Products.Any(p => p.Name == "Fruit Salad")).First()); // Basic Salad preferred.Add("Basic Salad", _gameContext.Recipes.GetRecipes(r => r.Products.Any(p => p.Name == "Basic Salad")).First()); // Tallow preferred.Add("Tallow", _gameContext.Recipes.GetRecipes(r => r.Products.Any(p => p.Name == "Tallow") && r.Ingredients.All(i => i.Name == "Raw Bacon")).Single()); // Leather Hide preferred.Add("Leather Hide", _gameContext.Recipes.GetRecipes(r => r.Products.Any(p => p.Name == "Leather Hide")).First()); // Fur Pelt preferred.Add("Fur Pelt", _gameContext.Recipes.GetRecipes(r => r.Products.Any(p => p.Name == "Fur Pelt")).First()); // Oil preferred.Add("Oil", _gameContext.Recipes.GetRecipes(r => r.Products.Any(p => p.Name == "Oil") && r.Ingredients.Any(i => i.Name == "Tallow")).Single()); // Cereal Germ preferred.Add("Cereal Germ", _gameContext.Recipes.GetRecipes(r => r.Products.Any(p => p.Name == "Cereal Germ")).First()); var filter = new CompositeFilter ( new ProductFilter(), preferred ); var partsList = new PartsList(); Calculate(item, partsList, filter, quantity); return(partsList); }
private static bool VerifyQueryFilters(QueryFilter aqsFilter, QueryFilter kqlFilter) { if (aqsFilter == kqlFilter) { return(true); } if (kqlFilter is CompositeFilter) { if (aqsFilter is CompositeFilter) { CompositeFilter compositeFilter = (CompositeFilter)aqsFilter; CompositeFilter compositeFilter2 = (CompositeFilter)kqlFilter; if (compositeFilter.FilterCount == compositeFilter2.FilterCount) { for (int i = 0; i < compositeFilter.FilterCount; i++) { if (!Utils.VerifyQueryFilters(compositeFilter.Filters[i], compositeFilter2.Filters[i])) { return(false); } } return(true); } } } else if (kqlFilter is ComparisonFilter) { if (kqlFilter.Equals(Utils.KqlImportanceHigh)) { return(aqsFilter.Equals(Utils.AqsImportanceHigh)); } if (kqlFilter.Equals(Utils.KqlImportanceNormal)) { return(aqsFilter.Equals(Utils.AqsImportanceNormal)); } if (kqlFilter.Equals(Utils.KqlImportanceLow)) { return(aqsFilter.Equals(Utils.AqsImportanceLow)); } if (aqsFilter is ComparisonFilter) { ComparisonFilter comparisonFilter = aqsFilter as ComparisonFilter; ComparisonFilter comparisonFilter2 = kqlFilter as ComparisonFilter; if (comparisonFilter.Property.Name == comparisonFilter2.Property.Name && comparisonFilter.ComparisonOperator == comparisonFilter2.ComparisonOperator) { if (comparisonFilter.PropertyValue == null) { return(comparisonFilter2.PropertyValue == null); } if (comparisonFilter.PropertyValue is ExDateTime && comparisonFilter2.PropertyValue is ExDateTime) { return(comparisonFilter2.PropertyValue.ToString().Equals(new ExDateTime(ExTimeZone.CurrentTimeZone, ((ExDateTime)comparisonFilter.PropertyValue).UniversalTime).ToString())); } } } } return(aqsFilter.Equals(kqlFilter)); }
public void match_with_includes_and_no_excludes() { var filter = new CompositeFilter <string>(); filter.Includes += x => x == "a"; filter.Matches("a").ShouldBeTrue(); filter.Matches("b").ShouldBeFalse(); }
public IFilter ToFilter() { var type = Enum.Parse <FilterType>(Type); if (type == FilterType.Composite) { var compositeFilter = new CompositeFilter { And = And, Type = FilterType.Composite, Filters = Filters?.Select(t => t.ToFilter())?.ToList() ?? new List <IFilter>() }; return(compositeFilter); } object value = Value; if (Value is JsonElement jsonElement) { if (jsonElement.ValueKind == JsonValueKind.String) { value = jsonElement.ToString(); } else if (jsonElement.ValueKind == JsonValueKind.Number && jsonElement.TryGetInt64(out var l)) { value = l; } else if (jsonElement.ValueKind == JsonValueKind.True) { value = true; } else if (jsonElement.ValueKind == JsonValueKind.False) { value = false; } else if (jsonElement.ValueKind == JsonValueKind.Array) { throw new System.Exception("TODO"); } else { value = null; } } var simpleFilter = new SimpleFilter { And = And, Type = type, Not = Not, Path = Path, Value = value, CaseInsensitive = CaseInsensitive, }; return(simpleFilter); }
public void TypeMethodPolicyTester() { var filter = new CompositeFilter <MethodInfo>(); var policy = new TypeMethodPolicy <IRouter>(filter); policy.Include(x => x.Go()); filter.Matches(ReflectionHelper.GetMethod <Router1>(x => x.Go())).ShouldBeTrue(); filter.Matches(ReflectionHelper.GetMethod <Router1>(x => x.CanGo())).ShouldBeFalse(); }
public virtual ItemFilter GetEditorFilter(IPrincipal user) { ItemFilter filter = new AccessFilter(user, securityManager); if (!settings.DisplayDataItems) { filter = new CompositeFilter(new PageFilter(), filter); } return(filter); }
public void matches_all_with_excludes() { var filter = new CompositeFilter<string>(); filter.Excludes += x => x.EndsWith("*"); filter.Excludes += x => x.EndsWith("$"); filter.MatchesAll("a").ShouldBeTrue(); filter.MatchesAll("a*").ShouldBeFalse(); filter.MatchesAll("a$").ShouldBeFalse(); }
public void match_with_matching_include_and_not_matching_exclude() { var filter = new CompositeFilter<string>(); filter.Includes += x => x.StartsWith("a"); filter.Excludes += x => x == "a"; filter.Matches("a").ShouldBeFalse(); filter.Matches("abc").ShouldBeTrue(); filter.Matches("b").ShouldBeFalse(); }
public void matches_all_with_only_includes() { var filter = new CompositeFilter<string>(); filter.Includes += x => x.StartsWith("a"); filter.Includes += x => x.EndsWith("c"); filter.Includes += x => x.Contains("b"); filter.MatchesAll("abc").ShouldBeTrue(); filter.MatchesAll("ac").ShouldBeFalse(); filter.MatchesAll("abdc").ShouldBeTrue(); filter.MatchesAll("abdd").ShouldBeFalse(); filter.MatchesAll("babdc").ShouldBeFalse(); }
private static TypePool getTypes() { var types = new TypePool(ConfigurationGraph.FindTheCallingAssembly()); var filter = new CompositeFilter<Assembly>(); filter.Excludes.Add(a => a.IsDynamic); filter.Excludes.Add(a => types.HasAssembly(a)); filter.Includes += (t => true); types.AddSource(() => AppDomain.CurrentDomain.GetAssemblies().Where(filter.MatchesAll)); return types; }
public void matches_all_with_mixed_includes_and_excludes() { var filter = new CompositeFilter<string>(); filter.Includes += x => x.StartsWith("a"); filter.Includes += x => x.EndsWith("c"); filter.Excludes += x => x.Contains("*"); filter.Excludes += x => x.Contains("$"); filter.MatchesAll("ac").ShouldBeTrue(); filter.MatchesAll("abc").ShouldBeTrue(); filter.MatchesAll("abdc").ShouldBeTrue(); filter.MatchesAll("abd*c").ShouldBeFalse(); filter.MatchesAll("abd$c").ShouldBeFalse(); }
public void Apply(CompositeFilter<Type> filter) { if (Type == FilterType.Fixture) { filter.Includes += t => t.GetFixtureAlias() == Name; } else if (Type == FilterType.All) { filter.Includes += t => true; } else { filter.Includes += t => t.IsInNamespace(Name); } }
public void has_changed() { var filter = new CompositeFilter<string>(); filter.HasChanged.ShouldBeFalse(); filter.Includes += x => x == "a"; filter.HasChanged.ShouldBeTrue(); filter.ResetChangeTracking(); filter.HasChanged.ShouldBeFalse(); filter.Excludes += x => x == "a"; filter.HasChanged.ShouldBeTrue(); filter.ResetChangeTracking(); filter.HasChanged.ShouldBeFalse(); }
public void Apply(CompositeFilter<FixtureGraph> filter) { switch (Type) { case FilterType.All: filter.Includes += f => true; break; case FilterType.Fixture: filter.Includes += f => f.Name == Name; break; case FilterType.Namespace: filter.Includes += f => f.FixtureNamespace.IsEmpty() ? false : f.FixtureNamespace.StartsWith(Name); break; } }
/// <summary> /// Converts a <see cref="TcmCDService.Contracts.TaxonomyFilter" /> to <see cref="T:Tridion.ContentDelivery.Taxonomies.TaxonomyFilter" /> /// </summary> /// <param name="taxonomyFilter"><see cref="TcmCDService.Contracts.TaxonomyFilter" /></param> /// <returns><see cref="T:Tridion.ContentDelivery.Taxonomies.TaxonomyFilter" /> or null</returns> internal static TaxonomyFilter ToTaxonomyFilter(this Contracts.TaxonomyFilter taxonomyFilter) { if (taxonomyFilter != null) { CompositeFilter filter = new CompositeFilter(); if (taxonomyFilter.FilterConcrete.HasValue || taxonomyFilter.FilterAbstract.HasValue) filter.AbstractKeywordFiltering(taxonomyFilter.FilterConcrete.GetValueOrDefault(false), taxonomyFilter.FilterAbstract.GetValueOrDefault(false)); if (taxonomyFilter.DepthFilteringLevel.HasValue) filter.DepthFiltering(taxonomyFilter.DepthFilteringLevel.GetValueOrDefault(-1), (int)taxonomyFilter.DepthFilteringDirection); if (taxonomyFilter.FilterHasChildren.HasValue || taxonomyFilter.FilterNavigable.HasValue) filter.PropertyKeywordFiltering(taxonomyFilter.FilterHasChildren.GetValueOrDefault(false), taxonomyFilter.FilterNavigable.GetValueOrDefault(false)); return filter; } return null; }
public void SetUp() { observer = MockRepository.GenerateMock<IFixtureObserver>(); var filter = new CompositeFilter<Type>(); filter.Includes += t => t.Name.StartsWith("M"); builder = new LibraryBuilder(observer, filter); library = builder.Build(new TestContext(x => x.AddFixturesFromThisAssembly())); }
public ContentCompression() { _filters = new CompositeFilter<BehaviorChain>(); Include(x => true); Exclude(x => x.FirstCall() != null && x.FirstCall().HasAttribute<DoNotCompressAttribute>()); }
public void TypeMethodPolicyTester() { var filter = new CompositeFilter<MethodInfo>(); var policy = new TypeMethodPolicy<IRouter>(filter); policy.Include(x => x.Go()); filter.Matches(ReflectionHelper.GetMethod<Router1>(x => x.Go())).ShouldBeTrue(); filter.Matches(ReflectionHelper.GetMethod<Router1>(x => x.CanGo())).ShouldBeFalse(); }
public void match_with_no_includes_an_no_excludes() { var filter = new CompositeFilter<string>(); filter.Excludes.DoesNotMatcheAny("a").ShouldBeTrue(); filter.Matches("a").ShouldBeTrue(); }
public void SetUp() { container = new Container(); var registry = new FixtureRegistry(); registry.AddFixturesFromThisAssembly(); registry.AddFixturesToContainer(container); observer = MockRepository.GenerateMock<IFixtureObserver>(); var filter = new CompositeFilter<Type>(); filter.Includes += t => t.Name.StartsWith("M"); builder = new LibraryBuilder(observer, filter, new ObjectConverter()); library = builder.Build(new TestContext(container)); }
public IEnumerable<Type> For(IEnumerable<Assembly> assemblies, CompositeFilter<Type> filter) { return assemblies.SelectMany(x => _types[x].Where(filter.Matches)); }
public Dynamic.IKeyword GetKeyword(string categoryUriToLookIn, string keywordName) { //Create filter to retrieve all keywords in a taxonomy CompositeFilter compFilter = new CompositeFilter(); compFilter.DepthFiltering(DepthFilter.UnlimitedDepth, DepthFilter.FilterUp); compFilter.DepthFiltering(DepthFilter.UnlimitedDepth, DepthFilter.FilterDown); //Get keywords in taxonomy (hierarchically) IEnumerable<Keyword> taxonomy = null; try { //Ugly way to see if a taxonomy exists. Alternative is to loop through all taxonomys in Tridion and check if the categoryUriToLookIn exists... taxonomy = TaxonomyFactory.GetTaxonomyKeywords(categoryUriToLookIn, compFilter, new TaxonomyHierarchyFormatter()).KeywordChildren.Cast<Keyword>(); } catch (Exception) { //TODO: Trace return null; } //Search in taxonomy Keyword foundKeyword = null; foreach (var currentKeyword in taxonomy) { string currentKeywordName = currentKeyword.KeywordName; if (currentKeywordName != keywordName) { foundKeyword = recursive(currentKeyword.KeywordChildren.Cast<Keyword>().ToList(), keywordName); } else { foundKeyword = currentKeyword; } if (foundKeyword != null) { Dynamic.Keyword returnKeyword = new Dynamic.Keyword(); Keyword par = foundKeyword.ParentKeyword; do { Dynamic.Keyword newParentKeyword = new Dynamic.Keyword(); newParentKeyword.Id = par.KeywordUri; newParentKeyword.TaxonomyId = par.TaxonomyUri; newParentKeyword.Title = par.KeywordName; returnKeyword.ParentKeywords.Add(newParentKeyword); //Add the parentkeyword to the list par = par.ParentKeyword; } while (par != null); //Add remaining properties to the returnKeyword returnKeyword.Id = foundKeyword.KeywordUri; returnKeyword.TaxonomyId = foundKeyword.TaxonomyUri; returnKeyword.Title = foundKeyword.KeywordName; return returnKeyword; } } return null; }
public TypeMatcher(TypePool types) { _types = types; _typeFilters = new CompositeFilter<Type>(); }
public LibraryBuilder(IFixtureObserver observer, CompositeFilter<Type> filter) { _observer = observer; _filter = filter; }