/// <inheritdoc />
public IValueProvider GetValueProvider([NotNull] ValueProviderFactoryContext context)
{
var valueProviders = _valueProviderFactories.Select(factory => factory.GetValueProvider(context))
.Where(vp => vp != null);
return(new CompositeValueProvider(valueProviders));
}
/// <inheritdoc />
public Task <IValueProvider> GetValueProviderAsync([NotNull] ValueProviderFactoryContext context)
{
return(Task.FromResult <IValueProvider>(new ReadableStringCollectionValueProvider(
BindingSource.Query,
context.HttpContext.Request.Query,
CultureInfo.InvariantCulture)));
}
/// <inheritdoc />
public IValueProvider GetValueProvider([NotNull] ValueProviderFactoryContext context)
{
return(new ReadableStringCollectionValueProvider(
BindingSource.Query,
context.HttpContext.Request.Query,
CultureInfo.InvariantCulture));
}
/// <summary>
/// Creates a new <see cref="CompositeValueProvider"/> from the provided <paramref name="context"/>
/// and <paramref name="factories"/>.
/// </summary>
/// <param name="factories">The set of <see cref="IValueProviderFactory"/> instances.</param>
/// <param name="context">The <see cref="ValueProviderFactoryContext"/>.</param>
/// <returns>
/// A <see cref="CompositeValueProvider"/> containing all <see cref="IValueProvider"/> instances
/// created.
/// </returns>
public static async Task <CompositeValueProvider> CreateAsync(
IEnumerable <IValueProviderFactory> factories,
ValueProviderFactoryContext context)
{
if (factories == null)
{
throw new ArgumentNullException(nameof(factories));
}
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
var composite = new CompositeValueProvider();
foreach (var valueProvidersFactory in factories)
{
var valueProvider = await valueProvidersFactory.GetValueProviderAsync(context);
if (valueProvider != null)
{
composite.Add(valueProvider);
}
}
return(composite);
}
public Task<ActionBindingContext> GetActionBindingContextAsync(ActionContext actionContext)
{
if (_bindingContext != null)
{
if (actionContext == _bindingContext.Item1)
{
return Task.FromResult(_bindingContext.Item2);
}
}
var factoryContext = new ValueProviderFactoryContext(
actionContext.HttpContext,
actionContext.RouteData.Values);
var valueProvider = _compositeValueProviderFactory.GetValueProvider(factoryContext);
var context = new ActionBindingContext(
actionContext,
_modelMetadataProvider,
_compositeModelBinder,
valueProvider,
_inputFormatterProvider,
_validatorProviders);
_bindingContext = new Tuple<ActionContext, ActionBindingContext>(actionContext, context);
return Task.FromResult(context);
}
public IValueProvider GetValueProvider(ValueProviderFactoryContext context)
{
if (context.HttpContext.Request.Path.Value.Contains("TestValueProvider"))
{
return new CustomValueProvider();
}
return null;
}
public Task<IValueProvider> GetValueProviderAsync(ValueProviderFactoryContext context)
{
if (context.HttpContext.Request.Path.Value.Contains("TestValueProvider"))
{
return Task.FromResult<IValueProvider>(new CustomValueProvider());
}
return Task.FromResult<IValueProvider>(null);
}
public Task<IValueProvider> GetValueProviderAsync(ValueProviderFactoryContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
return Task.FromResult<IValueProvider>(new DictionaryBasedValueProvider(
BindingSource.Path,
context.RouteValues));
}
public Task <IValueProvider> GetValueProviderAsync(ValueProviderFactoryContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
return(Task.FromResult <IValueProvider>(new DictionaryBasedValueProvider(
BindingSource.Path,
context.RouteValues)));
}
/// <inheritdoc />
public Task<IValueProvider> GetValueProviderAsync(ValueProviderFactoryContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
return Task.FromResult<IValueProvider>(new ReadableStringCollectionValueProvider(
BindingSource.Query,
context.HttpContext.Request.Query,
CultureInfo.InvariantCulture));
}
public IValueProvider GetValueProvider([NotNull] ValueProviderFactoryContext context)
{
var request = context.HttpContext.Request;
if (IsSupportedContentType(request))
{
var culture = GetCultureInfo(request);
return(new ReadableStringCollectionValueProvider(() => request.GetFormAsync(), culture));
}
return(null);
}
/// <inheritdoc />
public Task <IValueProvider> GetValueProviderAsync(ValueProviderFactoryContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
return(Task.FromResult <IValueProvider>(new ReadableStringCollectionValueProvider(
BindingSource.Query,
context.HttpContext.Request.Query,
CultureInfo.InvariantCulture)));
}
public async Task <IValueProvider> GetValueProviderAsync([NotNull] ValueProviderFactoryContext context)
{
var request = context.HttpContext.Request;
if (request.HasFormContentType)
{
return(new JQueryFormValueProvider(
BindingSource.Form,
await GetValueCollectionAsync(request),
CultureInfo.CurrentCulture));
}
return(null);
}
public IValueProvider GetValueProvider([NotNull] ValueProviderFactoryContext context)
{
var request = context.HttpContext.Request;
if (request.HasFormContentType)
{
var culture = GetCultureInfo(request);
return(new ReadableStringCollectionValueProvider <IFormDataValueProviderMetadata>(
async() => await request.ReadFormAsync(),
culture));
}
return(null);
}
public Task<IValueProvider> GetValueProviderAsync(ValueProviderFactoryContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
var request = context.HttpContext.Request;
if (request.HasFormContentType)
{
return CreateValueProviderAsync(request);
}
return TaskCache<IValueProvider>.DefaultCompletedTask;
}
public Task <IValueProvider> GetValueProviderAsync(ValueProviderFactoryContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
var request = context.HttpContext.Request;
if (request.HasFormContentType)
{
return(CreateValueProviderAsync(request));
}
return(TaskCache <IValueProvider> .DefaultCompletedTask);
}
public async Task <IValueProvider> GetValueProviderAsync([NotNull] ValueProviderFactoryContext context)
{
var request = context.HttpContext.Request;
if (request.HasFormContentType)
{
var culture = GetCultureInfo(request);
return(new ReadableStringCollectionValueProvider(
BindingSource.Form,
await request.ReadFormAsync(),
culture));
}
return(null);
}
/// <summary>
/// Creates a new <see cref="CompositeValueProvider"/> from the provided <paramref name="context"/>
/// and <paramref name="factories"/>.
/// </summary>
/// <param name="factories">The set of <see cref="IValueProviderFactory"/> instances.</param>
/// <param name="context">The <see cref="ValueProviderFactoryContext"/>.</param>
/// <returns>
/// A <see cref="CompositeValueProvider"/> containing all <see cref="IValueProvider"/> instances
/// created.
/// </returns>
public static CompositeValueProvider Create(
[NotNull] IEnumerable <IValueProviderFactory> factories,
[NotNull] ValueProviderFactoryContext context)
{
var composite = new CompositeValueProvider();
foreach (var valueProvidersFactory in factories)
{
var valueProvider = valueProvidersFactory.GetValueProvider(context);
if (valueProvider != null)
{
composite.Add(valueProvider);
}
}
return(composite);
}
public IValueProvider GetValueProvider([NotNull] ValueProviderFactoryContext context)
{
// Process the query collection once-per request.
var storage = context.HttpContext.Items;
object value;
IValueProvider provider;
if (!storage.TryGetValue(_cacheKey, out value))
{
var queryCollection = context.HttpContext.Request.Query;
provider = new ReadableStringCollectionValueProvider(queryCollection, CultureInfo.InvariantCulture);
storage[_cacheKey] = provider;
}
else
{
provider = (ReadableStringCollectionValueProvider)value;
}
return(provider);
}
public async Task GetValueProvider_ReturnsSnakeCaseQueryValueProviderInstanceWithInvariantCulture()
{
// Arrange
var request = new Mock<HttpRequest>();
request.SetupGet(f => f.Query).Returns(Mock.Of<IReadableStringCollection>());
var context = new Mock<HttpContext>();
context.SetupGet(c => c.Items).Returns(new Dictionary<object, object>());
context.SetupGet(c => c.Request).Returns(request.Object);
var factoryContext = new ValueProviderFactoryContext(
context.Object,
new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase));
// Act
var result = await _factory.GetValueProviderAsync(factoryContext);
// Assert
var valueProvider = Assert.IsType<SnakeCaseQueryValueProvider>(result);
Assert.Equal(CultureInfo.InvariantCulture, valueProvider.Culture);
}
public Task<IValueProvider> GetValueProviderAsync(ValueProviderFactoryContext context)
{
var collection = new Dictionary<string, object>();
var lightcoreContext = context.HttpContext.LightcoreContext();
var item = lightcoreContext?.Item;
if (item != null)
{
var controller = context.RouteValues["controller"] as string;
if (controller != null && !controller.Equals("Lightcore"))
{
var rendering = item.PresentationDetails.Renderings
.FirstOrDefault(r => r.Controller.Equals(controller, StringComparison.OrdinalIgnoreCase));
if (rendering != null)
{
foreach (var parameter in rendering.Parameters)
{
collection.Add(parameter.Key, parameter.Value);
}
collection.Add("datasource", rendering.Datasource);
collection.Add("language", item.Language.Name);
collection.Add("itemId", item.Id);
collection.Add("templateId", item.TemplateId);
collection.Add("renderingContext.Datasource", rendering.Datasource);
collection.Add("renderingContext.ItemLanguageName", item.Language.Name);
collection.Add("renderingContext.ItemId", item.Id);
collection.Add("renderingContext.ItemTemplateId", item.TemplateId);
}
}
}
return Task.FromResult<IValueProvider>(new DictionaryBasedValueProvider(BindingSource.ModelBinding, collection));
}
public Task <IValueProvider> GetValueProviderAsync([NotNull] ValueProviderFactoryContext context)
{
return(Task.FromResult <IValueProvider>(new DictionaryBasedValueProvider(
BindingSource.Path,
context.RouteValues)));
}
private static ActionBindingContext GetActionBindingContext(MvcOptions options, ActionContext actionContext)
{
var valueProviderFactoryContext = new ValueProviderFactoryContext(
actionContext.HttpContext,
actionContext.RouteData.Values);
var valueProvider = CompositeValueProvider.CreateAsync(
options.ValueProviderFactories,
valueProviderFactoryContext).Result;
return new ActionBindingContext()
{
InputFormatters = options.InputFormatters,
OutputFormatters = options.OutputFormatters, // Not required for model binding.
ValidatorProvider = new TestModelValidatorProvider(options.ModelValidatorProviders),
ModelBinder = new CompositeModelBinder(options.ModelBinders),
ValueProvider = valueProvider
};
}
public IValueProvider GetValueProvider(ValueProviderFactoryContext context)
{
throw new NotImplementedException();
}
public IValueProvider GetValueProvider([NotNull] ValueProviderFactoryContext context)
{
return(new DictionaryBasedValueProvider(BindingSource.Path, context.RouteValues));
}