public ValidationTemplate(INotifyPropertyChanged target)
{
this.target = target;
validator = GetValidator(target.GetType());
validationResult = validator.Validate(target);
target.PropertyChanged += Validate;
}
public Screen(IModelValidator validator)
: base(validator)
{
var type = GetType();
DisplayName = type.FullName;
logger = LogManager.GetLogger(type);
}
protected override IModel CreateModel(DbContext context, IConventionSetBuilder conventionSetBuilder, IModelValidator validator)
{
var model = base.CreateModel(context, conventionSetBuilder, validator) as Model;
model["AllYourModelAreBelongTo"] = "Us!";
return model;
}
public SiteController(ISiteService siteservice, IUserService userService, ITemplateService templateService, INodeService nodeService, IModelValidator<Site> siteValidator, IModelValidator<SiteAlias> siteAliasValidator)
{
_siteService = siteservice;
_userService = userService;
_templateService = templateService;
_nodeService = nodeService;
_siteAliasValidator = siteAliasValidator;
ModelValidator = siteValidator;
}
public PagesController(INodeService nodeService, ITemplateService templateService, IFileService fileService, ISectionService sectionService, IModelValidator<Node> modelValidator, ModuleLoader moduleLoader)
{
_nodeService = nodeService;
_templateService = templateService;
_fileService = fileService;
_sectionService = sectionService;
this.ModelValidator = modelValidator;
_moduleLoader = moduleLoader;
}
public void SetUp()
{
var locator = ServiceLocator.Builder.Create as ServiceLocator;
locator.Register(typeof(IValidator<Customer>), new CustomerValidator(), typeof(CustomerValidator).FullName);
var factory = ObjectFactory.Builder.UseLocator(locator).UseConfigurationSource(new IObjectFactoryConfigurationSource[] { new AutoValidationConfigurationSource() }).Create;
_modelValidator = ModelValidator.Builder.UseFactory(factory).Create;
}
protected override IModel CreateModel(DbContext context, IConventionSetBuilder conventionSetBuilder, IModelValidator validator)
{
var conventionSet = CreateConventionSet(conventionSetBuilder);
var model = new Model();
var modelBuilder = new ModelBuilder(conventionSet, model);
FindSets(modelBuilder, context);
_onModelCreating(modelBuilder);
validator.Validate(model);
return model;
}
protected override IModel CreateModel(DbContext context, IConventionSetBuilder conventionSetBuilder, IModelValidator validator)
{
var conventionSet = CreateConventionSet(conventionSetBuilder);
var modelBuilder = new ModelBuilder(conventionSet);
var model = (Model)modelBuilder.Model;
model.SetProductVersion(ProductInfo.GetVersion());
FindSets(modelBuilder, context);
_onModelCreating(modelBuilder);
model.Validate();
validator.Validate(model);
return model;
}
public void SetUp()
{
var container = new ServiceContainer();
var directory = TestContext.CurrentContext.TestDirectory;
var finder = AssemblyFinder.Builder.UsePath(directory).Create;
var assemblies = finder.GetAssembliesTagged<AssemblyTagAttribute>();
container.RegisterFrom<ServiceLocatorCompositionRoot>();
container.RegisterFactory(assemblies);
container.RegisterValidator(assemblies, assemblies);
_modelValidator = container.GetInstance<IModelValidator>();
}
public void SetUp()
{
var directory = TestContext.CurrentContext.TestDirectory;
var finder = AssemblyFinder.Builder.UsePath(directory).Create;
var assemblies = finder.GetAssembliesTagged<AssemblyTagAttribute>();
IWindsorContainer container = new WindsorContainer();
container.Kernel.Resolver.AddSubResolver(new ArrayResolver(container.Kernel));
container.Install(new ValidatorInstaller(assemblies, assemblies));
container.Install(new ServiceLocatorInstaller());
container.Install(new FactoryInstaller(assemblies));
_modelValidator = container.Resolve<IModelValidator>();
}
protected override IModel CreateModel(
DbContext context,
IConventionSetBuilder conventionSetBuilder,
IModelValidator validator)
{
var conventionSet = CreateConventionSet(conventionSetBuilder);
var modelBuilder = new MaterializingModelBuilder(conventionSet);
var internalModelBuilder = ((IInfrastructure<InternalModelBuilder>)modelBuilder).Instance;
internalModelBuilder.Metadata.SetProductVersion(ProductInfo.GetVersion());
FindSets(modelBuilder, context);
ModelCustomizer.Customize(modelBuilder, context);
internalModelBuilder.Validate();
validator.Validate(modelBuilder.Model);
return modelBuilder.Model;
}
public ImportWizardImportContainerViewModel(ILogger <ImportWizardImportContainerViewModel> logger, IDialogCoordinator dialogCoordinator, IModelValidator <ImportWizardImportContainerViewModel> validator, IObjectSelectionProvider objectSelectionProvider, IDiscoveryServices discoveryServices, IDirectory directory, IWindowsServiceProvider windowsServiceProvider, IShellExecuteProvider shellExecuteProvider)
{
this.logger = logger;
this.dialogCoordinator = dialogCoordinator;
this.discoveryServices = discoveryServices;
this.objectSelectionProvider = objectSelectionProvider;
this.directory = directory;
this.Validator = validator;
this.windowsServiceProvider = windowsServiceProvider;
this.shellExecuteProvider = shellExecuteProvider;
this.Initialization = this.Initialize();
}
public SqlServerModelSource([NotNull] IDbSetFinder setFinder, [NotNull] IModelValidator modelValidator)
: base(setFinder, modelValidator)
{
}
public RenameViewModel(IModelValidator <RenameViewModel> validator, string subject, string currentName) : base(validator)
{
Subject = subject;
ElementName = currentName;
}
public ApiConnection(ILogger logger, HttpClient client, IApiConnectionPlatformHelper helper, IModelValidator validator)
{
this.logger = logger;
this.client = client;
this.helper = helper;
this.validator = validator;
}
/// <summary>
/// Validates the given object. If invalid, the errors are added to the ModelState.
/// </summary>
/// <param name="objectToValidate">The object to validate</param>
/// <param name="modelValidator">A specific model validator</param>
/// <param name="includeProperties">Properties to check</param>
/// <param name="modelPrefix"></param>
/// <returns>True if the object is valid</returns>
protected virtual bool ValidateModel(object objectToValidate, IModelValidator modelValidator, string[] includeProperties, string modelPrefix)
{
if (modelValidator == null && this._modelValidator == null)
{
throw new InvalidOperationException("A call to Validate() was made while there is no IModelValidator available to perform validation.");
}
// if a specific modelvalidator is passed, use that one, otherwise use the modelvalidator of the controller.
IModelValidator modelValidatorToUse = modelValidator ?? this._modelValidator;
if (!modelValidatorToUse.IsValid(objectToValidate, includeProperties))
{
IDictionary<string, ICollection<string>> errorsForProperties = modelValidatorToUse.GetErrors();
foreach (KeyValuePair<string, ICollection<string>> errorsForProperty in errorsForProperties)
{
string propertyName = errorsForProperty.Key;
if (! String.IsNullOrEmpty(modelPrefix))
{
propertyName = modelPrefix + "." + propertyName;
}
foreach (string errorMessage in errorsForProperty.Value)
{
ViewData.ModelState.AddModelError(propertyName, errorMessage);
}
}
return false;
}
return true;
}
protected override IModel CreateModel(DbContext context, IConventionSetBuilder conventionSetBuilder, IModelValidator validator)
{
var conventionSet = CreateConventionSet(conventionSetBuilder);
conventionSet.ModelBuiltConventions.Add(new ValidatingConvention(validator));
var modelBuilder = new ModelBuilder(conventionSet);
Dependencies.ModelCustomizer.Customize(modelBuilder, context);
_onModelCreating(modelBuilder, context);
return(modelBuilder.FinalizeModel());
}
protected DialogViewModelBase(IModelValidator validator) : base(validator)
{
}
// Returns true if validator execution adds a model error.
private static bool RunValidator(IModelValidator validator,
ModelBindingContext bindingContext,
ModelMetadata propertyMetadata,
string modelStateKey)
{
var validationContext = new ModelValidationContext(bindingContext, propertyMetadata);
var addedError = false;
foreach (var validationResult in validator.Validate(validationContext))
{
bindingContext.ModelState.AddModelError(modelStateKey, validationResult.Message);
addedError = true;
}
if (!addedError)
{
bindingContext.ModelState.MarkFieldValid(modelStateKey);
}
return addedError;
}
public MyScreen(IModelValidator validator) : base(validator)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="ValidationCommandHandlerDecorator{TCommand}"/> class.
/// </summary>
/// <param name="validator">The validator.</param>
/// <param name="commandHandler">The command handler.</param>
public ValidationCommandHandlerDecorator(IModelValidator <TCommand> validator, ICommandHandler <TCommand> commandHandler)
{
this.validator = validator;
this.commandHandler = commandHandler;
}
public ViewModelBase(IModelValidator validator) : base(validator)
{
DialogCoordinator = MahApps.Metro.Controls.Dialogs.DialogCoordinator.Instance;
}
public AuthenticationValidator(IAuthenticationConfigurationService authenticationConfigurationService, IAuthenticationRepository authenticationRepository, IEncryptionService encryptionService, IModelValidator modelValidator)
{
_authenticationConfigurationService = authenticationConfigurationService;
_authenticationRepository = authenticationRepository;
_encryptionService = encryptionService;
_modelValidator = modelValidator;
}
public DataAnnotationsModelValidator(IModelValidator validator, ValidationAttribute validationAttribute)
{
this.validator = validator;
this.validationAttribute = validationAttribute;
}
public WebhookNotificationChannelDefinitionViewModelFactory(IAppPathProvider appPathProvider, INotificationSubscriptionProvider notificationSubscriptionProvider, IModelValidator <WebhookNotificationChannelDefinitionViewModel> validator)
{
this.appPathProvider = appPathProvider;
this.notificationSubscriptionProvider = notificationSubscriptionProvider;
this.validator = validator;
}
public virtual IModel GetModel(DbContext context, IConventionSetBuilder conventionSetBuilder, IModelValidator validator)
=> _models.GetOrAdd(context.GetType(), k => CreateModel(context, conventionSetBuilder, validator));
protected ModelSource([NotNull] IDbSetFinder setFinder, [NotNull] IModelValidator modelValidator)
{
SetFinder = setFinder;
Validator = modelValidator;
}
public virtual void SetPropertyPublic(ModelBindingContext bindingContext, ModelMetadata propertyMetadata, ComplexModelDtoResult dtoResult, IModelValidator requiredValidator)
{
base.SetProperty(bindingContext, propertyMetadata, dtoResult, requiredValidator);
}
public TemplatesController(ITemplateService templateService, IFileService fileService, IModelValidator <Template> modelValidator)
{
_templateService = templateService;
_fileService = fileService;
ModelValidator = modelValidator;
}
/// <summary>
/// Validates the given object. If invalid, the errors are added to the ModelState.
/// </summary>
/// <param name="objectToValidate">The object to validate</param>
/// <param name="modelValidator">A specific model validator</param>
/// <param name="includeProperties">Properties to check</param>
/// <returns>True if the object is valid</returns>
protected virtual bool ValidateModel(object objectToValidate, IModelValidator modelValidator, string[] includeProperties)
{
return ValidateModel(objectToValidate, modelValidator, includeProperties, null);
}
public override IModel GetModel(DbContext context, IConventionSetBuilder conventionSetBuilder, IModelValidator validator)
=> _testModelSource.GetModel(context, conventionSetBuilder, validator);
public ModuleViewModel(IModelValidator <ModuleViewModel> validator, IServiceProvider provider)
: base(validator)
{
_provider = provider;
Validate();
}
public BrandService(ICatalogDbContext catalogDbContext, IModelValidator <Brand> validator)
{
_catalogDbContext = catalogDbContext;
_validator = validator;
}
public AccountController(IModelValidator modelValidator, IUserService service)
{
this.modelValidator = modelValidator;
this.service = service;
}
protected override IModel CreateModel(DbContext context, IConventionSetBuilder conventionSetBuilder, IModelValidator validator)
{
var model = base.CreateModel(context, conventionSetBuilder, validator) as Model;
model["AllYourModelAreBelongTo"] = "Us!";
return(model);
}
/// <summary>
/// This is an internal API that supports the Entity Framework Core infrastructure and not subject to
/// the same compatibility standards as public APIs. It may be changed or removed without notice in
/// any release. You should only use it directly in your code with extreme caution and knowing that
/// doing so can result in application failures when updating to a new Entity Framework Core release.
/// </summary>
public ValidatingConvention([NotNull] IModelValidator validator, DiagnosticsLoggers loggers)
{
_validator = validator;
_loggers = loggers;
}
public UserController(ILogger <UserController> logger, IUserRoleRepository userRoleRepository,
IUserRepository userRepository, IPractitionerRepository practitionerRepository, ICryptographyHelper cryptographyHelper, IModelValidator <UserModel> validator)
{
_logger = logger;
_userRoleRepository = userRoleRepository;
_userRepository = userRepository;
_practionerRepository = practitionerRepository;
_cryptographyHelper = cryptographyHelper;
_validator = validator;
}
public JitGroupMappingViewModel(JitGroupMapping model, ILogger <JitGroupMappingViewModel> logger, IDialogCoordinator dialogCoordinator, IModelValidator <JitGroupMappingViewModel> validator, IDiscoveryServices discoveryServices, IObjectSelectionProvider objectSelectionProvider)
{
this.logger = logger;
this.dialogCoordinator = dialogCoordinator;
this.Model = model;
this.objectSelectionProvider = objectSelectionProvider;
this.Validator = validator;
this.discoveryServices = discoveryServices;
}
protected override IModel CreateModel(DbContext context, IConventionSetBuilder conventionSetBuilder, IModelValidator validator)
{
var conventionSet = CreateConventionSet(conventionSetBuilder);
var modelBuilder = new ModelBuilder(conventionSet);
var model = (Model)modelBuilder.Model;
model.SetProductVersion(ProductInfo.GetVersion());
FindSets(modelBuilder, context);
_onModelCreating(modelBuilder);
model.Validate();
validator.Validate(model);
return(model);
}
public CallCenterOffersController(IModelValidator modelValidator)
{
_modelValidator = modelValidator;
}
/// <summary>
/// Returns the model from the cache, or creates a model if it is not present in the cache.
/// </summary>
/// <param name="context"> The context the model is being produced for. </param>
/// <param name="conventionSetBuilder"> The convention set to use when creating the model. </param>
/// <param name="validator"> The validator to verify the model can be successfully used with the context. </param>
/// <returns> The model to be used. </returns>
public virtual IModel GetModel(DbContext context, IConventionSetBuilder conventionSetBuilder, IModelValidator validator)
=> _models.GetOrAdd(
Dependencies.ModelCacheKeyFactory.Create(context),
// Using a Lazy here so that OnModelCreating, etc. really only gets called once, since it may not be thread safe.
k => new Lazy <IModel>(
() => CreateModel(context, conventionSetBuilder, validator),
LazyThreadSafetyMode.ExecutionAndPublication)).Value;
protected override void SetProperty(ModelBindingContext bindingContext, ModelMetadata propertyMetadata, ComplexModelDtoResult dtoResult, IModelValidator requiredValidator)
{
SetPropertyPublic(bindingContext, propertyMetadata, dtoResult, requiredValidator);
}
public ProfileCreateViewModel(IModelValidator <ProfileCreateViewModel> validator) : base(validator)
{
}
/// <summary>
/// This API supports the Entity Framework Core infrastructure and is not intended to be used
/// directly from your code. This API may change or be removed in future releases.
/// </summary>
public ValidatingConvention([NotNull] IModelValidator validator)
{
_validator = validator;
}
public PersonModelBinder(IModelValidator validator)
{
Validator = validator;
}
public ConcreteModelSource(IDbSetFinder setFinder, IModelValidator modelValidator)
: base(setFinder, modelValidator)
{
}
public DomainValidator(IModelValidator modelValidator, IDomainRepository domainRepository)
{
_modelValidator = modelValidator;
_domainRepository = domainRepository;
}
protected virtual void SetProperty(ModelBindingContext bindingContext,
ModelMetadata propertyMetadata,
ComplexModelDtoResult dtoResult,
IModelValidator requiredValidator)
{
var bindingFlags = BindingFlags.Instance | BindingFlags.Public | BindingFlags.IgnoreCase;
var property = bindingContext.ModelType
.GetProperty(propertyMetadata.PropertyName, bindingFlags);
if (property == null || !property.CanWrite)
{
// nothing to do
return;
}
var value = dtoResult.Model ?? GetPropertyDefaultValue(property);
propertyMetadata.Model = value;
// 'Required' validators need to run first so that we can provide useful error messages if
// the property setters throw, e.g. if we're setting entity keys to null.
if (value == null)
{
var modelStateKey = dtoResult.ValidationNode.ModelStateKey;
var validationState = bindingContext.ModelState.GetFieldValidationState(modelStateKey);
if (validationState == ModelValidationState.Unvalidated)
{
if (requiredValidator != null)
{
var validationContext = new ModelValidationContext(bindingContext, propertyMetadata);
foreach (var validationResult in requiredValidator.Validate(validationContext))
{
bindingContext.ModelState.AddModelError(modelStateKey, validationResult.Message);
}
}
}
}
if (value != null || property.PropertyType.AllowsNullValue())
{
try
{
property.SetValue(bindingContext.Model, value);
}
catch (Exception ex)
{
// don't display a duplicate error message if a binding error has already occurred for this field
var targetInvocationException = ex as TargetInvocationException;
if (targetInvocationException != null &&
targetInvocationException.InnerException != null)
{
ex = targetInvocationException.InnerException;
}
var modelStateKey = dtoResult.ValidationNode.ModelStateKey;
var validationState = bindingContext.ModelState.GetFieldValidationState(modelStateKey);
if (validationState == ModelValidationState.Unvalidated)
{
bindingContext.ModelState.AddModelError(modelStateKey, ex);
}
}
}
else
{
// trying to set a non-nullable value type to null, need to make sure there's a message
var modelStateKey = dtoResult.ValidationNode.ModelStateKey;
var validationState = bindingContext.ModelState.GetFieldValidationState(modelStateKey);
if (validationState == ModelValidationState.Unvalidated)
{
dtoResult.ValidationNode.Validated += CreateNullCheckFailedHandler(propertyMetadata, value);
}
}
}
/// <summary>
/// Returns the model from the cache, or creates a model if it is not present in the cache.
/// </summary>
/// <param name="context"> The context the model is being produced for. </param>
/// <param name="conventionSetBuilder"> The convention set to use when creating the model. </param>
/// <param name="validator"> The validator to verify the model can be successfully used with the context. </param>
/// <returns> The model to be used. </returns>
public virtual IModel GetModel(DbContext context, IConventionSetBuilder conventionSetBuilder, IModelValidator validator)
=> _models.GetOrAdd(ModelCacheKeyFactory.Create(context), k => CreateModel(context, conventionSetBuilder, validator));
public override IModel GetModel(DbContext context, IConventionSetBuilder conventionSetBuilder, IModelValidator validator) => _testModelSource.GetModel(context, conventionSetBuilder, validator);
public TestInMemoryModelSource(Action<ModelBuilder> onModelCreating, IDbSetFinder setFinder, IModelValidator modelValidator)
: base(setFinder, modelValidator)
{
_testModelSource = new TestModelSource(onModelCreating, setFinder);
}
public virtual IModel GetModel(DbContext context, IConventionSetBuilder conventionSetBuilder, IModelValidator validator = null)
{
return null;
}
private IReadOnlyList<IModelValidator> ExtractValidators(List<ValidatorItem> items)
{
var count = 0;
for (var i = 0; i < items.Count; i++)
{
if (items[i].Validator != null)
{
count++;
}
}
if (count == 0)
{
return EmptyArray;
}
var validators = new IModelValidator[count];
var validatorIndex = 0;
for (int i = 0; i < items.Count; i++)
{
var validator = items[i].Validator;
if (validator != null)
{
validators[validatorIndex++] = validator;
}
}
return validators;
}
public SKSizePropertyInputViewModel(LayerProperty <SKSize> layerProperty, IProfileEditorService profileEditorService,
IModelValidator <SKSizePropertyInputViewModel> validator) : base(layerProperty, profileEditorService, validator)
{
_widthRegistration = layerProperty.GetDataBindingRegistration <float>("Width");
_heightRegistration = layerProperty.GetDataBindingRegistration <float>("Height");
}
public TemplatesController(ITemplateService templateService, IFileService fileService, IModelValidator<Template> modelValidator)
{
_templateService = templateService;
_fileService = fileService;
ModelValidator = modelValidator;
}
protected virtual void SetProperty(ModelBindingContext bindingContext,
ModelMetadata propertyMetadata,
ComplexModelDtoResult dtoResult,
IModelValidator requiredValidator)
{
var bindingFlags = BindingFlags.Instance | BindingFlags.Public | BindingFlags.IgnoreCase;
var property = bindingContext.ModelType
.GetProperty(propertyMetadata.PropertyName, bindingFlags);
if (property == null || !property.CanWrite)
{
// nothing to do
return;
}
object value;
var hasDefaultValue = false;
if (dtoResult.IsModelBound)
{
value = dtoResult.Model;
}
else
{
hasDefaultValue = TryGetPropertyDefaultValue(property, out value);
}
propertyMetadata.Model = value;
// 'Required' validators need to run first so that we can provide useful error messages if
// the property setters throw, e.g. if we're setting entity keys to null.
if (value == null)
{
var modelStateKey = dtoResult.ValidationNode.ModelStateKey;
var validationState = bindingContext.ModelState.GetFieldValidationState(modelStateKey);
if (validationState == ModelValidationState.Unvalidated)
{
if (requiredValidator != null)
{
var validationContext = new ModelValidationContext(bindingContext, propertyMetadata);
foreach (var validationResult in requiredValidator.Validate(validationContext))
{
bindingContext.ModelState.TryAddModelError(modelStateKey, validationResult.Message);
}
}
}
}
if (!dtoResult.IsModelBound && !hasDefaultValue)
{
// If we don't have a value, don't set it on the model and trounce a pre-initialized
// value.
return;
}
if (value != null || property.PropertyType.AllowsNullValue())
{
try
{
property.SetValue(bindingContext.Model, value);
}
catch (Exception ex)
{
// don't display a duplicate error message if a binding error has already occurred for this field
var targetInvocationException = ex as TargetInvocationException;
if (targetInvocationException != null &&
targetInvocationException.InnerException != null)
{
ex = targetInvocationException.InnerException;
}
var modelStateKey = dtoResult.ValidationNode.ModelStateKey;
var validationState = bindingContext.ModelState.GetFieldValidationState(modelStateKey);
if (validationState == ModelValidationState.Unvalidated)
{
bindingContext.ModelState.AddModelError(modelStateKey, ex);
}
}
}
else
{
// trying to set a non-nullable value type to null, need to make sure there's a message
var modelStateKey = dtoResult.ValidationNode.ModelStateKey;
var validationState = bindingContext.ModelState.GetFieldValidationState(modelStateKey);
if (validationState == ModelValidationState.Unvalidated)
{
dtoResult.ValidationNode.Validated += CreateNullCheckFailedHandler(propertyMetadata, value);
}
}
}
/// <summary>
/// Returns the model from the cache, or creates a model if it is not present in the cache.
/// </summary>
/// <param name="context"> The context the model is being produced for. </param>
/// <param name="conventionSetBuilder"> The convention set to use when creating the model. </param>
/// <param name="validator"> The validator to verify the model can be successfully used with the context. </param>
/// <returns> The model to be used. </returns>
public virtual IModel GetModel(DbContext context, IConventionSetBuilder conventionSetBuilder, IModelValidator validator)
=> _models.GetOrAdd(
Dependencies.ModelCacheKeyFactory.Create(context),
k => CreateModel(context, conventionSetBuilder, validator));
static IModelValidator GetValidator(Type modelType)
{
IModelValidator validator;
if (!validators.TryGetValue(modelType.TypeHandle, out validator))
{
var typeName = string.Format("{0}.{1}Validator", modelType.Namespace, modelType.Name);
var type = modelType.Assembly.GetType(typeName, true);
validators[modelType.TypeHandle] = validator = (IModelValidator) Activator.CreateInstance(type);
}
return validator;
}
/// <summary>
/// Create and initialize an instance of the LoginController class.
/// </summary>
/// <param name="authenticationService"></param>
/// <param name="modelValidator"></param>
public LoginController(IAuthenticationService authenticationService, IModelValidator<LoginViewData> modelValidator)
{
this._authenticationService = authenticationService;
this.ModelValidator = modelValidator;
}
public PagesController(INodeService nodeService, ITemplateService templateService, IFileService fileService, ISectionService sectionService, IModelValidator <Node> modelValidator, ModuleLoader moduleLoader)
{
_nodeService = nodeService;
_templateService = templateService;
_fileService = fileService;
_sectionService = sectionService;
this.ModelValidator = modelValidator;
_moduleLoader = moduleLoader;
}
