private IModelBinder GetModelBinderForSection(Section section, INConfigSettings settings)
{
var binder = new ConfigurationHelper()
.GetConfigurationProperty<Section, IModelBinder>(section, x => x.ModelBinder, settings.ModelBinder,
x => settings.ModelBinder);
return binder;
}
private IEnumerable<IValueProvider> BuildValueProviders(IEnumerable<ParameterValue> values, IStringToValueTranslator translator, INConfigSettings settings)
{
foreach (var parameterValue in values)
{
IEnumerable<IFilterCondition> filterConditions = this.TranslateFilterConditions(parameterValue.FilterConditions, settings);
yield return new TranslateFromStringValueProvider(translator, parameterValue.Value, filterConditions.ToArray());
}
}
static NConfigurator()
{
mergerRegistry = CreateSectionMerger();
repository = CreateRepository();
settings = new NConfigSettings(Repository);
configurationFactory = new ConfigurationFactory(Repository, MergerRegistry);
Default = ConfigurationFactory.CreateConfiguration(null);
systemConfigurator = CreateSystemConfigurator();
}
private void BuildParameterProvider(INConfigSettings settings, SectionProvider provider, Parameter parameter, PropertyInfo parameterPropertyInfo)
{
if (string.IsNullOrEmpty(parameter.TypeName))
{
parameter.TypeName = parameterPropertyInfo.PropertyType.AssemblyQualifiedName;
}
else if (!parameterPropertyInfo.PropertyType.IsAssignableFrom(Type.GetType(parameter.TypeName, true)))
{
throw new InvalidParameterConfiguration(string.Format("Specified type {0} for parameter {1} is not assignable to the property of type {2}", parameter.TypeName, parameter.Name,parameterPropertyInfo.PropertyType.FullName));
}
var valueProvider = new ParameterToParameterValueProviderConverter().Convert(parameter, settings);
provider.ParameterValuesProviders.Add(parameterPropertyInfo.Name, valueProvider);
}
private void BuildParametersProviders(Section section, INConfigSettings settings, SectionProvider provider, Type sectionType)
{
var properties = sectionType.GetProperties(BindingFlags.Public | BindingFlags.Instance);
foreach (Parameter parameter in section.Parameters.Values)
{
var parameterPropertyInfo = properties.SingleOrDefault(x => x.Name.ToLower() == parameter.Name.ToLower());
if (parameterPropertyInfo == null && settings.ThrowIfParameterMemberMissing)
{
throw new MemberNotFouldForParameter(parameter);
}
this.BuildParameterProvider(settings, provider, parameter, parameterPropertyInfo);
}
}
public ISectionProvider Convert(Section section, INConfigSettings settings)
{
try
{
Type sectionType = Type.GetType(section.TypeName, true);
var binder = this.GetModelBinderForSection(section, settings);
var provider = new SectionProvider { SectionType = sectionType, ModelBinder = binder };
this.BuildParametersProviders(section, settings, provider, sectionType);
return provider;
}
catch (Exception e)
{
throw new SessionToProviderConvertionFailed(section, e);
}
}
private IFilterPolicy GetFilterPolicy(Parameter parameter, Type parameterType, INConfigSettings settings)
{
IFilterPolicy filterPolicy = this._helper.GetConfigurationProperty<Parameter, IFilterPolicy>
(parameter,x=>x.PolicyName,
() =>
{
if (settings.ResultBuilderProvider.IsTypeIsSupportedCollection(parameterType))
{
return settings.FilterPolicies[Configure.DefaultCollectionFilterPolicyName];
}
else
{
return settings.FilterPolicies[Configure.DefaultSingleValueFilterPolicyName];
}
}
,
x => settings.FilterPolicies[x]);
return filterPolicy;
}
public IParameterValueProvider Convert(Parameter parameter, INConfigSettings settings)
{
var parameterType = Type.GetType(parameter.TypeName, true);
var policy = this.GetFilterPolicy(parameter, parameterType, settings);
var required = this.GetRequired(parameter);
var parameterValueType = this.DetermineParameterValueType(parameterType);
var translator = this.GetTranslator(parameter, parameterValueType, settings);
IEnumerable<IValueProvider> valueProviders = this.BuildValueProviders(parameter.Values,translator,settings);
var resultBuilder = settings.ResultBuilderProvider.Get(parameterType);
IParameterValueProvider parameterValueProvider = new ParameterValueProvider
(valueProviders, resultBuilder, new Filter(policy, settings.FilterConditionsEvaluator), required, parameter.Name);
return parameterValueProvider;
}
private IEnumerable<IFilterCondition> TranslateFilterConditions(IEnumerable<FilterCondition> filterConditions, INConfigSettings settings)
{
foreach(var filterCondition in filterConditions)
{
IFilterConditionFactory factory = this._helper.GetConfigurationProperty(filterCondition, x => x.ConditionName, () => settings.FilterConditionFactories[settings.DefaultFilterConditionName], x => settings.FilterConditionFactories[x]);
yield return factory.Create(filterCondition.Properties);
}
}
private IStringToValueTranslator GetTranslator(Parameter parameter, Type parameterValueType, INConfigSettings settings)
{
var translatorProvider = this._helper.GetConfigurationProperty<Parameter, IStringToValueTranslatorProvider>
(parameter,x=>x.Translator,() => settings.TranslatorProviders[settings.DefaultRawValueTranslatorName],
x => settings.TranslatorProviders[x]);
return translatorProvider.Get(parameterValueType);
}
public static string GetAliasedFileName(this INConfigSettings settings, string fileName)
{
return(Path.Combine(Path.GetDirectoryName(fileName),
settings.HostAlias + "." + Path.GetFileName(fileName)));
}
public ConvertFromSectionDataProvider(Func<IEnumerable<Section>> getMehtod, INConfigSettings settings)
{
this.GetMehtod = getMehtod;
this.Settings = settings;
}
