/// <summary>
/// Creates a binding context with the route values populated to similute an Umbraco dynamically routed request
/// </summary>
private ModelBindingContext CreateBindingContextForUmbracoRequest(
Type modelType,
IPublishedContent publishedContent)
{
var builder = new PublishedRequestBuilder(new Uri("https://example.com"), Mock.Of <IFileService>());
builder.SetPublishedContent(publishedContent);
var publishedRequest = builder.Build();
var httpContext = new DefaultHttpContext();
var routeData = new RouteData();
httpContext.Features.Set(new UmbracoRouteValues(publishedRequest, null));
var actionContext = new ActionContext(httpContext, routeData, new ActionDescriptor());
var metadataProvider = new EmptyModelMetadataProvider();
var routeValueDictionary = new RouteValueDictionary();
var valueProvider = new RouteValueProvider(BindingSource.Path, routeValueDictionary);
return(new DefaultModelBindingContext
{
ActionContext = actionContext,
ModelMetadata = metadataProvider.GetMetadataForType(modelType),
ModelName = modelType.Name,
ValueProvider = valueProvider,
});
}
public void GetRouteValues_WithStringLambda_ReturnsRouteValues()
{
Expression <Func <Ping, object> > expression = ping => ping.Pong(Message());
var methodCall = (MethodCallExpression)expression.Body;
var routeValues = RouteValueProvider.GetRouteValues(methodCall);
routeValues["message"].ShouldBe(Message());
}
public void GetRouteValues_WithNullValue_ReturnsRouteValues()
{
string message = null;
Expression <Func <Ping, object> > expression = ping => ping.Pong(message);
var methodCall = (MethodCallExpression)expression.Body;
var routeValues = RouteValueProvider.GetRouteValues(methodCall);
routeValues[nameof(message)].ShouldBeNull();
}
public void ContainsPrefix_ReturnsNullValue_IfKeyIsPresent()
{
// Arrange
var values = new RouteValueDictionary(new Dictionary <string, object>
{
{ "test-key", null }
});
var provider = new RouteValueProvider(BindingSource.Query, values);
// Act
var result = provider.GetValue("test-key");
// Assert
Assert.Equal(string.Empty, (string)result);
}
public void GetValueProvider_ReturnsValue_UsesInvariantCulture()
{
// Arrange
var values = new RouteValueDictionary(new Dictionary <string, object>
{
{ "test-key", new DateTimeOffset(2018, 10, 31, 7, 37, 38, TimeSpan.FromHours(-7)) },
});
var provider = new RouteValueProvider(BindingSource.Query, values);
// Act
var result = provider.GetValue("test-key");
// Assert
Assert.Equal("10/31/2018 07:37:38 -07:00", (string)result);
}
public void GetValueProvider_ReturnsValue_IfKeyIsPresent()
{
// Arrange
var values = new RouteValueDictionary(new Dictionary <string, object>
{
{ "test-key", "test-value" }
});
var provider = new RouteValueProvider(BindingSource.Query, values);
// Act
var result = provider.GetValue("test-key");
// Assert
Assert.Equal("test-value", (string)result);
}
public void ContainsPrefix_ReturnsTrue_IfKeyIsPresent()
{
// Arrange
var values = new RouteValueDictionary(new Dictionary <string, object>
{
{ "test-key", "test-value" }
});
var provider = new RouteValueProvider(BindingSource.Query, values);
// Act
var result = provider.ContainsPrefix("test-key");
// Assert
Assert.True(result);
}
public void GetValueProvider_ReturnsNull_WhenKeyIsNotFound()
{
// Arrange
var values = new RouteValueDictionary(new Dictionary <string, object>
{
{ "test-key", "value" }
});
var provider = new RouteValueProvider(BindingSource.Query, values);
// Act
var result = provider.GetValue("not-test-key");
// Assert
Assert.Equal(ValueProviderResult.None, result);
}
public void GetValue_ReturnsValue_WithDefaultCulture()
{
// Arrange
var values = new RouteValueDictionary(new Dictionary <string, object>
{
{ "test-key", "test-value" }
});
var provider = new RouteValueProvider(BindingSource.Query, values);
// Act
var result = provider.GetValue("test-key");
// Assert
Assert.Equal(CultureInfo.InvariantCulture, result.Culture);
}
public Task CreateValueProviderAsync(ValueProviderFactoryContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
var valueProvider = new RouteValueProvider(
BindingSource.Path,
context.ActionContext.RouteData.Values);
context.ValueProviders.Add(valueProvider);
return(Task.CompletedTask);
}
public void GetValue_DoesNotReturnAValue_ForAKeyPrefix()
{
// Arrange
var values = new RouteValueDictionary(new Dictionary <string, object>
{
{ "bar.baz", 2 },
});
var valueProvider = new RouteValueProvider(BindingSource.Query, values);
// Act
var result = valueProvider.GetValue("bar");
// Assert
Assert.Equal(ValueProviderResult.None, result);
}
public void GetValueProvider_ReturnsValue_UsesSpecifiedCulture()
{
// Arrange
var values = new RouteValueDictionary(new Dictionary <string, object>
{
{ "test-key", new DateTimeOffset(2018, 10, 31, 7, 37, 38, TimeSpan.FromHours(-7)) },
});
var provider = new RouteValueProvider(BindingSource.Query, values, new CultureInfo("de-CH"));
// The formatting was changed in netcoreapp3.0 to be consistent across platforms.
var expected = "31.10.2018 07:37:38 -07:00";
// Act
var result = provider.GetValue("test-key");
// Assert
Assert.Equal(expected, (string)result);
}
public void GetValue_ReturnsCorrectValue_ForKnownKeys(string prefix, string expectedValue)
{
// Arrange
var values = new RouteValueDictionary(new Dictionary <string, object>
{
{ "bar", 1 },
{ "bar.baz", 2 },
});
var valueProvider = new RouteValueProvider(BindingSource.Query, values);
// Act
var result = valueProvider.GetValue(prefix);
// Assert
Assert.Equal(expectedValue, (string)result);
}
public void ContainsPrefix_ReturnsTrue_ForKnownPrefixes(string prefix)
{
// Arrange
var values = new RouteValueDictionary(new Dictionary <string, object>
{
{ "foo", 1 },
{ "bar.baz", 1 },
});
var valueProvider = new RouteValueProvider(BindingSource.Query, values);
// Act
var result = valueProvider.ContainsPrefix(prefix);
// Assert
Assert.True(result);
}
public void FilterExclude()
{
// Arrange
var values = new RouteValueDictionary();
var provider = new RouteValueProvider(BindingSource.Query, values);
var bindingSource = new BindingSource(
"Test",
displayName: null,
isGreedy: true,
isFromRequest: true);
// Act
var result = provider.Filter(bindingSource);
// Assert
Assert.Null(result);
}
public async Task BindModelAsync_DoesNotTrimValue()
{
DefaultModelBindingContext context = new()
{
ModelName = "Test",
ModelState = new ModelStateDictionary(),
ActionContext = MvcHelperFactory.CreateViewContext(),
ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(typeof(String)),
ValueProvider = new RouteValueProvider(BindingSource.Path, new RouteValueDictionary(new { Test = " Value " }))
};
await new NotTrimmedAttribute().BindModelAsync(context);
ModelBindingResult expected = ModelBindingResult.Success(" Value ");
ModelBindingResult actual = context.Result;
Assert.Equal(expected, actual);
}
}
private ModelBindingContext CreateBindingContext(string querystring)
{
var httpContext = new DefaultHttpContext();
httpContext.Request.QueryString = new QueryString(querystring);
httpContext.Request.Headers.Add("X-UMB-CULTURE", new StringValues("en-gb"));
var routeData = new RouteData();
var actionContext = new ActionContext(httpContext, routeData, new ActionDescriptor());
var metadataProvider = new EmptyModelMetadataProvider();
var routeValueDictionary = new RouteValueDictionary();
var valueProvider = new RouteValueProvider(BindingSource.Path, routeValueDictionary);
Type modelType = typeof(FormCollection);
return(new DefaultModelBindingContext
{
ActionContext = actionContext,
ModelMetadata = metadataProvider.GetMetadataForType(modelType),
ModelName = modelType.Name,
ValueProvider = valueProvider,
});
}
public async Task InvokeAsync(HttpContext context)
{
var providerInfoCache = context.RequestServices.GetRequiredService <IProviderInfoCache>();
var currentUserProvider = context.RequestServices.GetRequiredService <ICurrentUserProvider>();
var providerContextProvider = context.RequestServices.GetRequiredService <IProviderContextProvider>();
bool runNext = true;
await TryAssignFeature();
if (runNext)
{
await _next(context);
}
async Task TryAssignFeature()
{
// For Provider {Super}Users the provider comes from their identity token.
// For Admin or Helpdesk users there should be a route value indicating the provider.
// If Provider {Super}Users specify the route value it's ignored.
var user = currentUserProvider.GetCurrentUser();
if (user == null)
{
return;
}
Guid providerId;
// A 'strict' provider context means it cannot be changed for a given request
bool strict = true;
var requestProviderId = TryGetProviderIdFromRequest();
if (!requestProviderId.HasValue)
{
requestProviderId = await TryGetProviderIdFromLegacyContext();
if (requestProviderId.HasValue)
{
strict = false;
}
}
if (user.IsDeveloper || user.IsHelpdesk)
{
if (!requestProviderId.HasValue)
{
return;
}
else
{
providerId = requestProviderId.Value;
}
}
else // user.IsProvider == true
{
var usersOwnProviderId = user.CurrentProviderId.Value;
// Route param or session value, if specified, must match user's own org
if (requestProviderId.HasValue && requestProviderId.Value != usersOwnProviderId)
{
context.Response.StatusCode = StatusCodes.Status403Forbidden;
runNext = false;
return;
}
providerId = usersOwnProviderId;
}
var providerInfo = await providerInfoCache.GetProviderInfo(providerId);
if (providerInfo != null)
{
var providerContext = new ProviderContext(providerInfo, strict);
providerContextProvider.SetProviderContext(providerContext);
}
}
Guid?TryGetProviderIdFromRequest()
{
var routeValueProvider = new RouteValueProvider(
BindingSource.Path,
context.GetRouteData().Values);
var queryStringValueProvider = new QueryStringValueProvider(
BindingSource.Query,
context.Request.Query,
CultureInfo.InvariantCulture);
var matches = routeValueProvider.GetValue(RouteValueKey).Values
.Concat(queryStringValueProvider.GetValue(RouteValueKey).Values)
.Distinct()
.ToList();
if (matches.Count == 1 && Guid.TryParse(matches.Single(), out var providerId))
{
return(providerId);
}
return(null);
}
async Task <Guid?> TryGetProviderIdFromLegacyContext()
{
var ukprn = context.Session.GetInt32("UKPRN");
return(ukprn.HasValue ? await providerInfoCache.GetProviderIdForUkprn(ukprn.Value) : null);
}
}
private Task <object> BindInternal(HttpContext context, Type returnType)
{
var mediatorRequest = Activator.CreateInstance(returnType);
var requestProperties = typeBindingRepo.GetProperties(returnType);
if (!requestProperties.Any())
{
return(Task.FromResult(mediatorRequest));
}
var routeProvider = new RouteValueProvider(BindingSource.Path, context.Request.RouteValues);
var queryProvider = new QueryStringValueProvider(BindingSource.Query, context.Request.Query, CultureInfo.InvariantCulture);
var compositeValueProvider = new CompositeValueProvider
{
routeProvider,
queryProvider
};
IValueProvider formProvider = null;
var bodyProvider = new JsonBodyValueProvider(context, jsonOptions);
if (context.Request.HasFormContentType)
{
formProvider = new FormValueProvider(BindingSource.Form, context.Request.Form, CultureInfo.CurrentCulture);;
compositeValueProvider.Add(formProvider);
}
else
{
compositeValueProvider.Add(bodyProvider);
}
IValueProvider GetProvider(BoundProperty property)
{
if (property.BindingSource == BindingSource.Path)
{
return(routeProvider);
}
else if (property.BindingSource == BindingSource.Query)
{
return(queryProvider);
}
else if (property.BindingSource == BindingSource.Form)
{
return(formProvider);
}
else if (property.BindingSource == BindingSource.Body)
{
return(bodyProvider);
}
return(compositeValueProvider);
}
foreach (var property in requestProperties)
{
var propType = property.Property.PropertyType;
var valueProvider = GetProvider(property);
if (valueProvider != null)
{
var value = valueProvider.GetValue(property.Name);
if (value.FirstValue != null)
{
if (Nullable.GetUnderlyingType(propType) != null)
{
propType = Nullable.GetUnderlyingType(propType);
}
if (propType == typeof(string))
{
property.Property.SetValue(mediatorRequest, value.FirstValue);
}
else if (propType == typeof(bool))
{
property.Property.SetValue(mediatorRequest, Convert.ToBoolean(value.FirstValue));
}
else if (propType == typeof(char))
{
property.Property.SetValue(mediatorRequest, Convert.ToChar(value.FirstValue));
}
else if (propType == typeof(DateTime))
{
property.Property.SetValue(mediatorRequest, Convert.ToDateTime(value.FirstValue));
}
else if (propType == typeof(DateTimeOffset))
{
property.Property.SetValue(mediatorRequest, DateTimeOffset.Parse(value.FirstValue));
}
else if (propType == typeof(TimeSpan))
{
property.Property.SetValue(mediatorRequest, TimeSpan.Parse(value.FirstValue));
}
else if (propType == typeof(Uri))
{
property.Property.SetValue(mediatorRequest, new Uri(value.FirstValue));
}
else if (propType == typeof(Version))
{
property.Property.SetValue(mediatorRequest, new Version(value.FirstValue));
}
else if (propType == typeof(Guid))
{
property.Property.SetValue(mediatorRequest, Guid.Parse(value.FirstValue));
}
else if (propType == typeof(decimal) || propType == typeof(double) || propType == typeof(int) || propType == typeof(uint) ||
propType == typeof(byte) || propType == typeof(sbyte) || propType == typeof(long) || propType == typeof(float) ||
propType == typeof(short) || propType == typeof(ulong) || propType == typeof(ushort))
{
var objValue = JsonSerializer.Deserialize(value.FirstValue, propType, jsonOptions.Value.JsonSerializerOptions);
property.Property.SetValue(mediatorRequest, objValue);
}
else
{
var needsQuotes = bodyProvider.ValueKind == JsonValueKind.String || bodyProvider.ValueKind == null;
var text = needsQuotes ? $"\"{value.FirstValue}\"" : value.FirstValue;
var objValue = JsonSerializer.Deserialize(text, propType, jsonOptions.Value.JsonSerializerOptions);
property.Property.SetValue(mediatorRequest, objValue);
}
}
}
}
return(Task.FromResult(mediatorRequest));
}
