private static void DoValidationProcess(FilterDefinition filterdata, FilterMetadata metadata)
{
List <SimpleFilterDefinition> simpleFilters = new List <SimpleFilterDefinition>();
ExtractAllSimpleFilterData(filterdata, ref simpleFilters);
foreach (var filter in simpleFilters)
{
bool isValidField = false;
foreach (var item in metadata.Items)
{
if (filter.FieldName == item.FieldName)
{
try
{
Convert.ChangeType(filter.Value, item.Type);
isValidField = true;
}
catch
{
isValidField = false;
break;
}
}
}
if (!isValidField)
{
throw new InvalidOperationException($"Invalid filter has been applyed to {metadata.TypeName} Filter: {filter}");
}
}
}
public async void WrapperResolvesActionFilterFromDependencyScope()
{
var builder = new ContainerBuilder();
builder.Register <ILogger>(c => new Logger()).InstancePerDependency();
var activationCount = 0;
builder.Register <IAutofacActionFilter>(c => new TestActionFilter(c.Resolve <ILogger>()))
.AsWebApiActionFilterFor <TestController>(c => c.Get())
.InstancePerRequest()
.OnActivated(e => activationCount++);
var container = builder.Build();
var resolver = new AutofacWebApiDependencyResolver(container);
var controllerContext = CreateControllerContext(resolver);
var methodInfo = typeof(TestController).GetMethod("Get");
var actionDescriptor = CreateActionDescriptor(methodInfo);
var actionContext = new HttpActionContext(controllerContext, actionDescriptor);
var httpActionExecutedContext = new HttpActionExecutedContext(actionContext, null);
var metadata = new FilterMetadata
{
ControllerType = typeof(TestController),
FilterScope = FilterScope.Action,
MethodInfo = methodInfo
};
var wrapper = new ActionFilterWrapper(metadata);
await wrapper.OnActionExecutingAsync(actionContext, CancellationToken.None);
Assert.Equal(1, activationCount);
await wrapper.OnActionExecutedAsync(httpActionExecutedContext, CancellationToken.None);
Assert.Equal(1, activationCount);
}
public void WrapperResolvesAuthenticationFilterFromDependencyScope()
{
var builder = new ContainerBuilder();
builder.Register<ILogger>(c => new Logger()).InstancePerDependency();
var activationCount = 0;
builder.Register<IAutofacAuthenticationFilter>(c => new TestAuthenticationFilter(c.Resolve<ILogger>()))
.AsWebApiAuthenticationFilterFor<TestController>(c => c.Get())
.InstancePerRequest()
.OnActivated(e => activationCount++);
var container = builder.Build();
var resolver = new AutofacWebApiDependencyResolver(container);
var configuration = new HttpConfiguration { DependencyResolver = resolver };
var requestMessage = new HttpRequestMessage();
requestMessage.Properties.Add(HttpPropertyKeys.HttpConfigurationKey, configuration);
var contollerContext = new HttpControllerContext { Request = requestMessage };
var controllerDescriptor = new HttpControllerDescriptor { ControllerType = typeof(TestController) };
var methodInfo = typeof(TestController).GetMethod("Get");
var actionDescriptor = new ReflectedHttpActionDescriptor(controllerDescriptor, methodInfo);
var actionContext = new HttpActionContext(contollerContext, actionDescriptor);
var context = new HttpAuthenticationContext(actionContext, Thread.CurrentPrincipal);
var metadata = new FilterMetadata
{
ControllerType = typeof(TestController),
FilterScope = FilterScope.Action,
MethodInfo = methodInfo
};
var wrapper = new AuthenticationFilterWrapper(metadata);
wrapper.OnAuthenticate(context);
Assert.Equal(1, activationCount);
}
AsFilterFor <TFilter>(IRegistrationBuilder <object, IConcreteActivatorData, SingleRegistrationStyle> registration, string metadataKey, Type controllerType)
{
if (registration == null)
{
throw new ArgumentNullException("registration");
}
if (controllerType == null)
{
throw new ArgumentNullException("controllerType");
}
if (!controllerType.IsAssignableTo <IHttpController>())
{
throw new ArgumentNullException("controllerType");
}
var limitType = registration.ActivatorData.Activator.LimitType;
if (!limitType.IsAssignableTo <TFilter>())
{
var message = string.Format(CultureInfo.CurrentCulture, RegistrationExtensionsResources.MustBeAssignableToFilterType,
limitType.FullName, typeof(TFilter).FullName);
throw new ArgumentException(message, "registration");
}
var metadata = new FilterMetadata
{
ControllerType = controllerType,
FilterScope = FilterScope.Controller,
MethodInfo = null
};
return(registration.As <TFilter>().WithMetadata(metadataKey, metadata));
}
public void FilterMetadata_1_Prop_Test()
{
// given
// when
IFilterMetadata filterData = new FilterMetadata();
filterData.value = 1;
// then
Assert.IsNotNull(filterData);
//
}
/// <summary>
/// Retrieve or create filter metadata. We want to maintain the fluent flow when we change
/// registration metadata so we'll do that here.
/// </summary>
public static IRegistrationBuilder <object, IConcreteActivatorData, SingleRegistrationStyle> GetMetadata(
this IRegistrationBuilder <object, IConcreteActivatorData, SingleRegistrationStyle> registration,
out FilterMetadata filterMeta)
{
Assert.True(registration.RegistrationData.Metadata.TryGetValue(AutofacWebApiFilterProvider.FilterMetadataKey, out var filterDataObj));
filterMeta = (FilterMetadata)filterDataObj;
Assert.NotNull(filterMeta);
return(registration);
}
public void FilterMetadata_2_Prop_Test()
{
// given
// when
IFilterMetadata filterData = new FilterMetadata();
filterData.value = 1;
filterData.matchMode = "equal";
// then
Assert.IsNotNull(filterData);
//
}
public async void WrapperResolvesActionFilterFromDependencyScope()
{
var builder = new ContainerBuilder();
builder.Register <ILogger>(c => new Logger()).InstancePerDependency();
var activationCount = 0;
builder.Register <IAutofacActionFilter>(c => new TestActionFilter(c.Resolve <ILogger>()))
.AsWebApiActionFilterFor <TestController>(c => c.Get())
.InstancePerRequest()
.OnActivated(e => activationCount++);
var container = builder.Build();
var resolver = new AutofacWebApiDependencyResolver(container);
var configuration = new HttpConfiguration {
DependencyResolver = resolver
};
var requestMessage = new HttpRequestMessage();
requestMessage.Properties.Add(HttpPropertyKeys.HttpConfigurationKey, configuration);
var contollerContext = new HttpControllerContext {
Request = requestMessage
};
var controllerDescriptor = new HttpControllerDescriptor {
ControllerType = typeof(TestController)
};
var methodInfo = typeof(TestController).GetMethod("Get");
var actionDescriptor = new ReflectedHttpActionDescriptor(controllerDescriptor, methodInfo);
var httpActionContext = new HttpActionContext(contollerContext, actionDescriptor);
var actionContext = new HttpActionContext(contollerContext, actionDescriptor);
var httpActionExecutedContext = new HttpActionExecutedContext(actionContext, null);
var metadata = new FilterMetadata
{
ControllerType = typeof(TestController),
FilterScope = FilterScope.Action,
MethodInfo = methodInfo
};
var wrapper = new ActionFilterWrapper(metadata);
await wrapper.OnActionExecutingAsync(httpActionContext, new CancellationToken());
Assert.Equal(1, activationCount);
await wrapper.OnActionExecutedAsync(httpActionExecutedContext, new CancellationToken());
Assert.Equal(1, activationCount);
}
public async void RunsFiltersInCorrectOrder()
{
// Issue #16: Filters need to run 1, 2, 3 in Executing but 3, 2, 1 in Executed.
var builder = new ContainerBuilder();
var order = new List <string>();
builder.Register(ctx => new DelegatingLogger(s => order.Add(s)))
.As <ILogger>()
.SingleInstance();
builder.RegisterType <TestActionFilter>()
.AsWebApiActionFilterFor <TestController>(c => c.Get())
.InstancePerRequest();
builder.RegisterType <TestActionFilter2>()
.AsWebApiActionFilterFor <TestController>(c => c.Get())
.InstancePerRequest();
var container = builder.Build();
var resolver = new AutofacWebApiDependencyResolver(container);
var controllerContext = CreateControllerContext(resolver);
var methodInfo = typeof(TestController).GetMethod("Get");
var actionDescriptor = CreateActionDescriptor(methodInfo);
var actionContext = new HttpActionContext(controllerContext, actionDescriptor);
var httpActionExecutedContext = new HttpActionExecutedContext(actionContext, null);
var metadata = new FilterMetadata
{
ControllerType = typeof(TestController),
FilterScope = FilterScope.Action,
MethodInfo = methodInfo
};
var wrapper = new ActionFilterWrapper(metadata);
await wrapper.OnActionExecutingAsync(actionContext, CancellationToken.None);
await wrapper.OnActionExecutedAsync(httpActionExecutedContext, CancellationToken.None);
Assert.Equal("TestActionFilter2.OnActionExecutingAsync", order[0]);
Assert.Equal("TestActionFilter.OnActionExecutingAsync", order[1]);
Assert.Equal("TestActionFilter.OnActionExecutedAsync", order[2]);
Assert.Equal("TestActionFilter2.OnActionExecutedAsync", order[3]);
}
public void WrapperResolvesAuthenticationFilterFromDependencyScope()
{
var builder = new ContainerBuilder();
builder.Register <ILogger>(c => new Logger()).InstancePerDependency();
var activationCount = 0;
builder.Register <IAutofacAuthenticationFilter>(c => new TestAuthenticationFilter(c.Resolve <ILogger>()))
.AsWebApiAuthenticationFilterFor <TestController>(c => c.Get())
.InstancePerRequest()
.OnActivated(e => activationCount++);
var container = builder.Build();
var resolver = new AutofacWebApiDependencyResolver(container);
var configuration = new HttpConfiguration {
DependencyResolver = resolver
};
var requestMessage = new HttpRequestMessage();
requestMessage.Properties.Add(HttpPropertyKeys.HttpConfigurationKey, configuration);
var contollerContext = new HttpControllerContext {
Request = requestMessage
};
var controllerDescriptor = new HttpControllerDescriptor {
ControllerType = typeof(TestController)
};
var methodInfo = typeof(TestController).GetMethod("Get");
var actionDescriptor = new ReflectedHttpActionDescriptor(controllerDescriptor, methodInfo);
var actionContext = new HttpActionContext(contollerContext, actionDescriptor);
var context = new HttpAuthenticationContext(actionContext, Thread.CurrentPrincipal);
var metadata = new FilterMetadata
{
ControllerType = typeof(TestController),
FilterScope = FilterScope.Action,
MethodInfo = methodInfo
};
var wrapper = new AuthenticationFilterWrapper(metadata);
wrapper.OnAuthenticate(context);
Assert.That(activationCount, Is.EqualTo(1));
}
public static HashSet <FilterMetadata> ToSingleFilterHashSet(this FilterMetadata metadata)
{
return(new HashSet <FilterMetadata> {
metadata
});
}
private static Specification <T> CreateExpression <T>(FilterDefinition filterdata, FilterMetadata metadata)
{
Specification <T> spec = null;
if (filterdata is SimpleFilterDefinition)
{
var data = filterdata as SimpleFilterDefinition;
spec = new FieldSpecification <T>(data, metadata.GetTypeCodeOfField(data.FieldName));
}
else if (filterdata is ComplexFilterDefinition)
{
var data = filterdata as ComplexFilterDefinition;
if (data.FiltersConnector == ComplexFilterDefinition.Connector.And)
{
spec = new AndSpecification <T>(CreateExpression <T>(data.LeftFilter, metadata), CreateExpression <T>(data.RightFilter, metadata));
}
else
{
spec = new OrSpecification <T>(CreateExpression <T>(data.LeftFilter, metadata), CreateExpression <T>(data.RightFilter, metadata));
}
}
return(spec);
}
