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;
}
