protected BaseController(IModelMetadataProvider modelMetadataProvider, IObjectModelValidator objectValidator)
{
_modelMetadataProvider = modelMetadataProvider;
_objectValidator = objectValidator;
ValidationErrors = new List<ModelFieldErrorDto>();
}
private ParameterBinder(
IModelMetadataProvider modelMetadataProvider,
IModelBinderFactory modelBinderFactory,
IModelValidatorProvider validatorProvider,
IObjectModelValidator validatorForBackCompatOnly,
ILoggerFactory loggerFactory)
{
if (modelMetadataProvider == null)
{
throw new ArgumentNullException(nameof(modelMetadataProvider));
}
if (modelBinderFactory == null)
{
throw new ArgumentNullException(nameof(modelBinderFactory));
}
if (loggerFactory == null)
{
throw new ArgumentNullException(nameof(loggerFactory));
}
_modelMetadataProvider = modelMetadataProvider;
_modelBinderFactory = modelBinderFactory;
_validatorProvider = validatorProvider;
_validatorForBackCompatOnly = validatorForBackCompatOnly;
_validatorCache = new ValidatorCache();
Logger = loggerFactory.CreateLogger(GetType());
}
/// <summary>
/// Updates the specified <paramref name="model"/> instance using the specified <paramref name="modelBinder"/>
/// and the specified <paramref name="valueProvider"/> and executes validation using the specified
/// <paramref name="validatorProvider"/>.
/// </summary>
/// <typeparam name="TModel">The type of the model object.</typeparam>
/// <param name="model">The model instance to update and validate.</param>
/// <param name="prefix">The prefix to use when looking up values in the <paramref name="valueProvider"/>.
/// </param>
/// <param name="httpContext">The <see cref="HttpContext"/> for the current executing request.</param>
/// <param name="modelState">The <see cref="ModelStateDictionary"/> used for maintaining state and
/// results of model-binding validation.</param>
/// <param name="metadataProvider">The provider used for reading metadata for the model type.</param>
/// <param name="modelBinder">The <see cref="IModelBinder"/> used for binding.</param>
/// <param name="valueProvider">The <see cref="IValueProvider"/> used for looking up values.</param>
/// <param name="inputFormatters">
/// The set of <see cref="IInputFormatter"/> instances for deserializing the body.
/// </param>
/// <param name="objectModelValidator">The <see cref="IObjectModelValidator"/> used for validating the
/// bound values.</param>
/// <param name="validatorProvider">The <see cref="IModelValidatorProvider"/> used for executing validation
/// on the model instance.</param>
/// <param name="predicate">A predicate which can be used to
/// filter properties(for inclusion/exclusion) at runtime.</param>
/// <returns>A <see cref="Task"/> that on completion returns <c>true</c> if the update is successful</returns>
public static Task <bool> TryUpdateModelAsync <TModel>(
[NotNull] TModel model,
[NotNull] string prefix,
[NotNull] HttpContext httpContext,
[NotNull] ModelStateDictionary modelState,
[NotNull] IModelMetadataProvider metadataProvider,
[NotNull] IModelBinder modelBinder,
[NotNull] IValueProvider valueProvider,
[NotNull] IList <IInputFormatter> inputFormatters,
[NotNull] IObjectModelValidator objectModelValidator,
[NotNull] IModelValidatorProvider validatorProvider,
[NotNull] Func <ModelBindingContext, string, bool> predicate)
where TModel : class
{
return(TryUpdateModelAsync(
model,
typeof(TModel),
prefix,
httpContext,
modelState,
metadataProvider,
modelBinder,
valueProvider,
inputFormatters,
objectModelValidator,
validatorProvider,
predicate: predicate));
}
/// <summary>
/// Updates the specified <paramref name="model"/> instance using the specified <paramref name="modelBinder"/>
/// and the specified <paramref name="valueProvider"/> and executes validation using the specified
/// <paramref name="validatorProvider"/>.
/// </summary>
/// <typeparam name="TModel">The type of the model object.</typeparam>
/// <param name="model">The model instance to update and validate.</param>
/// <param name="prefix">The prefix to use when looking up values in the <paramref name="valueProvider"/>.
/// </param>
/// <param name="httpContext">The <see cref="HttpContext"/> for the current executing request.</param>
/// <param name="modelState">The <see cref="ModelStateDictionary"/> used for maintaining state and
/// results of model-binding validation.</param>
/// <param name="metadataProvider">The provider used for reading metadata for the model type.</param>
/// <param name="modelBinder">The <see cref="IModelBinder"/> used for binding.</param>
/// <param name="valueProvider">The <see cref="IValueProvider"/> used for looking up values.</param>
/// <param name="inputFormatters">
/// The set of <see cref="IInputFormatter"/> instances for deserializing the body.
/// </param>
/// <param name="objectModelValidator">The <see cref="IObjectModelValidator"/> used for validating the
/// bound values.</param>
/// <param name="validatorProvider">The <see cref="IModelValidatorProvider"/> used for executing validation
/// on the model
/// instance.</param>
/// <param name="includeExpressions">Expression(s) which represent top level properties
/// which need to be included for the current model.</param>
/// <returns>A <see cref="Task"/> that on completion returns <c>true</c> if the update is successful</returns>
public static Task <bool> TryUpdateModelAsync <TModel>(
[NotNull] TModel model,
[NotNull] string prefix,
[NotNull] HttpContext httpContext,
[NotNull] ModelStateDictionary modelState,
[NotNull] IModelMetadataProvider metadataProvider,
[NotNull] IModelBinder modelBinder,
[NotNull] IValueProvider valueProvider,
[NotNull] IList <IInputFormatter> inputFormatters,
[NotNull] IObjectModelValidator objectModelValidator,
[NotNull] IModelValidatorProvider validatorProvider,
[NotNull] params Expression <Func <TModel, object> >[] includeExpressions)
where TModel : class
{
var includeExpression = GetIncludePredicateExpression(prefix, includeExpressions);
var predicate = includeExpression.Compile();
return(TryUpdateModelAsync(
model,
prefix,
httpContext,
modelState,
metadataProvider,
modelBinder,
valueProvider,
inputFormatters,
objectModelValidator,
validatorProvider,
predicate: predicate));
}
/// <summary>
/// Updates the specified <paramref name="model"/> instance using the specified <paramref name="modelBinder"/>
/// and the specified <paramref name="valueProvider"/> and executes validation using the specified
/// <paramref name="validatorProvider"/>.
/// </summary>
/// <typeparam name="TModel">The type of the model object.</typeparam>
/// <param name="model">The model instance to update and validate.</param>
/// <param name="prefix">The prefix to use when looking up values in the <paramref name="valueProvider"/>.
/// </param>
/// <param name="httpContext">The <see cref="HttpContext"/> for the current executing request.</param>
/// <param name="modelState">The <see cref="ModelStateDictionary"/> used for maintaining state and
/// results of model-binding validation.</param>
/// <param name="metadataProvider">The provider used for reading metadata for the model type.</param>
/// <param name="modelBinder">The <see cref="IModelBinder"/> used for binding.</param>
/// <param name="valueProvider">The <see cref="IValueProvider"/> used for looking up values.</param>
/// <param name="inputFormatters">
/// The set of <see cref="IInputFormatter"/> instances for deserializing the body.
/// </param>
/// <param name="objectModelValidator">The <see cref="IObjectModelValidator"/> used for validating the
/// bound values.</param>
/// <param name="validatorProvider">The <see cref="IModelValidatorProvider"/> used for executing validation
/// on the model instance.</param>
/// <returns>A <see cref="Task"/> that on completion returns <c>true</c> if the update is successful</returns>
public static Task <bool> TryUpdateModelAsync <TModel>(
[NotNull] TModel model,
[NotNull] string prefix,
[NotNull] HttpContext httpContext,
[NotNull] ModelStateDictionary modelState,
[NotNull] IModelMetadataProvider metadataProvider,
[NotNull] IModelBinder modelBinder,
[NotNull] IValueProvider valueProvider,
[NotNull] IList <IInputFormatter> inputFormatters,
[NotNull] IObjectModelValidator objectModelValidator,
[NotNull] IModelValidatorProvider validatorProvider)
where TModel : class
{
// Includes everything by default.
return(TryUpdateModelAsync(
model,
prefix,
httpContext,
modelState,
metadataProvider,
modelBinder,
valueProvider,
inputFormatters,
objectModelValidator,
validatorProvider,
predicate: (context, propertyName) => true));
}
public ParameterBinder(
IModelMetadataProvider modelMetadataProvider,
IModelBinderFactory modelBinderFactory,
IObjectModelValidator validator)
: this(modelMetadataProvider, modelBinderFactory, validator, NullLoggerFactory.Instance)
{
}
/// <summary>
/// Initializes a new instance of <see cref="ParameterBinder"/>.
/// </summary>
/// <param name="modelMetadataProvider">The <see cref="IModelMetadataProvider"/>.</param>
/// <param name="modelBinderFactory">The <see cref="IModelBinderFactory"/>.</param>
/// <param name="validator">The <see cref="IObjectModelValidator"/>.</param>
/// <param name="loggerFactory">The <see cref="ILoggerFactory"/>.</param>
public ParameterBinder(
IModelMetadataProvider modelMetadataProvider,
IModelBinderFactory modelBinderFactory,
IObjectModelValidator validator,
ILoggerFactory loggerFactory)
{
if (modelMetadataProvider == null)
{
throw new ArgumentNullException(nameof(modelMetadataProvider));
}
if (modelBinderFactory == null)
{
throw new ArgumentNullException(nameof(modelBinderFactory));
}
if (validator == null)
{
throw new ArgumentNullException(nameof(validator));
}
if (loggerFactory == null)
{
throw new ArgumentNullException(nameof(loggerFactory));
}
_modelMetadataProvider = modelMetadataProvider;
_modelBinderFactory = modelBinderFactory;
_objectModelValidator = validator;
Logger = loggerFactory.CreateLogger(GetType());
}
/// <summary>
/// Updates the specified <paramref name="model"/> instance using the specified <paramref name="modelBinderFactory"/>
/// and the specified <paramref name="valueProvider"/> and executes validation using the specified
/// <paramref name="objectModelValidator"/>.
/// </summary>
/// <typeparam name="TModel">The type of the model object.</typeparam>
/// <param name="model">The model instance to update and validate.</param>
/// <param name="prefix">The prefix to use when looking up values in the <paramref name="valueProvider"/>.
/// </param>
/// <param name="actionContext">The <see cref="ActionContext"/> for the current executing request.</param>
/// <param name="metadataProvider">The provider used for reading metadata for the model type.</param>
/// <param name="modelBinderFactory">The <see cref="IModelBinderFactory"/> used for binding.</param>
/// <param name="valueProvider">The <see cref="IValueProvider"/> used for looking up values.</param>
/// <param name="objectModelValidator">The <see cref="IObjectModelValidator"/> used for validating the
/// bound values.</param>
/// <param name="includeExpressions">Expression(s) which represent top level properties
/// which need to be included for the current model.</param>
/// <returns>A <see cref="Task"/> that on completion returns <c>true</c> if the update is successful</returns>
public static Task <bool> TryUpdateModelAsync <TModel>(
TModel model,
string prefix,
ActionContext actionContext,
IModelMetadataProvider metadataProvider,
IModelBinderFactory modelBinderFactory,
IValueProvider valueProvider,
IObjectModelValidator objectModelValidator,
params Expression <Func <TModel, object> >[] includeExpressions)
where TModel : class
{
if (includeExpressions == null)
{
throw new ArgumentNullException(nameof(includeExpressions));
}
var expression = GetPropertyFilterExpression(includeExpressions);
var propertyFilter = expression.Compile();
return(TryUpdateModelAsync(
model,
prefix,
actionContext,
metadataProvider,
modelBinderFactory,
valueProvider,
objectModelValidator,
propertyFilter));
}
public DefaultControllerActionArgumentBinder(
IModelMetadataProvider modelMetadataProvider,
IObjectModelValidator validator)
{
_modelMetadataProvider = modelMetadataProvider;
_validator = validator;
}
/// <summary>
/// Updates the specified <paramref name="model"/> instance using the specified <paramref name="modelBinder"/>
/// and the specified <paramref name="valueProvider"/> and executes validation using the specified
/// <paramref name="validatorProvider"/>.
/// </summary>
/// <param name="model">The model instance to update and validate.</param>
/// <param name="modelType">The type of model instance to update and validate.</param>
/// <param name="prefix">The prefix to use when looking up values in the <paramref name="valueProvider"/>.
/// </param>
/// <param name="httpContext">The <see cref="HttpContext"/> for the current executing request.</param>
/// <param name="modelState">The <see cref="ModelStateDictionary"/> used for maintaining state and
/// results of model-binding validation.</param>
/// <param name="metadataProvider">The provider used for reading metadata for the model type.</param>
/// <param name="modelBinder">The <see cref="IModelBinder"/> used for binding.</param>
/// <param name="valueProvider">The <see cref="IValueProvider"/> used for looking up values.</param>
/// <param name="objectModelValidator">The <see cref="IObjectModelValidator"/> used for validating the
/// bound values.</param>
/// <param name="validatorProvider">The <see cref="IModelValidatorProvider"/> used for executing validation
/// on the model instance.</param>
/// <returns>A <see cref="Task"/> that on completion returns <c>true</c> if the update is successful</returns>
public static Task <bool> TryUpdateModelAsync(
[NotNull] object model,
[NotNull] Type modelType,
[NotNull] string prefix,
[NotNull] HttpContext httpContext,
[NotNull] ModelStateDictionary modelState,
[NotNull] IModelMetadataProvider metadataProvider,
[NotNull] IModelBinder modelBinder,
[NotNull] IValueProvider valueProvider,
[NotNull] IObjectModelValidator objectModelValidator,
[NotNull] IModelValidatorProvider validatorProvider)
{
// Includes everything by default.
return(TryUpdateModelAsync(
model,
modelType,
prefix,
httpContext,
modelState,
metadataProvider,
modelBinder,
valueProvider,
objectModelValidator,
validatorProvider,
predicate: (context, propertyName) => true));
}
/// <summary>
/// Updates the specified <paramref name="model"/> instance using the specified <paramref name="modelBinder"/>
/// and the specified <paramref name="valueProvider"/> and executes validation using the specified
/// <paramref name="validatorProvider"/>.
/// </summary>
/// <param name="model">The model instance to update and validate.</param>
/// <param name="modelType">The type of model instance to update and validate.</param>
/// <param name="prefix">The prefix to use when looking up values in the <paramref name="valueProvider"/>.
/// </param>
/// <param name="httpContext">The <see cref="HttpContext"/> for the current executing request.</param>
/// <param name="modelState">The <see cref="ModelStateDictionary"/> used for maintaining state and
/// results of model-binding validation.</param>
/// <param name="metadataProvider">The provider used for reading metadata for the model type.</param>
/// <param name="modelBinder">The <see cref="IModelBinder"/> used for binding.</param>
/// <param name="valueProvider">The <see cref="IValueProvider"/> used for looking up values.</param>
/// <param name="objectModelValidator">The <see cref="IObjectModelValidator"/> used for validating the
/// bound values.</param>
/// <param name="validatorProvider">The <see cref="IModelValidatorProvider"/> used for executing validation
/// on the model instance.</param>
/// <param name="predicate">A predicate which can be used to
/// filter properties(for inclusion/exclusion) at runtime.</param>
/// <returns>A <see cref="Task"/> that on completion returns <c>true</c> if the update is successful</returns>
public static async Task <bool> TryUpdateModelAsync(
[NotNull] object model,
[NotNull] Type modelType,
[NotNull] string prefix,
[NotNull] HttpContext httpContext,
[NotNull] ModelStateDictionary modelState,
[NotNull] IModelMetadataProvider metadataProvider,
[NotNull] IModelBinder modelBinder,
[NotNull] IValueProvider valueProvider,
[NotNull] IObjectModelValidator objectModelValidator,
[NotNull] IModelValidatorProvider validatorProvider,
[NotNull] Func <ModelBindingContext, string, bool> predicate)
{
if (!modelType.IsAssignableFrom(model.GetType()))
{
var message = Resources.FormatModelType_WrongType(
model.GetType().FullName,
modelType.FullName);
throw new ArgumentException(message, nameof(modelType));
}
var modelMetadata = metadataProvider.GetMetadataForType(modelType);
// Clear ModelStateDictionary entries for the model so that it will be re-validated.
ClearValidationStateForModel(modelType, modelState, metadataProvider, prefix);
var operationBindingContext = new OperationBindingContext
{
ModelBinder = modelBinder,
ValidatorProvider = validatorProvider,
MetadataProvider = metadataProvider,
HttpContext = httpContext
};
var modelBindingContext = new ModelBindingContext
{
Model = model,
ModelMetadata = modelMetadata,
ModelName = prefix,
ModelState = modelState,
ValueProvider = valueProvider,
FallbackToEmptyPrefix = true,
OperationBindingContext = operationBindingContext,
PropertyFilter = predicate
};
var modelBindingResult = await modelBinder.BindModelAsync(modelBindingContext);
if (modelBindingResult != null)
{
var modelExplorer = new ModelExplorer(metadataProvider, modelMetadata, modelBindingResult.Model);
var modelValidationContext = new ModelValidationContext(modelBindingContext, modelExplorer);
modelValidationContext.RootPrefix = prefix;
objectModelValidator.Validate(modelValidationContext);
return(modelState.IsValid);
}
return(false);
}
public ModelService(
ApplicationDbContext context,
IObjectModelValidator modelValidator
)
{
_context = context;
_modelValidator = modelValidator;
}
public static void Validate(this IObjectModelValidator objectModelValidator, ControllerContext controllerContext, object model)
{
objectModelValidator.Validate(
controllerContext,
validationState: null,
prefix: string.Empty,
model: model);
}
public DefaultControllerActionArgumentBinder(
IModelMetadataProvider modelMetadataProvider,
IObjectModelValidator validator,
IOptions<MvcOptions> optionsAccessor)
{
_modelMetadataProvider = modelMetadataProvider;
_options = optionsAccessor.Options;
_validator = validator;
}
public DefaultControllerActionArgumentBinder(
IModelMetadataProvider modelMetadataProvider,
IObjectModelValidator validator,
IOptions <MvcOptions> optionsAccessor)
{
_modelMetadataProvider = modelMetadataProvider;
_options = optionsAccessor.Options;
_validator = validator;
}
public DefaultControllerArgumentBinder(
IModelMetadataProvider modelMetadataProvider,
IModelBinderFactory modelBinderFactory,
IObjectModelValidator validator)
{
_modelMetadataProvider = modelMetadataProvider;
_modelBinderFactory = modelBinderFactory;
_validator = validator;
}
public static void Validate(this IObjectModelValidator objectModelValidator, ControllerContext controllerContext, object model)
{
objectModelValidator.Validate(
controllerContext,
new CompositeModelValidatorProvider(controllerContext.ValidatorProviders),
validationState: null,
prefix: string.Empty,
model: model);
}
/// <summary>
/// Updates the specified <paramref name="model"/> instance using the specified
/// <paramref name="modelBinderFactory"/> and the specified <paramref name="valueProvider"/> and executes
/// validation using the specified <paramref name="objectModelValidator"/>.
/// </summary>
/// <typeparam name="TModel">The type of the model object.</typeparam>
/// <param name="model">The model instance to update and validate.</param>
/// <param name="prefix">The prefix to use when looking up values in the <paramref name="valueProvider"/>.
/// </param>
/// <param name="actionContext">The <see cref="ActionContext"/> for the current executing request.</param>
/// <param name="metadataProvider">The provider used for reading metadata for the model type.</param>
/// <param name="modelBinderFactory">The <see cref="IModelBinderFactory"/> used for binding.</param>
/// <param name="valueProvider">The <see cref="IValueProvider"/> used for looking up values.</param>
/// <param name="objectModelValidator">The <see cref="IObjectModelValidator"/> used for validating the
/// bound values.</param>
/// <returns>A <see cref="Task"/> that on completion returns <c>true</c> if the update is successful</returns>
public static Task <bool> TryUpdateModelAsync <TModel>(
TModel model,
string prefix,
ActionContext actionContext,
IModelMetadataProvider metadataProvider,
IModelBinderFactory modelBinderFactory,
IValueProvider valueProvider,
IObjectModelValidator objectModelValidator)
where TModel : class
{
if (model == null)
{
throw new ArgumentNullException(nameof(model));
}
if (prefix == null)
{
throw new ArgumentNullException(nameof(prefix));
}
if (actionContext == null)
{
throw new ArgumentNullException(nameof(actionContext));
}
if (metadataProvider == null)
{
throw new ArgumentNullException(nameof(metadataProvider));
}
if (modelBinderFactory == null)
{
throw new ArgumentNullException(nameof(modelBinderFactory));
}
if (valueProvider == null)
{
throw new ArgumentNullException(nameof(valueProvider));
}
if (objectModelValidator == null)
{
throw new ArgumentNullException(nameof(objectModelValidator));
}
// Includes everything by default.
return(TryUpdateModelAsync(
model,
prefix,
actionContext,
metadataProvider,
modelBinderFactory,
valueProvider,
objectModelValidator,
propertyFilter: (m) => true));
}
public CommentService(
ApplicationDbContext context,
IAuthorizationService authorizationService,
IObjectModelValidator modelValidator,
ICommentAuthorizationService commentViewService
)
: base(context, modelValidator)
{
Authorization = commentViewService;
}
private static DefaultControllerActionArgumentBinder GetArgumentBinder(IObjectModelValidator validator = null)
{
if (validator == null)
{
validator = CreateMockValidator();
}
return(new DefaultControllerActionArgumentBinder(
TestModelMetadataProvider.CreateDefaultProvider(),
validator));
}
public ParameterBinder(
IModelMetadataProvider modelMetadataProvider,
IModelBinderFactory modelBinderFactory,
IObjectModelValidator validator)
: this(
modelMetadataProvider,
modelBinderFactory,
validator,
Options.Create(new MvcOptions()),
NullLoggerFactory.Instance)
{
}
private static DefaultControllerActionArgumentBinder GetArgumentBinder(IObjectModelValidator validator = null)
{
if (validator == null)
{
var mockValidator = new Mock <IObjectModelValidator>(MockBehavior.Strict);
mockValidator.Setup(
o => o.Validate(It.IsAny <ModelValidationContext>(), It.IsAny <ModelValidationNode>()));
validator = mockValidator.Object;
}
return(new DefaultControllerActionArgumentBinder(
TestModelMetadataProvider.CreateDefaultProvider(),
validator));
}
public ParameterBinder(
IModelMetadataProvider modelMetadataProvider,
IModelBinderFactory modelBinderFactory,
IObjectModelValidator validator)
: this(modelMetadataProvider, modelBinderFactory, null, validator)
{
// Note: When this obsolete constructor overload is removed, also remember
// to remove the validatorForBackCompatOnly field.
if (validator == null)
{
throw new ArgumentNullException(nameof(validator));
}
}
public PatchCarCommand(
IActionContextAccessor actionContextAccessor,
IObjectModelValidator objectModelValidator,
ICarRepository carRepository,
IMapper <Car, ViewModels.Car> carToCarMapper,
IMapper <Car, SaveCar> carToSaveCarMapper,
IMapper <SaveCar, Car> saveCarToCarMapper)
{
_actionContextAccessor = actionContextAccessor;
_objectModelValidator = objectModelValidator;
_carRepository = carRepository;
_carToCarMapper = carToCarMapper;
_carToSaveCarMapper = carToSaveCarMapper;
_saveCarToCarMapper = saveCarToCarMapper;
}
public PatchPostCommand(
IActionContextAccessor actionContextAccessor,
IObjectModelValidator objectModelValidator,
IPostRepository postRepository,
IMapper <Post, ViewModels.Post> postToPostMapper,
IMapper <Post, SavePost> postToSavePostMapper,
IMapper <SavePost, Post> savePostToPostMapper)
{
_actionContextAccessor = actionContextAccessor;
_objectModelValidator = objectModelValidator;
_postRepository = postRepository;
_postToPostMapper = postToPostMapper;
_postToSavePostMapper = postToSavePostMapper;
_savePostToPostMapper = savePostToPostMapper;
}
public PatchBlogCommand(
IActionContextAccessor actionContextAccessor,
IObjectModelValidator objectModelValidator,
IBlogRepository blogRepository,
IMapper <Blog, ViewModels.Blog> blogToBlogMapper,
IMapper <Blog, SaveBlog> blogToSaveBlogMapper,
IMapper <SaveBlog, Blog> saveBlogToBlogMapper)
{
_actionContextAccessor = actionContextAccessor;
_objectModelValidator = objectModelValidator;
_blogRepository = blogRepository;
_blogToBlogMapper = blogToBlogMapper;
_blogToSaveBlogMapper = blogToSaveBlogMapper;
_saveBlogToBlogMapper = saveBlogToBlogMapper;
}
/// <summary>
/// Initializes a new instance of the <see cref="ValidationAppSI"/> class.
/// </summary>
public ValidationAppSI(
ILogger <ApplicationAppSI> logger,
IData dataService,
IAltinnApp altinnApp,
IAppResources appResourcesService,
IObjectModelValidator objectModelValidator,
IHttpContextAccessor httpContextAccessor)
{
_logger = logger;
_dataService = dataService;
_altinnApp = altinnApp;
_appResourcesService = appResourcesService;
_objectModelValidator = objectModelValidator;
_httpContextAccessor = httpContextAccessor;
}
public DefaultModelStateValidator(IObjectModelValidator validator, MvcOptions options, IServiceProvider provider)
{
if (validator == null)
{
throw new ArgumentNullException(nameof(validator));
}
if (options == null)
{
throw new ArgumentNullException(nameof(validator));
}
_validator = validator;
_options = options;
_provider = provider ?? ServiceUtils.GetDefaultServiceProvider();
}
public PatchCountryCommand(
IActionContextAccessor actionContextAccessor,
IObjectModelValidator objectModelValidator,
ICountryRepository countryRepository,
IMapper <Models.Country, Country> countryToCountryMapper,
IMapper <Models.Country, SaveCountry> countryToSaveCountryMapper,
IMapper <SaveCountry, Models.Country> saveCountryToCountryMapper)
{
_actionContextAccessor = actionContextAccessor;
_objectModelValidator = objectModelValidator;
_countryRepository = countryRepository;
_countryToCountryMapper = countryToCountryMapper;
_countryToSaveCountryMapper = countryToSaveCountryMapper;
_saveCountryToCountryMapper = saveCountryToCountryMapper;
}
public PatchCarCommand(
IActionContextAccessor actionContextAccessor,
IObjectModelValidator objectModelValidator,
ICarRepository carRepository,
IMapper <Models.Car, Car> carToCarMapper,
IMapper <Models.Car, SaveCar> carToSaveCarMapper,
IMapper <SaveCar, Models.Car> saveCarToCarMapper)
{
this.actionContextAccessor = actionContextAccessor;
this.objectModelValidator = objectModelValidator;
this.carRepository = carRepository;
this.carToCarMapper = carToCarMapper;
this.carToSaveCarMapper = carToSaveCarMapper;
this.saveCarToCarMapper = saveCarToCarMapper;
}
public PatchZoneCommand(
IActionContextAccessor actionContextAccessor,
IObjectModelValidator objectModelValidator,
IZoneRepository zoneRepository,
IMapper <Models.Zone, Zone> zoneToZoneMapper,
IMapper <Models.Zone, SaveZone> zoneToSaveZoneMapper,
IMapper <SaveZone, Models.Zone> saveZoneToZoneMapper,
IHttpContextAccessor httpContextAccessor)
{
this.actionContextAccessor = actionContextAccessor;
this.objectModelValidator = objectModelValidator;
this.zoneRepository = zoneRepository;
this.zoneToZoneMapper = zoneToZoneMapper;
this.zoneToSaveZoneMapper = zoneToSaveZoneMapper;
this.saveZoneToZoneMapper = saveZoneToZoneMapper;
}
public PatchLanguageCommand(
IActionContextAccessor actionContextAccessor,
IObjectModelValidator objectModelValidator,
ILanguageRepository languageRepository,
IMapper <Models.Language, Language> languageToLanguageMapper,
IMapper <Models.Language, SaveLanguage> languageToSaveLanguageMapper,
IMapper <SaveLanguage, Models.Language> saveLanguageToLanguageMapper,
IHttpContextAccessor httpContextAccessor)
{
_actionContextAccessor = actionContextAccessor;
_objectModelValidator = objectModelValidator;
_languageRepository = languageRepository;
_languageToLanguageMapper = languageToLanguageMapper;
_languageToSaveLanguageMapper = languageToSaveLanguageMapper;
_saveLanguageToLanguageMapper = saveLanguageToLanguageMapper;
_httpContextAccessor = httpContextAccessor;
}
/// <summary>
/// Initialises a new instance of <see cref="DefaultWidgetArgumentBinder"/>.
/// </summary>
/// <param name="options">The options accessor for <see cref="MvcOptions"/></param>
/// <param name="modelMetadataProvider">The model metadata provider.</param>
/// <param name="objectModelValidator">The object model validator.</param>
public DefaultWidgetArgumentBinder(IOptions<MvcOptions> options, IModelMetadataProvider modelMetadataProvider, IObjectModelValidator objectModelValidator)
{
if (options == null)
{
throw new ArgumentNullException(nameof(options));
}
if (modelMetadataProvider == null)
{
throw new ArgumentNullException(nameof(modelMetadataProvider));
}
if (objectModelValidator == null)
{
throw new ArgumentNullException(nameof(objectModelValidator));
}
_options = options.Value;
_modelMetadataProvider = modelMetadataProvider;
_objectModelValidator = objectModelValidator;
}
