public AppSettingsConfigurationSource(IConfigurationOptions options)
{
Config = new T();
var props = typeof(T).GetProperties();
foreach (var prop in props)
{
string name;
var attrs = prop.GetCustomAttributes(typeof(ConfigurationPropertyAttribute), true);
if (attrs.Length == 1)
{
name = ((ConfigurationPropertyAttribute)attrs[0]).Name;
}
else
{
name = options.ConvertPropertyNameToAppSettingsName(prop.Name);
}
var converted = TypeDescriptor
.GetConverter(prop.PropertyType)
.ConvertFromString(
ConfigurationManager.AppSettings[name]);
prop.SetValue(Config, converted, null);
}
}
public AutofacGlassFactoryBuilder(IConfigurationOptions options, IContainer container,
Func <ILookup <Type, GlassInterfaceMetadata>, IGlassTemplateCacheService> templateCacheFactory,
IGlassTypesLoader typeLoader, IImplementationFactory implFactory)
: base(options)
{
if (container == null)
{
throw new ArgumentNullException(nameof(container));
}
if (templateCacheFactory == null)
{
throw new ArgumentNullException(nameof(templateCacheFactory));
}
if (typeLoader == null)
{
throw new ArgumentNullException(nameof(typeLoader));
}
if (implFactory == null)
{
throw new ArgumentNullException(nameof(implFactory));
}
_container = container;
_templateCacheFactory = templateCacheFactory;
_typeLoader = typeLoader;
_implFactory = implFactory;
}
public static IConfigurationFactory Create(IConfigurationOptions options = null)
{
// Construct the IConfiguration
var builder = new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile("appsettings.json");
var configuration = (IConfiguration)builder.Build();
// Configure the core pieces
var keynameResolver = new KeyNameResolver();
var parserResolver = new ParserResolver();
var configResolver = new ConfigurationReaderResolver();
var constructorResolver = new ValueConstructorResolver();
options = options ?? ConfigurationOptions.Create();
var configuratinFactory = new ConfigurationFactory(configuration,
options,
keynameResolver,
configResolver,
parserResolver,
constructorResolver);
return(configuratinFactory);
}
public DefaultGlassFactoryBuilder(IConfigurationOptions options, Func <ISitecoreService> serviceFactory) : base(options)
{
if (serviceFactory == null)
{
throw new ArgumentNullException(nameof(serviceFactory));
}
_serviceFactory = serviceFactory;
}
protected AbstractGlassFactoryBuilder(IConfigurationOptions options)
{
if (options == null)
{
throw new ArgumentNullException(nameof(options));
}
Options = options;
}
public WebClientFactory(ILogger <WebClientFactory> logger,
IDownloadProgressCache downloadProgressCache,
IConfigurationOptions configurationService)
{
_logger = logger;
_downloadProgressCache = downloadProgressCache;
_configurationService = configurationService;
}
public IKeyName Resolve(Type type, IConfigurationOptions configurationOptions)
{
var autoResolvedKeyName = ResolveInternally(type, configurationOptions);
// Try to resolve a custom key name from options
var customKeyName = configurationOptions.CustomKeyName?.Invoke(type, autoResolvedKeyName);
return(customKeyName ?? autoResolvedKeyName);
}
public IValueConstructor Resolve(Type configType, IConfigurationOptions configurationOptions)
{
var autoResolvedConstructor = ResolveInternally(configType, configurationOptions);
// Try to resolve a custom constructor from options
var customConstructor = configurationOptions.CustomConstructor?.Invoke(configType, autoResolvedConstructor);
return(customConstructor ?? autoResolvedConstructor);
}
public void TestSetup()
{
_mockOptions = Substitute.For <IConfigurationOptions>();
_mockOptions.Assemblies.Returns(new[] { Assembly.GetAssembly(GetType()).FullName });
_mockService = Substitute.For <ISitecoreService>();
_builder = new DefaultGlassFactoryBuilder(_mockOptions, () => _mockService);
}
public IParser Resolve(Type configType, IConfigurationOptions configurationOptions)
{
var autoResolvedParser = ResolveInternally(configType, configurationOptions);
// Try to resolve a custom parser from options
var customParser = configurationOptions.CustomParser?.Invoke(configType, autoResolvedParser);
return(customParser ?? autoResolvedParser);
}
public IConfigurationReader Resolve(Type type, IConfigurationOptions configurationOptions)
{
var autoResolvedReader = ResolveInternally(type, configurationOptions);
// Try to resolve a custom reader from options
var customReader = configurationOptions.CustomReader?.Invoke(type, autoResolvedReader);
return(customReader ?? autoResolvedReader);
}
public DownloadProgressProvider(ILogger <DownloadProgressProvider> logger,
IDownloadProgressCache downloadProgressCache,
IConfigurationOptions configurationService,
ITextProvider textProvider)
{
_logger = logger;
_downloadProgressCache = downloadProgressCache;
_configurationService = configurationService;
_textProvider = textProvider;
}
public WebClient(IDownloadProgressCache progressCache,
IConfigurationOptions configurationService)
{
_progressCache = progressCache;
_configurationService = configurationService;
if (!string.IsNullOrEmpty(_configurationService.User) && !string.IsNullOrEmpty(_configurationService.Password))
{
Credentials = new System.Net.NetworkCredential(_configurationService.User, _configurationService.Password);
}
}
public static object GetSetting(Type type, IConfiguration configuration, IConfigurationOptions options = null)
{
if (type.GetConfigurationSettingType() == ConfigurationSettingType.None)
{
throw new ArgumentException($"{type} is not a Configuration Setting type.", nameof(type));
}
var factory = Create(configuration, options);
return(factory.CreateConfigurationSetting(type));
}
public void TestSetup()
{
_mockOptions = Substitute.For <IConfigurationOptions>();
_mockOptions.Assemblies.Returns(new[] { Assembly.GetAssembly(GetType()).FullName });
_mockContainer = Substitute.For <IContainer>();
_mockImplFactory = Substitute.For <IImplementationFactory>();
_mockCache = Substitute.For <IGlassTemplateCacheService>();
_mockTypeLoader = Substitute.For <IGlassTypesLoader>();
_builder = new AutofacGlassFactoryBuilder(_mockOptions, _mockContainer, lookup => _mockCache, _mockTypeLoader, _mockImplFactory);
}
public FileDownloader(ILogger <FileDownloader> logger,
IWebClientFactory webClientFactory,
IConfigurationOptions configuration,
ILinksCache linksCache,
IDownloadProgressCache downloadProgressCache,
INotificationService notificationService)
{
_logger = logger;
_webClientFactory = webClientFactory;
_configuration = configuration;
_linksCache = linksCache;
_downloadProgressCache = downloadProgressCache;
_notificationService = notificationService;
}
public DownloadProgressMonitor(ILogger <DownloadProgressMonitor> logger,
IDownloadProgressProvider downloadProgressProvider,
IConfigurationOptions configurationService,
IDownloadProgressCache downloadProgressCache,
ITextProvider textProvider)
{
_logger = logger;
_downloadProgressProvider = downloadProgressProvider;
_downloadProgressCache = downloadProgressCache;
_textProvider = textProvider;
_progressTimer = new Timer(TimeSpan.FromSeconds(configurationService.MonitorPeriodInSecond).TotalMilliseconds);
_progressTimer.Elapsed += ProgressTimer_Elapsed;
}
public IConfigurationReader ResolveInternally(Type type, IConfigurationOptions configurationOptions)
{
if (type.GetConfigurationSettingType() == ConfigurationSettingType.GenericType)
{
var genericType = type.GetGenericTypeOfConfigurationSetting();
return(genericType.IsValueType
? GenericValueTypeConfigurationReader
: GenericNonValueTypeConfigurationReader);
}
else
{
return(ComplexTypeConfigurationReader);
}
}
public SimpleAuthenticationController(IAuthenticationCallbackProvider callbackProvider,
ICache cache,
IConfigurationOptions configurationOptions)
{
if (callbackProvider == null)
{
throw new ArgumentNullException("callbackProvider");
}
_callbackProvider = callbackProvider;
_cache = cache; // Can be null / not provided.
_configurationOptions = configurationOptions; // Can be null / not provided.
_authenticationProviderFactory = new AuthenticationProviderFactory();
}
public SimpleAuthenticationController(IAuthenticationCallbackProvider callbackProvider,
ICache cache,
IConfigurationOptions configurationOptions)
{
if (callbackProvider == null)
{
throw new ArgumentNullException("callbackProvider");
}
_callbackProvider = callbackProvider;
_cache = cache; // Can be null / not provided.
_configurationOptions = configurationOptions; // Can be null / not provided.
_authenticationProviderFactory = new AuthenticationProviderFactory();
}
public void Configure(IConfigurationOptions configurationOptions)
{
if (configurationOptions is not DatabaseConfigurationOptions)
{
throw new ArgumentException($"Invalid IConfigurationsOptions argument; got '{configurationOptions.GetType()}' instead.");
}
var configOptions = configurationOptions as DatabaseConfigurationOptions;
var optionsBuilder = new DbContextOptionsBuilder <StoreManagerContext>();
optionsBuilder.UseSqlServer(configOptions.ConnectionString);
optionsBuilder.LogTo(configOptions.Logger.Log, LogLevel.Information);
var contextOptions = optionsBuilder.Options;
_interfacerManager = new DbSetInterfacerManager(contextOptions);
}
private IKeyName ResolveInternally(Type type, IConfigurationOptions configurationOptions)
{
var prefix = string.Empty;
// Try to resolve via SettingInfo attribute
var attribute = type.CustomAttributes.SingleOrDefault(c => c.AttributeType == typeof(SettingInfo));
if (attribute?.NamedArguments != null)
{
var keyName = attribute.NamedArguments.SingleOrDefault(a => a.MemberName == nameof(SettingInfo.Key));
var value = keyName.TypedValue.Value;
return(new KeyName(prefix, value.ToString()));
}
// Revert to type name
return(new KeyName(prefix, type.Name));
}
public IValueConstructor ResolveInternally(Type configType, IConfigurationOptions configurationOptions)
{
var settingType = configType.GetConfigurationSettingType();
switch (settingType)
{
case ConfigurationSettingType.ComplexType:
return(ComplexTypeValueConstructor);
case ConfigurationSettingType.GenericType:
return(GenericTypeValueConstructor);
case ConfigurationSettingType.None:
break;
default:
throw new ArgumentOutOfRangeException();
}
return(null);
}
private static IConfigurationFactory Create(IConfiguration configuration, IConfigurationOptions options = null)
{
configuration.EnsureNotNull(nameof(configuration));
// Configure the core pieces
var keynameResolver = new KeyNameResolver();
var parserResolver = new ParserResolver();
var configResolver = new ConfigurationReaderResolver();
var constructorResolver = new ValueConstructorResolver();
options = options ?? ConfigurationOptions.Create();
var configuratinFactory = new ConfigurationFactory(configuration,
options,
keynameResolver,
configResolver,
parserResolver,
constructorResolver);
return(configuratinFactory);
}
public static IConfigurationOptions WithGlobalPrefix(this IConfigurationOptions configurationOptions,
string prefix,
Type[] onlyForTheseTypes = null,
Type[] exceptTheseTypes = null)
{
ConfigurationOptionDelegates.CustomKeyNameFunc keyNameResolverFunc = (type, name) =>
{
if (onlyForTheseTypes != null && !onlyForTheseTypes.Contains(type))
{
return(name);
}
if (exceptTheseTypes != null && exceptTheseTypes.Contains(type))
{
return(name);
}
return(new KeyName(prefix, name.QualifiedKeyName));
};
return(configurationOptions.WithNamingScheme(keyNameResolverFunc));
}
public static IConfigurationOptions WithConstructor(this IConfigurationOptions configurationOptions,
ConfigurationOptionDelegates.CustomConstructorFunc resolverFunction)
{
ConfigurationOptionDelegates.CustomConstructorFunc currentResolverFunc = null;
currentResolverFunc = configurationOptions.CustomConstructor;
if (currentResolverFunc == null)
{
configurationOptions.CustomConstructor = resolverFunction;
}
else
{
// Chain the functions
configurationOptions.CustomConstructor = (type, constructor) =>
{
var customConstructor = currentResolverFunc.Invoke(type, constructor);
return(resolverFunction.Invoke(type, customConstructor));
};
}
return(configurationOptions);
}
public SimpleAuthenticationModule(IAuthenticationCallbackProvider callbackProvider, IConfigurationOptions configurationOptions)
{
_callbackProvider = callbackProvider;
_authenticationProviderFactory = new AuthenticationProviderFactory();
_configurationOptions = configurationOptions;
// Define the routes and how they are handled.
Get[RedirectRoute] = parameters => RedirectToProvider(parameters);
Post[RedirectRoute] = parameters => RedirectToProvider(parameters);
Get[CallbackRoute] = parameters => AuthenticateCallback();
// If no Cache type is provided, we'll use a Session as the default.
Before += context =>
{
if (Cache == null)
{
Cache = new SessionCache(context.Request.Session);
}
return null;
};
}
public static ServiceProvider SetupConfigurationDependencies(this IConfiguration configuration,
Assembly[] assemblies,
IConfigurationOptions configurationOptions = null)
{
// Configure your DI Container
// We are using 'Microsoft.Extensions.DependencyInjection' in this example
// but you can use your favourite one like Autofac, StructureMap, Ninject etc
var services = new ServiceCollection();
// Add single IConfiguration
services.AddSingleton(configuration);
// Add configuration options instance
configurationOptions = configurationOptions ?? ConfigurationOptions.Create();
services.AddSingleton <IConfigurationOptions>((s) => configurationOptions);
// Add required resolvers
services.AddSingleton <IResolver <IKeyName>, KeyNameResolver>();
services.AddSingleton <IResolver <IParser>, ParserResolver>();
services.AddSingleton <IResolver <IConfigurationReader>, ConfigurationReaderResolver>();
services.AddSingleton <IResolver <IValueConstructor>, ValueConstructorResolver>();
// Add configuration factory
services.AddSingleton <IConfigurationFactory, ConfigurationFactory>();
var settingTypes = GetConfigurationSettings(assemblies);
foreach (var settingType in settingTypes)
{
services.AddSingleton(settingType, (s) =>
{
var factory = s.GetService <IConfigurationFactory>();
return(factory.CreateConfigurationSetting(settingType));
});
}
return(services.BuildServiceProvider());
}
public static IConfigurationOptions WithNamingScheme(this IConfigurationOptions configurationOptions,
ConfigurationOptionDelegates.CustomKeyNameFunc resolverFunction)
{
ConfigurationOptionDelegates.CustomKeyNameFunc currentResolverFunc = null;
currentResolverFunc = configurationOptions.CustomKeyName;
if (currentResolverFunc == null)
{
configurationOptions.CustomKeyName = resolverFunction;
}
else
{
// Chain the functions
configurationOptions.CustomKeyName = (type, name) =>
{
var customName = currentResolverFunc.Invoke(type, name);
return(resolverFunction.Invoke(type, customName));
};
}
return(configurationOptions);
}
public SimpleAuthenticationModule(IAuthenticationCallbackProvider callbackProvider, IConfigurationOptions configurationOptions)
{
_callbackProvider = callbackProvider;
_authenticationProviderFactory = new AuthenticationProviderFactory();
_configurationOptions = configurationOptions;
// Define the routes and how they are handled.
Get[RedirectRoute] = parameters => RedirectToProvider(parameters);
Post[RedirectRoute] = parameters => RedirectToProvider(parameters);
Get[CallbackRoute] = parameters => AuthenticateCallback();
// If no Cache type is provided, we'll use a Session as the default.
Before += context =>
{
if (Cache == null)
{
Cache = new SessionCache(context.Request.Session);
}
return(null);
};
}
public ConfigurationFactory(IConfiguration configuration,
IConfigurationOptions configurationOptions,
IResolver <IKeyName> keyNameResolver,
IResolver <IConfigurationReader> configurationReaderResolver,
IResolver <IParser> parserResolver,
IResolver <IValueConstructor> valueConstructorResolver,
IConfigLogger configLogger = null)
{
_configuration = configuration
.EnsureNotNull(nameof(configuration));
_configurationOptions = configurationOptions
.EnsureNotNull(nameof(configurationOptions));
_keyNameResolver = keyNameResolver
.EnsureNotNull(nameof(keyNameResolver));
_configurationReaderResolver = configurationReaderResolver
.EnsureNotNull(nameof(configurationReaderResolver));
_parserResolver = parserResolver
.EnsureNotNull(nameof(parserResolver));
_valueConstructorResolver = valueConstructorResolver
.EnsureNotNull(nameof(valueConstructorResolver));
StaticLoggingHelper.ConfigLogger = configLogger;
}
/// <summary>
/// Initializes a new instance of the ConfigurableActiveRecordGenerator class.
/// </summary>
/// <param name="configOptions"></param>
public ConfigurableActiveRecordGenerator(IConfigurationOptions configOptions)
{
base.ConfigOptions = configOptions;
}
public EnumerationGenerator(IDbProvider dbProvider, IConfigurationOptions configOptions, NameProvider nameProvider)
{
_dbProvider = dbProvider;
_configOptions = configOptions;
_nameProvider = nameProvider;
}
public SimpleAuthenticationController(IAuthenticationCallbackProvider callbackProvider,
IConfigurationOptions configurationOptions)
: this(callbackProvider, null, configurationOptions)
{
}
private NameProvider InitializeNameProvider(IConfigurationOptions config, Ioc ioc)
{
Log.WriteLine("Initializing NameProvider");
var nameProvider = ioc.Get<NameProvider>() ?? new NameProvider();
nameProvider.TablePrefixes.AddRange(config.OnlyTablesWithPrefix);
nameProvider.TablePrefixes.AddRange(config.SkipTablesWithPrefix);
nameProvider.EnumReplacements = config.EnumReplacements;
return nameProvider;
}
private void EnsureOutputPath(IConfigurationOptions config)
{
Log.Write("Ensuring output path... ");
string outputPath = config.OutputPath;
if (!Path.IsPathRooted(outputPath))
{
outputPath = Path.Combine(_configDirectory, outputPath);
}
if (!Directory.Exists(outputPath))
{
Directory.CreateDirectory(outputPath);
}
config.OutputPath = outputPath;
Log.WriteLine(config.OutputPath);
}
private void EnsureEnumOutputPath(IConfigurationOptions config)
{
if (config.Enums.Count() == 0)
return;
Log.Write("Ensuring enum output path... ");
string enumOutputPath = config.EnumOutputPath;
if (!Path.IsPathRooted(enumOutputPath))
{
enumOutputPath = Path.Combine(_configDirectory, enumOutputPath);
}
if (!Directory.Exists(enumOutputPath))
{
Directory.CreateDirectory(enumOutputPath);
}
config.EnumOutputPath = enumOutputPath;
Log.WriteLine(config.EnumOutputPath);
}
private void LoadEnumReplacements(XmlNode configNode, IConfigurationOptions options)
{
var nodeList = configNode.SelectNodes("./enums/replacement");
foreach (XmlNode node in nodeList)
{
string lookfor = node.Attributes["lookfor"] != null ? node.Attributes["lookfor"].Value : String.Empty;
string replacewith = node.Attributes["replacewith"] != null ? node.Attributes["replacewith"].Value : String.Empty;
if (String.IsNullOrEmpty(lookfor) || String.IsNullOrEmpty(replacewith))
{
continue;
}
options.EnumReplacements.Add(lookfor, replacewith);
}
}
public static void Initialize(IStorageRepository storage = null, ISerializer serializer = null, IConfigurationOptions configurationOptions = null)
{
s_storeManager ??= new StoreManagerApplication(storage, serializer, configurationOptions);
}
public CodeRunnerImpl(CodeRunnerConfig codeRunnerConfig)
{
_codeRunnerConfig = codeRunnerConfig;
_options = _codeRunnerConfig.Options;
}
