public static ModelMetadata ForType(Type modelType)
{
var mockModelMetadataProvider = new Mock <IModelMetadataProvider>();
var mockCompositeMetadataDetailsProvider = new Mock <ICompositeMetadataDetailsProvider>();
var defaultMetadataDetails = new DefaultMetadataDetails(ModelMetadataIdentity.ForType(modelType), ModelAttributes.GetAttributesForType(typeof(List <object>)));
return(new DefaultModelMetadata(mockModelMetadataProvider.Object, mockCompositeMetadataDetailsProvider.Object, defaultMetadataDetails));
}
public static DefaultModelMetadata CreateModelMetadata <T>()
{
var metadataDetailProvider = new Mock <ICompositeMetadataDetailsProvider>().Object;
var modelMetadataProvider = new DefaultModelMetadataProvider(metadataDetailProvider);
var details = new DefaultMetadataDetails(ModelMetadataIdentity.ForType(typeof(T)), ModelAttributes.GetAttributesForType(typeof(T)));
return(new DefaultModelMetadata(modelMetadataProvider, metadataDetailProvider, details));
}
protected override ModelMetadata CreateModelMetadata(DefaultMetadataDetails entry)
{
if (typeof(Lite <Entity>).IsAssignableFrom(entry.Key.ModelType) ||
typeof(IModifiableEntity).IsAssignableFrom(entry.Key.ModelType))
{
return(new SignumModelMetadata(this, this.DetailsProvider, entry));
}
return(base.CreateModelMetadata(entry));
}
/// <inheritdoc />
protected override ModelMetadata CreateModelMetadata(DefaultMetadataDetails entry)
{
var metadata = (DefaultModelMetadata)base.CreateModelMetadata(entry);
if (metadata.ValidationMetadata.IsRequired == true)
{
metadata.ValidationMetadata.PropertyValidationFilter = _jsonApiValidationFilter;
}
return(metadata);
}
public void CreateModelMetadata_NullContainerType_DoesNotSetDisplayName()
{
DefaultMetadataDetails metaDetails = new DefaultMetadataDetails(
new ModelMetadataIdentity(), ModelAttributes.GetAttributesForType(typeof(RoleView)));
ICompositeMetadataDetailsProvider details = Substitute.For <ICompositeMetadataDetailsProvider>();
DisplayNameMetadataProviderProxy provider = new DisplayNameMetadataProviderProxy(details);
String actual = provider.BaseCreateModelMetadata(metaDetails).DisplayName;
Assert.Null(actual);
}
private static DefaultMetadataDetails CreateMetadataDetails(ParameterSpecification parameterSpecification, ActionExecutionModel containerModel)
{
if (parameterSpecification == null)
{
throw new ArgumentNullException(nameof(parameterSpecification));
}
if (containerModel == null)
{
throw new ArgumentNullException(nameof(containerModel));
}
#pragma warning disable CS0618 // Type or member is obsolete
var parameterMetadataIdentity = ModelMetadataIdentity.ForProperty(parameterSpecification.Type, parameterSpecification.Key, containerModel.GetType());
#pragma warning restore CS0618 // Type or member is obsolete
var parameterAttributes = ModelAttributes.GetAttributesForProperty(containerModel.GetType(), nullPropertyInfo, parameterSpecification.Type);
var propertyMetadataDetails = new DefaultMetadataDetails(
parameterMetadataIdentity,
parameterAttributes)
{
PropertyGetter = thisModel => GetParameterValue((ActionExecutionModel)thisModel, parameterSpecification),
PropertySetter = (thisModel, value) => SetParameterValue((ActionExecutionModel)thisModel, parameterSpecification, value),
ValidationMetadata = new ValidationMetadata
{
IsRequired = parameterSpecification.IsRequired
},
DisplayMetadata = new DisplayMetadata()
};
var dataTypeAttribute = parameterSpecification.ValidationAttributes.OfType <DataTypeAttribute>().FirstOrDefault();
if (dataTypeAttribute != null)
{
propertyMetadataDetails.DisplayMetadata.DataTypeName = dataTypeAttribute.GetDataTypeName();
}
foreach (var attribute in parameterSpecification.ValidationAttributes)
{
propertyMetadataDetails.ValidationMetadata.ValidatorMetadata.Add(attribute);
}
foreach (var attribute in parameterSpecification.Type.GetCustomAttributes <ValidationAttribute>(true))
{
propertyMetadataDetails.ValidationMetadata.ValidatorMetadata.Add(attribute);
}
if (propertyMetadataDetails.ValidationMetadata.ValidatorMetadata.Count > 0 || typeof(IValidatableObject).IsAssignableFrom(parameterSpecification.Type))
{
propertyMetadataDetails.ValidationMetadata.HasValidators = true;
}
return(propertyMetadataDetails);
}
private ModelMetadata GetRequiredMetadata()
{
var details = new DefaultMetadataDetails(ModelMetadataIdentity.ForType(typeof(string)),
ModelAttributes.GetAttributesForType(typeof(string)))
{
ValidationMetadata = new ValidationMetadata {
IsRequired = true
}
};
return(new DefaultModelMetadata(new EmptyModelMetadataProvider(), new DefaultCompositeMetadataDetailsProvider(new IMetadataDetailsProvider[0]), details));
}
public void CreateModelMetadata_SetsDisplayName()
{
DefaultMetadataDetails metaDetails = new DefaultMetadataDetails(
ModelMetadataIdentity.ForProperty(typeof(String), "Title", typeof(RoleView)), ModelAttributes.GetAttributesForType(typeof(RoleView)));
ICompositeMetadataDetailsProvider details = Substitute.For <ICompositeMetadataDetailsProvider>();
DisplayNameMetadataProviderProxy provider = new DisplayNameMetadataProviderProxy(details);
String expected = ResourceProvider.GetPropertyTitle(typeof(RoleView), "Title");
String actual = provider.BaseCreateModelMetadata(metaDetails).DisplayName;
Assert.Equal(expected, actual);
}
private void RecreateMetadata(ModelMetadataIdentity key, DefaultMetadataDetails details)
{
var validationContext = new ValidationMetadataProviderContext(key, details.ModelAttributes);
var displayContext = new DisplayMetadataProviderContext(key, details.ModelAttributes);
var bindingContext = new BindingMetadataProviderContext(key, details.ModelAttributes);
DetailsProvider.CreateValidationMetadata(validationContext);
DetailsProvider.CreateDisplayMetadata(displayContext);
DetailsProvider.CreateBindingMetadata(bindingContext);
details.ValidationMetadata = validationContext.ValidationMetadata;
details.DisplayMetadata = displayContext.DisplayMetadata;
details.BindingMetadata = bindingContext.BindingMetadata;
}
public override ModelMetadata GetMetadataForType(Type modelType)
{
if (modelType != typeof(TestModel))
{
return(base.GetMetadataForType(modelType));
}
var key = ModelMetadataIdentity.ForType(modelType);
DefaultMetadataDetails details = CreateTypeDetails(key);
RecreateMetadata(key, details);
return(CreateModelMetadata(details));
}
private void ExpandParam(IList <ApiParameterDescription> apds, string name, ApiParameterDescription apdParent, Type modelType)
{
var pis = modelType.GetProperties();
foreach (var pi in pis)
{
var itemType = GetEnumerableElementType(pi.PropertyType, out bool isEnumerable);
var isCombType = IsComboType(pi.PropertyType);
if (isEnumerable && !IsBaseType(itemType))
{
ExpandParam(apds, $"{name}.{pi.Name}[0]", apdParent, itemType);
}
else if (isCombType)
{
ExpandParam(apds, $"{name}.{pi.Name}", apdParent, pi.PropertyType);
}
else
{
//var dmd = new DefaultMetadataDetails(
// ModelMetadataIdentity.ForProperty(pi.PropertyType, pi.Name, modelType),
// new ModelAttributes(new object[0]))
//{
// ValidationMetadata = new ValidationMetadata()
// {
// IsRequired = false
// }
//};
var dmd = new DefaultMetadataDetails(
ModelMetadataIdentity.ForProperty(pi.PropertyType, pi.Name, modelType),
null)
{
ValidationMetadata = new ValidationMetadata()
{
IsRequired = false
}
};
var md = new DefaultModelMetadata(_mmp, _cmdp, dmd);
var apd = new ApiParameterDescription
{
Type = pi.PropertyType,
ModelMetadata = md,
Name = $"{name}.{pi.Name}",
RouteInfo = apdParent.RouteInfo,
Source = apdParent.Source
};
apds.Add(apd);
}
}
}
protected virtual EntityMetadataDetails ConvertMetadataDetails(DefaultMetadataDetails details)
{
var entityDetails = new EntityMetadataDetails(details.Key, details.ModelAttributes);
entityDetails.BindingMetadata = details.BindingMetadata;
entityDetails.ContainerMetadata = details.ContainerMetadata;
entityDetails.DisplayMetadata = details.DisplayMetadata;
entityDetails.PropertyGetter = details.PropertyGetter;
entityDetails.PropertySetter = details.PropertySetter;
entityDetails.Properties = entityDetails.Properties;
entityDetails.ValidationMetadata = details.ValidationMetadata;
return(entityDetails);
}
private static DefaultMetadataDetails CreateMetadataDetails(ActionExecutionModel model)
{
if (model == null)
{
throw new ArgumentNullException(nameof(model));
}
var modelMetadataIdentity = ModelMetadataIdentity.ForType(model.GetType());
var modelAttributes = ModelAttributes.GetAttributesForType(model.GetType());
var modelMetadataDetails = new DefaultMetadataDetails(modelMetadataIdentity, modelAttributes);
return(modelMetadataDetails);
}
public static IEnumerable <KeyValuePair <Type, ModelMetadata> > CreateMetadataForTypes(params Type[] types)
{
var provider = new EmptyModelMetadataProvider();
var detailsProvider = new DefaultCompositeMetadataDetailsProvider(
Enumerable.Empty <IMetadataDetailsProvider>());
foreach (var type in types)
{
var key = ModelMetadataIdentity.ForType(type);
var cache = new DefaultMetadataDetails(key, ModelAttributes.GetAttributesForType(type));
var metadata = new DefaultModelMetadata(provider, detailsProvider, cache);
Xunit.Assert.Equal(type, metadata.ModelType);
Xunit.Assert.Null(metadata.PropertyName);
Xunit.Assert.Null(metadata.ContainerType);
yield return(KeyValuePair.Create <Type, ModelMetadata>(type, metadata));
}
}
public void GetBinderReturnsNullForUnsupportedTypeTest()
{
var context = Substitute.For <ModelBinderProviderContext>();
var provider = Substitute.For <IModelMetadataProvider>();
var detailsProvider = Substitute.For <ICompositeMetadataDetailsProvider>();
var key = ModelMetadataIdentity.ForType(typeof(string));
IEnumerable <object> typeAttributes = new List <object>();
var attributes = new ModelAttributes(typeAttributes);
var details = new DefaultMetadataDetails(key, attributes);
var metadata = new DefaultModelMetadata(provider, detailsProvider, details);
context.Metadata.Returns(metadata);
var sut = new ProfileFilterModelBinderProvider();
var actual = sut.GetBinder(context);
actual.Should().BeNull();
}
public void GetFormattedWeek_ReturnsExpectedFormattedValue(int year, int month, int day, string expectedOutput)
{
// Arrange
var detailsProvider = new DefaultCompositeMetadataDetailsProvider(
Enumerable.Empty <IMetadataDetailsProvider>());
var key = ModelMetadataIdentity.ForType(typeof(DateTime));
var cache = new DefaultMetadataDetails(key, new ModelAttributes(new object[0], null, null));
var provider = new EmptyModelMetadataProvider();
var metadata = new DefaultModelMetadata(provider, detailsProvider, cache);
var model = new DateTime(year, month, day);
var modelExplorer = new ModelExplorer(provider, metadata, model);
// Act
var formattedValue = FormatWeekHelper.GetFormattedWeek(modelExplorer);
// Assert
Assert.Equal(expectedOutput, formattedValue);
}
private DefaultMetadataDetails CreateSinglePropertyDetails(ModelMetadataIdentity propertyKey, PropertyInfo property)
{
var containerType = propertyKey.ContainerType;
var attributes = ModelAttributes.GetAttributesForProperty(containerType, property, propertyKey.ModelType);
var propertyEntry = new DefaultMetadataDetails(propertyKey, attributes);
if (property.CanRead && property.GetMethod?.IsPublic == true)
{
propertyEntry.PropertyGetter = property.MakeFastGetter <object, object>();
}
if (property.CanWrite && property.SetMethod?.IsPublic == true && !containerType.IsValueType)
{
propertyEntry.PropertySetter = property.MakeFastSetter <object, object>();
}
return(propertyEntry);
}
public CustomModelMetadata(ICustomModelMetadataProviderSingleton provider, ICompositeMetadataDetailsProvider detailsProvider, DefaultMetadataDetails details, DefaultModelBindingMessageProvider modelBindingMessageProvider)
: base(provider, detailsProvider, details, modelBindingMessageProvider)
{
_customProvider = provider;
}
public ModelMetadata BaseCreateModelMetadata(DefaultMetadataDetails entry)
{
return(CreateModelMetadata(entry));
}
public CustomModelMetadata(ICustomModelMetadataProviderSingleton provider, ICompositeMetadataDetailsProvider detailsProvider, DefaultMetadataDetails details)
: base(provider, detailsProvider, details)
{
_customProvider = provider;
}
protected override ModelMetadata CreateModelMetadata(DefaultMetadataDetails entry)
{
return(new CustomModelMetadata(this, DetailsProvider, entry, ModelBindingMessageProvider));
}
protected override ModelMetadata CreateModelMetadata(DefaultMetadataDetails entry)
{
return(new LocalizedModelMetadata(this, DetailsProvider, entry));
}
public ModelMetadataCacheEntry(ModelMetadata metadata, DefaultMetadataDetails details)
{
Metadata = metadata;
Details = details;
}
public SignumModelMetadata(IModelMetadataProvider provider, ICompositeMetadataDetailsProvider detailsProvider, DefaultMetadataDetails details) :
base(provider, detailsProvider, details)
{
}
public LocalizedModelMetadata(IModelMetadataProvider provider, ICompositeMetadataDetailsProvider detailsProvider, DefaultMetadataDetails details)
: base(provider, detailsProvider, details)
{
if (ContainerType == null)
{
LocalizedDisplayName = base.DisplayName;
}
else
{
LocalizedDisplayName = ResourceProvider.GetPropertyTitle(ContainerType, PropertyName);
}
}
