public DefaultObjectValidator(
IValidationExcludeFiltersProvider excludeFilterProvider,
IModelMetadataProvider modelMetadataProvider)
{
_excludeFilterProvider = excludeFilterProvider;
_modelMetadataProvider = modelMetadataProvider;
}
/// <summary>
/// Create a new instance of <see cref="ClientModelValidationContext"/>.
/// </summary>
/// <param name="actionContext">The <see cref="ActionContext"/> for validation.</param>
/// <param name="metadata">The <see cref="ModelMetadata"/> for validation.</param>
/// <param name="metadataProvider">The <see cref="IModelMetadataProvider"/> to be used in validation.</param>
public ClientModelValidationContext(
ActionContext actionContext,
ModelMetadata metadata,
IModelMetadataProvider metadataProvider)
: base(actionContext, metadata, metadataProvider)
{
}
protected BaseController(IModelMetadataProvider modelMetadataProvider, IObjectModelValidator objectValidator)
{
_modelMetadataProvider = modelMetadataProvider;
_objectValidator = objectValidator;
ValidationErrors = new List<ModelFieldErrorDto>();
}
public CustomExceptionFilterAttribute(
IHostingEnvironment hostingEnvironment,
IModelMetadataProvider modelMetadataProvider)
{
_hostingEnvironment = hostingEnvironment;
_modelMetadataProvider = modelMetadataProvider;
}
public ViewDataDictionaryControllerPropertyActivator(IModelMetadataProvider modelMetadataProvider)
{
_modelMetadataProvider = modelMetadataProvider;
_activateActions = new ConcurrentDictionary<Type, PropertyActivator<ControllerContext>[]>();
_getPropertiesToActivate = GetPropertiesToActivate;
}
/// <summary>
/// Creates a new <see cref="ModelExplorer"/>.
/// </summary>
/// <param name="metadataProvider">The <see cref="IModelMetadataProvider"/>.</param>
/// <param name="container">The container <see cref="ModelExplorer"/>.</param>
/// <param name="metadata">The <see cref="ModelMetadata"/>.</param>
/// <param name="modelAccessor">A model accessor function. May be <c>null</c>.</param>
public ModelExplorer(
IModelMetadataProvider metadataProvider,
ModelExplorer container,
ModelMetadata metadata,
Func<object, object> modelAccessor)
{
if (metadataProvider == null)
{
throw new ArgumentNullException(nameof(metadataProvider));
}
if (container == null)
{
throw new ArgumentNullException(nameof(container));
}
if (metadata == null)
{
throw new ArgumentNullException(nameof(metadata));
}
_metadataProvider = metadataProvider;
Container = container;
Metadata = metadata;
_modelAccessor = modelAccessor;
}
/// <summary>
/// Creates a new <see cref="DefaultModelMetadata"/>.
/// </summary>
/// <param name="provider">The <see cref="IModelMetadataProvider"/>.</param>
/// <param name="detailsProvider">The <see cref="ICompositeMetadataDetailsProvider"/>.</param>
/// <param name="details">The <see cref="DefaultMetadataDetails"/>.</param>
public DefaultModelMetadata(
IModelMetadataProvider provider,
ICompositeMetadataDetailsProvider detailsProvider,
DefaultMetadataDetails details)
: base(details.Key)
{
if (provider == null)
{
throw new ArgumentNullException(nameof(provider));
}
if (detailsProvider == null)
{
throw new ArgumentNullException(nameof(detailsProvider));
}
if (details == null)
{
throw new ArgumentNullException(nameof(details));
}
_provider = provider;
_detailsProvider = detailsProvider;
_details = details;
}
/// <summary>
/// Initialises a new instance of <see cref="ModelMetadata"/>.
/// </summary>
/// <param name="provider">The metadata provider.</param>
/// <param name="containerType">The container type.</param>
/// <param name="modelAccessor">The model accessor.</param>
/// <param name="modelType">The model type.</param>
/// <param name="propertyName">The property name.</param>
public ModelMetadata(IModelMetadataProvider provider, Type containerType, Func<object> modelAccessor, Type modelType, string propertyName)
{
_provider = provider;
_containerType = containerType;
_modelAccessor = modelAccessor;
_modelType = modelType;
_propertyName = propertyName;
}
public RequestBuilder()
{
actionMetadataProvider = new ActionMetadataProvider(new Conventions.DefaultActionPathConvention(), new Conventions.DefaultHttpMethodConvention());
modelMetadataProvider = new ModelMetadataProvider();
serviceMetadataProvider = new ServiceMetadataProvider(new Conventions.DefaultServicePathConvention());
Headers = new Dictionary<string, string>();
Values = new Dictionary<string, string>();
}
public TestableHtmlGenerator(IModelMetadataProvider metadataProvider, IUrlHelper urlHelper)
: this(
metadataProvider,
GetOptions(),
urlHelper,
validationAttributes: new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase))
{
}
public TestableHtmlGenerator(IModelMetadataProvider metadataProvider, IUrlHelper urlHelper)
: this(
metadataProvider,
Mock.Of<IScopedInstance<ActionBindingContext>>(),
urlHelper,
validationAttributes: new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase))
{
}
public TestableHtmlGenerator(
IModelMetadataProvider metadataProvider,
IOptions<MvcViewOptions> options,
IUrlHelper urlHelper,
IDictionary<string, object> validationAttributes)
: base(GetAntiForgery(), options, metadataProvider, urlHelper, new CommonTestEncoder())
{
_validationAttributes = validationAttributes;
}
/// <summary>
/// Constructor.
/// </summary>
public AbstractModelBinder(
Type baseType,
IDictionary<Type, IModelBinder> derivedModelBinders,
IModelMetadataProvider modelMetadataProvider)
{
_baseType = baseType;
_derivedModelBinders = derivedModelBinders;
_modelMetadataProvider = modelMetadataProvider;
}
public DefaultControllerActionArgumentBinder(
IModelMetadataProvider modelMetadataProvider,
IObjectModelValidator validator,
IOptions<MvcOptions> optionsAccessor)
{
_modelMetadataProvider = modelMetadataProvider;
_options = optionsAccessor.Options;
_validator = validator;
}
public TestableHtmlGenerator(
IModelMetadataProvider metadataProvider,
IScopedInstance<ActionBindingContext> bindingContextAccessor,
IUrlHelper urlHelper,
IDictionary<string, object> validationAttributes)
: base(GetAntiForgery(), bindingContextAccessor, metadataProvider, urlHelper, new HtmlEncoder())
{
_validationAttributes = validationAttributes;
}
/// <summary>
/// Create a new instance of <see cref="ClientModelValidationContext"/>.
/// </summary>
/// <param name="actionContext">The <see cref="ActionContext"/> for validation.</param>
/// <param name="metadata">The <see cref="ModelMetadata"/> for validation.</param>
/// <param name="metadataProvider">The <see cref="IModelMetadataProvider"/> to be used in validation.</param>
/// <param name="attributes">The attributes dictionary for the HTML tag being rendered.</param>
public ClientModelValidationContext(
ActionContext actionContext,
ModelMetadata metadata,
IModelMetadataProvider metadataProvider,
IDictionary<string, string> attributes)
: base(actionContext, metadata, metadataProvider)
{
Attributes = attributes;
}
private static ModelMetadata GetMetadataFromProvider(Func<object> modelAccessor, Type modelType, string propertyName, Type containerType, IModelMetadataProvider provider)
{
if (containerType != null && !string.IsNullOrWhiteSpace(propertyName))
{
return provider.GetMetadataForProperty(modelAccessor, containerType, propertyName);
}
return provider.GetMetadataForType(modelAccessor, modelType);
}
/// <summary>
/// Creates a new <see cref="ModelExplorer"/>.
/// </summary>
/// <param name="metadataProvider">The <see cref="IModelMetadataProvider"/>.</param>
/// <param name="metadata">The <see cref="ModelMetadata"/>.</param>
/// <param name="model">The model object. May be <c>null</c>.</param>
public ModelExplorer(
[NotNull] IModelMetadataProvider metadataProvider,
[NotNull] ModelMetadata metadata,
object model)
{
_metadataProvider = metadataProvider;
Metadata = metadata;
_model = model;
}
/// <summary>
/// Creates a new <see cref="DefaultModelMetadata"/>.
/// </summary>
/// <param name="provider">The <see cref="IModelMetadataProvider"/>.</param>
/// <param name="detailsProvider">The <see cref="ICompositeMetadataDetailsProvider"/>.</param>
/// <param name="details">The <see cref="DefaultMetadataDetails"/>.</param>
public DefaultModelMetadata(
[NotNull] IModelMetadataProvider provider,
[NotNull] ICompositeMetadataDetailsProvider detailsProvider,
[NotNull] DefaultMetadataDetails details)
: base(details.Key)
{
_provider = provider;
_detailsProvider = detailsProvider;
_details = details;
}
/// <summary>
/// Initializes a new instance of <see cref="DefaultObjectValidator"/>.
/// </summary>
/// <param name="modelMetadataProvider">The <see cref="IModelMetadataProvider"/>.</param>
public DefaultObjectValidator(
IModelMetadataProvider modelMetadataProvider)
{
if (modelMetadataProvider == null)
{
throw new ArgumentNullException(nameof(modelMetadataProvider));
}
_modelMetadataProvider = modelMetadataProvider;
}
/// <summary>
/// Creates a new <see cref="DefaultModelMetadata"/>.
/// </summary>
/// <param name="provider">The <see cref="IModelMetadataProvider"/>.</param>
/// <param name="detailsProvider">The <see cref="ICompositeMetadataDetailsProvider"/>.</param>
/// <param name="cache">The <see cref="DefaultMetadataDetailsCache"/>.</param>
public DefaultModelMetadata(
[NotNull] IModelMetadataProvider provider,
[NotNull] ICompositeMetadataDetailsProvider detailsProvider,
[NotNull] DefaultMetadataDetailsCache cache)
: base(cache.Key)
{
_provider = provider;
_detailsProvider = detailsProvider;
_cache = cache;
}
/// <summary>
/// Create a new instance of <see cref="ModelValidationContext"/>.
/// </summary>
/// <param name="actionContext">The <see cref="ActionContext"/> for validation.</param>
/// <param name="modelMetadata">The <see cref="ModelMetadata"/> for validation.</param>
/// <param name="metadataProvider">The <see cref="IModelMetadataProvider"/> to be used in validation.</param>
/// <param name="container">The model container.</param>
/// <param name="model">The model to be validated.</param>
public ModelValidationContext(
ActionContext actionContext,
ModelMetadata modelMetadata,
IModelMetadataProvider metadataProvider,
object container,
object model)
: base(actionContext, modelMetadata, metadataProvider)
{
Container = container;
Model = model;
}
/// <summary>
/// Creates a new <see cref="ModelExplorer"/>.
/// </summary>
/// <param name="metadataProvider">The <see cref="IModelMetadataProvider"/>.</param>
/// <param name="container">The container <see cref="ModelExplorer"/>.</param>
/// <param name="metadata">The <see cref="ModelMetadata"/>.</param>
/// <param name="modelAccessor">A model accessor function. May be <c>null</c>.</param>
public ModelExplorer(
[NotNull] IModelMetadataProvider metadataProvider,
[NotNull] ModelExplorer container,
[NotNull] ModelMetadata metadata,
Func<object, object> modelAccessor)
{
_metadataProvider = metadataProvider;
Container = container;
Metadata = metadata;
_modelAccessor = modelAccessor;
}
public DefaultActionBindingContextProvider(IModelMetadataProvider modelMetadataProvider,
ICompositeModelBinder compositeModelBinder,
ICompositeValueProviderFactory compositeValueProviderFactory,
IInputFormatterProvider inputFormatterProvider,
IEnumerable<IModelValidatorProvider> validatorProviders)
{
_modelMetadataProvider = modelMetadataProvider;
_compositeModelBinder = compositeModelBinder;
_compositeValueProviderFactory = compositeValueProviderFactory;
_inputFormatterProvider = inputFormatterProvider;
_validatorProviders = validatorProviders;
}
public TestableHtmlGenerator(
IModelMetadataProvider metadataProvider,
IOptions<MvcViewOptions> options,
IUrlHelper urlHelper,
IDictionary<string, object> validationAttributes)
: base(
Mock.Of<IAntiforgery>(),
options,
metadataProvider,
CreateUrlHelperFactory(urlHelper),
new HtmlTestEncoder())
{
_validationAttributes = validationAttributes;
}
/// <summary>
/// Initializes a new instance of the <see cref="RazorPageActivator"/> class.
/// </summary>
public RazorPageActivator(
IModelMetadataProvider metadataProvider,
IUrlHelperFactory urlHelperFactory,
IJsonHelper jsonHelper,
DiagnosticSource diagnosticSource,
HtmlEncoder htmlEncoder,
IModelExpressionProvider modelExpressionProvider)
{
_activationInfo = new ConcurrentDictionary<Type, PageActivationInfo>();
_metadataProvider = metadataProvider;
_urlHelperAccessor = context => urlHelperFactory.GetUrlHelper(context);
_jsonHelperAccessor = context => jsonHelper;
_diagnosticSourceAccessor = context => diagnosticSource;
_htmlEncoderAccessor = context => htmlEncoder;
_modelExpressionProviderAccessor = context => modelExpressionProvider;
}
public static TestModelBinderFactory Create(
IModelMetadataProvider metadataProvider,
params IModelBinderProvider[] providers)
{
if (metadataProvider == null)
{
metadataProvider = TestModelMetadataProvider.CreateDefaultProvider();
}
var options = new TestOptionsManager<MvcOptions>();
foreach (var provider in providers)
{
options.Value.ModelBinderProviders.Add(provider);
}
return new TestModelBinderFactory(metadataProvider, options);
}
public static TestModelBinderFactory CreateDefault(
IModelMetadataProvider metadataProvider,
params IModelBinderProvider[] providers)
{
if (metadataProvider == null)
{
metadataProvider = TestModelMetadataProvider.CreateDefaultProvider();
}
var options = new TestOptionsManager<MvcOptions>();
foreach (var provider in providers)
{
options.Value.ModelBinderProviders.Add(provider);
}
new MvcCoreMvcOptionsSetup(new TestHttpRequestStreamReaderFactory()).Configure(options.Value);
return new TestModelBinderFactory(metadataProvider, options);
}
/// <summary>
/// Initializes a new instance of <see cref="DefaultObjectValidator"/>.
/// </summary>
/// <param name="excludeFilters"><see cref="IExcludeTypeValidationFilter"/>s that determine
/// types to exclude from validation.</param>
/// <param name="modelMetadataProvider">The <see cref="IModelMetadataProvider"/>.</param>
public DefaultObjectValidator(
IList<IExcludeTypeValidationFilter> excludeFilters,
IModelMetadataProvider modelMetadataProvider)
{
if (excludeFilters == null)
{
throw new ArgumentNullException(nameof(excludeFilters));
}
if (modelMetadataProvider == null)
{
throw new ArgumentNullException(nameof(modelMetadataProvider));
}
_modelMetadataProvider = modelMetadataProvider;
_excludeFilters = excludeFilters;
}
/// <summary>
/// Initializes a new instance of <see cref="DefaultObjectValidator"/>.
/// </summary>
/// <param name="modelMetadataProvider">The <see cref="IModelMetadataProvider"/>.</param>
/// <param name="validatorCache">The <see cref="ValidatorCache"/>.</param>
public DefaultObjectValidator(
IModelMetadataProvider modelMetadataProvider,
ValidatorCache validatorCache)
{
if (modelMetadataProvider == null)
{
throw new ArgumentNullException(nameof(modelMetadataProvider));
}
if (validatorCache == null)
{
throw new ArgumentNullException(nameof(validatorCache));
}
_modelMetadataProvider = modelMetadataProvider;
_validatorCache = validatorCache;
}
public ClientModelValidationContextBuilder WithModelMetadataProvider(IModelMetadataProvider modelMetadataProvider)
{
_modelMetadataProvider = modelMetadataProvider;
return(this);
}
public TestableHtmlGenerator(IModelMetadataProvider metadataProvider)
: this(metadataProvider, Mock.Of <IUrlHelper>())
{
}
public TelemetryUIAttribute(IHostingEnvironment hostingEnvironment, IModelMetadataProvider modelMetadataProvider)
{
_hostingEnvironment = hostingEnvironment;
_modelMetadataProvider = modelMetadataProvider;
}
public MessageModelBinder(IModelMetadataProvider metadataProvider, Dictionary <string, IModelBinder> binders)
{
_metadataProvider = metadataProvider;
_binders = binders;
}
public DeviceUnavailableExceptionFilter(IModelMetadataProvider modelMetadataProvider)
{
this.modelMetadataProvider = modelMetadataProvider;
}
public static PageHandlerBinderDelegate CreateHandlerBinder(
ParameterBinder parameterBinder,
IModelMetadataProvider modelMetadataProvider,
IModelBinderFactory modelBinderFactory,
CompiledPageActionDescriptor actionDescriptor,
HandlerMethodDescriptor handler)
{
if (handler.Parameters == null || handler.Parameters.Count == 0)
{
return(NullHandlerBinder);
}
var handlerType = actionDescriptor.HandlerTypeInfo.AsType();
var parameterBindingInfo = new BinderItem[handler.Parameters.Count];
for (var i = 0; i < parameterBindingInfo.Length; i++)
{
var parameter = handler.Parameters[i];
ModelMetadata metadata;
if (modelMetadataProvider is ModelMetadataProvider modelMetadataProviderBase)
{
// The default model metadata provider derives from ModelMetadataProvider
// and can therefore supply information about attributes applied to parameters.
metadata = modelMetadataProviderBase.GetMetadataForParameter(parameter.ParameterInfo);
}
else
{
// For backward compatibility, if there's a custom model metadata provider that
// only implements the older IModelMetadataProvider interface, access the more
// limited metadata information it supplies. In this scenario, validation attributes
// are not supported on parameters.
metadata = modelMetadataProvider.GetMetadataForType(parameter.ParameterType);
}
var binder = modelBinderFactory.CreateBinder(new ModelBinderFactoryContext
{
BindingInfo = parameter.BindingInfo,
Metadata = metadata,
CacheToken = parameter,
});
parameterBindingInfo[i] = new BinderItem(binder, metadata);
}
return(Bind);
async Task Bind(PageContext pageContext, IDictionary <string, object?> arguments)
{
var(success, valueProvider) = await CompositeValueProvider.TryCreateAsync(pageContext, pageContext.ValueProviderFactories);
if (!success)
{
return;
}
for (var i = 0; i < parameterBindingInfo.Length; i++)
{
var parameter = handler.Parameters[i];
var bindingInfo = parameterBindingInfo[i];
var modelMetadata = bindingInfo.ModelMetadata;
if (!modelMetadata.IsBindingAllowed)
{
continue;
}
var result = await parameterBinder.BindModelAsync(
pageContext,
bindingInfo.ModelBinder,
valueProvider !,
parameter,
modelMetadata,
value : null,
container : null); // Parameters do not have containers.
if (result.IsModelSet)
{
arguments[parameter.Name] = result.Model;
}
}
}
}
internal ViewDataDictionary(IModelMetadataProvider metadataProvider)
: this(metadataProvider, new ModelStateDictionary())
{
}
public HomeController(IHostingEnvironment hostingEnvironment, IModelMetadataProvider modelMetadataProvider, SiteConfiguration siteConfiguration) : base(hostingEnvironment, modelMetadataProvider, siteConfiguration)
{
}
public TestTagHelper(IHtmlGenerator generator, IModelMetadataProvider modelMetadataProvider) : base(generator)
{
_modelMetadataProvider = modelMetadataProvider;
}
public ExceptionHandleFilter(IModelMetadataProvider modelMetadataProvider,
ILogger <ExceptionHandleFilter> logger)
{
_logger = logger;
}
public XmlCommentsSchemaFilterTests()
{
_modelMetadataProvider = ModelMetadataHelper.GetDefaultModelMetadataProvider();
_jsonContractResolver = new DefaultContractResolver();
}
public static HtmlHelper <ObjectTemplateModel> GetHtmlHelper(IModelMetadataProvider provider)
{
return(GetHtmlHelper <ObjectTemplateModel>(model: null, provider: provider));
}
public ExceptionsFilter(ILoggerFactory loggerFactory, IHostingEnvironment env, IModelMetadataProvider modelMetadataProvider)
{
_loggerFactory = loggerFactory;
_env = env;
_modelMetadataProvider = modelMetadataProvider;
}
public ClientModelValidationContextBuilder()
{
_actionContext = new ActionContext();
_modelMetadataProvider = new EmptyModelMetadataProvider();
_attributes = new AttributeDictionary();
}
protected ViewDataDictionary(
IModelMetadataProvider metadataProvider,
Type declaredModelType)
: this(metadataProvider, new ModelStateDictionary(), declaredModelType)
{
}
public EntityPropertyEditorTagHelper(IModelMetadataProvider modelMetadataProvider)
{
_modelMetadataProvider = modelMetadataProvider;
}
public ViewDataDictionary(
IModelMetadataProvider metadataProvider,
ModelStateDictionary modelState)
: this(metadataProvider, modelState, declaredModelType : typeof(object))
{
}
public FunctionApiDescriptionProvider(
IOptions <SwaggerDocOptions> functionsOptions,
SwashBuckleStartupConfig startupConfig,
IModelMetadataProvider modelMetadataProvider,
ICompositeMetadataDetailsProvider compositeMetadataDetailsProvider,
IOutputFormatter outputFormatter,
IOptions <HttpOptions> httpOptions)
{
_swaggerDocOptions = functionsOptions.Value;
_modelMetadataProvider = modelMetadataProvider;
_compositeMetadataDetailsProvider = compositeMetadataDetailsProvider;
_outputFormatter = outputFormatter;
var apiDescGroups = new Dictionary <string, List <ApiDescription> >();
var methods = startupConfig.Assembly.GetTypes()
.SelectMany(t => t.GetMethods())
.Where(m => m.GetCustomAttributes(typeof(FunctionNameAttribute), false).Any())
.ToArray();
foreach (var methodInfo in methods)
{
if (!TryGetHttpTrigger(methodInfo, out var triggerAttribute))
{
continue;
}
var functionAttr =
(FunctionNameAttribute)methodInfo.GetCustomAttribute(typeof(FunctionNameAttribute), false);
var apiExplorerSettingsAttribute =
(ApiExplorerSettingsAttribute)methodInfo.GetCustomAttribute(typeof(ApiExplorerSettingsAttribute),
false) ??
(ApiExplorerSettingsAttribute)methodInfo.DeclaringType.GetCustomAttribute(
typeof(ApiExplorerSettingsAttribute), false);
var prefix = string.IsNullOrWhiteSpace(httpOptions.Value.RoutePrefix)
? string.Empty
: $"{httpOptions.Value.RoutePrefix.TrimEnd('/')}/";
string route;
if (_swaggerDocOptions.PrependOperationWithRoutePrefix)
{
var routePart = !string.IsNullOrWhiteSpace(triggerAttribute.Route)
? triggerAttribute.Route
: functionAttr.Name;
route = $"{prefix}{(routePart)}";
}
else
{
route = !string.IsNullOrWhiteSpace(triggerAttribute.Route)
? triggerAttribute.Route
: functionAttr.Name;
}
var routes = new List <(string Route, string RemoveParamName)>();
var regex = new Regex("/\\{(?<paramName>\\w+)\\?\\}$");
var match = regex.Match(route);
var routeParamRemoveRegex = new Regex(":[a-zA-Z]+(\\(.*\\))?");
route = routeParamRemoveRegex.Replace(route, "");
if (match.Success && match.Captures.Count == 1)
{
routes.Add(
(route.Replace(match.Value, "").Replace("//", "/"), match.Groups["paramName"].ToString()));
routes.Add((route.Replace(match.Value, match.Value.Replace("?", "")), ""));
}
else
{
routes.Add((route, ""));
}
var verbs = triggerAttribute.Methods ??
new[] { "get", "post", "delete", "head", "patch", "put", "options" };
for (var index = 0; index < routes.Count; index++)
{
var routeTuple = routes[index];
var apiName = functionAttr.Name + (index == 0 ? "" : $"-{index}");
var items = verbs.Select(verb =>
CreateDescription(methodInfo, routeTuple.Route, index, functionAttr, apiExplorerSettingsAttribute, verb,
triggerAttribute.AuthLevel, routeTuple.RemoveParamName, verbs.Length > 1)).ToArray();
var groupName =
(items.FirstOrDefault()?.ActionDescriptor as ControllerActionDescriptor)?.ControllerName ??
apiName;
if (!apiDescGroups.ContainsKey(groupName))
{
apiDescGroups[groupName] = new List <ApiDescription>();
}
apiDescGroups[groupName].AddRange(items);
}
}
ApiDescriptionGroups =
new ApiDescriptionGroupCollection(
new ReadOnlyCollection <ApiDescriptionGroup>(
apiDescGroups.Select(kv => new ApiDescriptionGroup(kv.Key, kv.Value)).ToList()
), 1);
}
public static Func <PageContext, object, Task> CreatePropertyBinder(
ParameterBinder parameterBinder,
IModelMetadataProvider modelMetadataProvider,
IModelBinderFactory modelBinderFactory,
CompiledPageActionDescriptor actionDescriptor)
{
if (parameterBinder == null)
{
throw new ArgumentNullException(nameof(parameterBinder));
}
if (actionDescriptor == null)
{
throw new ArgumentNullException(nameof(actionDescriptor));
}
var properties = actionDescriptor.BoundProperties;
if (properties == null || properties.Count == 0)
{
return(NullPropertyBinder);
}
var handlerType = actionDescriptor.HandlerTypeInfo.AsType();
var propertyBindingInfo = new BinderItem[properties.Count];
for (var i = 0; i < properties.Count; i++)
{
var property = properties[i];
var metadata = modelMetadataProvider.GetMetadataForProperty(handlerType, property.Name);
var binder = modelBinderFactory.CreateBinder(new ModelBinderFactoryContext
{
BindingInfo = property.BindingInfo,
Metadata = metadata,
CacheToken = property,
});
propertyBindingInfo[i] = new BinderItem(binder, metadata);
}
return(Bind);
async Task Bind(PageContext pageContext, object instance)
{
var(success, valueProvider) = await CompositeValueProvider.TryCreateAsync(pageContext, pageContext.ValueProviderFactories);
if (!success)
{
return;
}
for (var i = 0; i < properties.Count; i++)
{
var property = properties[i];
var bindingInfo = propertyBindingInfo[i];
var modelMetadata = bindingInfo.ModelMetadata;
if (!modelMetadata.IsBindingAllowed)
{
continue;
}
var result = await parameterBinder.BindModelAsync(
pageContext,
bindingInfo.ModelBinder,
valueProvider !,
property,
modelMetadata,
value : null,
container : instance);
if (result.IsModelSet)
{
PropertyValueSetter.SetValue(bindingInfo.ModelMetadata, instance, result.Model);
}
}
}
}
public TestViewDataDictionary(IModelMetadataProvider modelMetadataProvider,
ModelStateDictionary modelState)
: base(modelMetadataProvider, modelState)
{
}
public MyModelBinder(IModelMetadataProvider modelMetadataProvider, IModelBinderFactory modelBinderFactory)
{
_modelMetadataProvider = modelMetadataProvider;
_modelBinderFactory = modelBinderFactory;
}
public ControllerExceptionFilterAttribute(ITempDataDictionaryFactory tempDataDictionaryFactory,
IModelMetadataProvider modelMetadataProvider)
{
_tempDataDictionaryFactory = tempDataDictionaryFactory;
_modelMetadataProvider = modelMetadataProvider;
}
public CustomizedExceptionFilterAttribute(IHostingEnvironment hostingEnvironment, IModelMetadataProvider modelMetadataProvider)
{
_hostingEnvironment = hostingEnvironment;
_modelMetadataProvider = modelMetadataProvider;
}
public CustomExceptionFilterAttribute(ILogger <CustomExceptionFilterAttribute> logger
, IModelMetadataProvider modelMetadataProvider)
{
this._modelMetadataProvider = modelMetadataProvider;
this._logger = logger;
}
/// <summary>
/// Initializes a new instance of <see cref="VersionedApiDescriptionProvider"/> class.
/// </summary>
/// <param name="groupNameFormatter">The <see cref="IApiVersionGroupNameFormatter">formatter</see> used to get group names for API versions.</param>
/// <param name="metadadataProvider">The <see cref="IModelMetadataProvider">provider</see> used to retrieve model metadata.</param>
public VersionedApiDescriptionProvider(IApiVersionGroupNameFormatter groupNameFormatter, IModelMetadataProvider metadadataProvider)
{
Arg.NotNull(groupNameFormatter, nameof(groupNameFormatter));
Arg.NotNull(metadadataProvider, nameof(metadadataProvider));
GroupNameFormatter = groupNameFormatter;
MetadadataProvider = metadadataProvider;
}
public string?GetDisplayName(IModelMetadataProvider modelMetadataProvider)
{
var modelMetadata =
PropertyPath.Count > 0 ?
modelMetadataProvider.GetMetadataForProperty(PropertyPath.Count > 1 ? PropertyPath[^ 2].PropertyType : ItemType, PropertyPath[^ 1].Name) :
/// <summary> /// SwaggerApiDescriptionProvider ctor /// </summary> /// <param name="metadadataProvider"></param> public SwaggerApiDescriptionProvider(IModelMetadataProvider metadadataProvider) =>
public static HtmlHelper <TModel> GetHtmlHelper <TModel>(IModelMetadataProvider provider)
{
return(GetHtmlHelper <TModel>(model: default(TModel), provider: provider));
}
public CustomPropertiesDictionaryModelBinder(IModelMetadataProvider modelMetadataProvider, IModelBinderFactory modelBinderFactory)
{
_modelMetadataProvider = modelMetadataProvider;
_modelBinderFactory = modelBinderFactory;
}
public SQADPlanXlsSerializer(IExportHelpersRepository staticValuesResolver, IModelMetadataProvider modelMetadataProvider
, bool isExportJsonToXls = false)
: this(new DefaultSheetResolver(), new DefaultColumnResolver(modelMetadataProvider), staticValuesResolver, isExportJsonToXls)
{
}
