private void LoadPropertiesInContainer(LoaderProperties loaderProperty, string moduleName, string configFile)
{
string cacheKeyImplementation = moduleName + loaderProperty.ImplementationAsString;
string cacheKeyInterface = moduleName + loaderProperty.InterfaceAsString;
loaderProperty.ImplementationAsType = _CachingService.Get <Type>(cacheKeyImplementation);
if (loaderProperty.ImplementationAsType == null)
{
loaderProperty.ImplementationAsType = Type.GetType(loaderProperty.ImplementationAsString, true);
_CachingService.Insert(cacheKeyImplementation, loaderProperty.ImplementationAsType);
}
loaderProperty.InterfaceAsType = _CachingService.Get <Type>(cacheKeyInterface);
if (loaderProperty.InterfaceAsType == null)
{
loaderProperty.InterfaceAsType = Type.GetType(loaderProperty.InterfaceAsString);
_CachingService.Insert(cacheKeyInterface, loaderProperty.InterfaceAsType);
}
TypeInfo typeInfo = loaderProperty.ImplementationAsType.GetTypeInfo();
if (typeInfo.ImplementedInterfaces.Contains(loaderProperty.InterfaceAsType))
{
_DependencyInjectionContainer.Add(loaderProperty.ImplementationAsType, loaderProperty.InterfaceAsType, cacheKeyImplementation);
}
else
{
throw new Exception($"Type: {loaderProperty.ImplementationAsString} doesn't implement {loaderProperty.InterfaceAsString} in {configFile}");
}
}
public static IUnityContainer Configure(IUnityContainer unityContainer, LoaderProperties loaderProps, Properties props)
{
var container = RegisterTypes(unityContainer, loaderProps, props);
ObjectFactoryConfigurator.DefaultContainer = container;
return(container);
}
public void ConfigureContainer(IUnityContainer container)
{
var loaderProps = new LoaderProperties();
Configuration.Bind("Loader", loaderProps);
UnityConfig.Configure(container, loaderProps);
}
public static IUnityContainer Configure(
IUnityContainer container,
LoaderProperties loaderProperties,
IntegrationProperties integrationProperties,
Properties properties)
{
container = RegisterTypes(container, loaderProperties, integrationProperties, properties);
ObjectFactoryConfigurator.DefaultContainer = container;
return(container);
}
public static Dictionary <string, string> GetCustomSettings(string loaderName, ELoaderType loaderType, KraftModuleConfigurationSettings moduleSettings, bool isIterator = false)
{
LoaderProperties loaderProperties = GetLoaderProperties(loaderName, moduleSettings, loaderType, isIterator);
if (loaderProperties != null)
{
return(loaderProperties.CustomSettings);
}
else
{
throw new NullReferenceException($"Loader properties for loader:{loaderName} are null (internal Dictionary<string, string> GetCustomSettings(string loaderName, Enumerations.ELoaderType loaderType))");
}
}
public void ConfigureContainer(IUnityContainer container)
{
var loaderProps = new LoaderProperties();
Configuration.Bind("Loader", loaderProps);
var props = new Properties();
Configuration.Bind("Properties", props);
ComponentInfo.SetLicense(props.DocumentLicenceKey);
UnityConfig.Configure(container, loaderProps, props);
}
public void ConfigureContainer(IUnityContainer container)
{
var loaderProps = new LoaderProperties();
Configuration.Bind("Loader", loaderProps);
var props = new Properties();
Configuration.Bind("Properties", props);
var integrationProps = new IntegrationProperties();
Configuration.Bind("Integration", integrationProps);
UnityConfig.Configure(container, loaderProps, integrationProps, props);
}
public static IUnityContainer RegisterTypes(
IUnityContainer container,
LoaderProperties loaderProperties,
IntegrationProperties integrationProperties,
Properties properties)
{
//fix Diagnostic extension
container.RegisterType <ILoggerFactory, LoggerFactory>(
new ContainerControlledLifetimeManager(), new InjectionConstructor(new ResolvedParameter <IEnumerable <ILoggerProvider> >())
);
container.AddExtension(new Diagnostic());
container.RegisterType <DynamicResourceDictionaryContainer>();
container.RegisterType <ProcessRemoteValidationIf>();
container.AddNewExtension <LoaderConfigurationExtension>();
container.AddNewExtension <ActionContainerConfiguration>();
container.AddNewExtension <TaskContainerConfiguration>();
container.AddNewExtension <ValidationConfiguration>();
container.RegisterType <IConnectionProvider, CoreConnectionProvider>();
container.RegisterType <ICustomerProvider, CustomerProvider>();
container.RegisterType <IIdentityProvider, CoreIdentityWithSessionProvider>();
// логируем в консоль
//container.RegisterInstance<ILogger>(new TextWriterLogger(Console.Out));
container.RegisterInstance <ILogger>(new NLogLogger("NLogClient.config"));
container.RegisterType <IContentDefinitionService, ContentDefinitionService>();
container.RegisterType <DefinitionEditorService>();
container
.RegisterType <IXmlProductService, XmlProductService>()
.RegisterType <IUserProvider, HttpContextUserProvider>()
.RegisterType <IQPNotificationService, QPNotificationService>()
// change default provider to filesystem-based one since it does not require app to recompile on changes.
// AppDataProductControlProvider does not cache reads from disk
.RegisterType <IProductControlProvider, ContentBasedProductControlProvider>();
container.RegisterFactory <CustomActionService>(c =>
{
var customer = c.Resolve <IConnectionProvider>().GetCustomer();
return(new CustomActionService(
new QpConnectionInfo(customer.ConnectionString, (DatabaseType)customer.DatabaseType),
1));
});
container.RegisterType <IRegionTagReplaceService, RegionTagService>();
container.RegisterType <IRegionService, RegionService>();
container.RegisterType <INotesService, NotesFromContentService>();
container.RegisterType <IProductUpdateService, ProductUpdateService>();
//container.RegisterType<IRegionTagReplaceService, RegionTagReplaceService>();
BindingValueProviderFactory.Current = new DefaultBindingValueProviderFactory(new QPModelBindingValueProvider());
container.RegisterType <ILoggerFactory, LoggerFactory>(new ContainerControlledLifetimeManager(), new InjectionConstructor(new ResolvedParameter <IEnumerable <ILoggerProvider> >()));
container.RegisterType <ITaskService, TaskService>();
container.RegisterType <IProductRelevanceService, ProductRelevanceService>();
var entitiesAssembly = typeof(IArticleFilter).Assembly;
foreach (var filterClass in entitiesAssembly.GetExportedTypes().Where(x => typeof(IArticleFilter).IsAssignableFrom(x) && x.IsClass && !x.IsAbstract))
{
container.RegisterType(typeof(IArticleFilter), filterClass, filterClass.Name);
}
container.RegisterType <IProductChangeSubscriber, RelevanceUpdaterOnProductChange>("RelevanceUpdaterOnProductChange");
container.RegisterFactory <IProductChangeNotificator>(x =>
{
var notificator = new ProductChangeNotificator(x.Resolve <ILogger>());
notificator.AddSubscribers(x.ResolveAll <IProductChangeSubscriber>());
return(notificator);
}, new ContainerControlledLifetimeManager());
container.RegisterType <IContentProvider <NotificationChannel>, NotificationChannelProvider>();
container.AddNewExtension <FormattersContainerConfiguration>();
container.RegisterType <StructureCacheTracker>();
container.RegisterType <IWarmUpProvider, ProductLoaderWarmUpProvider>();
container.RegisterSingleton <WarmUpRepeater>();
switch (loaderProperties.SettingsSource)
{
case SettingsSource.Content:
container.RegisterType <ISettingsService, SettingsFromContentCoreService>(new InjectionConstructor(typeof(VersionedCacheProviderBase), typeof(IConnectionProvider), loaderProperties.SettingsContentId));
break;
case SettingsSource.AppSettings:
container.RegisterType <ISettingsService, SettingsFromQpCoreService>();
break;
}
switch (loaderProperties.DefaultSerializer)
{
case DefaultSerializer.Json:
container.RegisterType <IArticleFormatter, JsonProductFormatter>();
break;
case DefaultSerializer.Xml:
container.RegisterType <IArticleFormatter, XmlProductFormatter>();
break;
}
var connection = container.Resolve <IConnectionProvider>();
if (connection.QPMode)
{
container
.RegisterConsolidationCache(properties.AutoRegisterConsolidationCache)
.As <IFactory>()
.With <FactoryWatcher>(properties.WatcherInterval)
.Watch();
}
else
{
container.RegisterType <ICustomerProvider, SingleCustomerCoreProvider>()
.RegisterConsolidationCache(properties.AutoRegisterConsolidationCache, SingleCustomerCoreProvider.Key)
.As <IFactory>()
.With <FactoryWatcher>()
.WithCallback((sender, e) => { container.Resolve <WarmUpRepeater>().Start(); })
.Watch();
}
if (connection.QPMode || connection.UseQPMonitoring)
{
container.RegisterQpMonitoring();
}
else
{
container.RegisterNonQpMonitoring();
}
RegisterExtraValidation(container, integrationProperties);
return(container);
}
internal static T GetPlugin <T>(string key, DependencyInjectionContainer dependencyInjectionContainer, KraftModuleConfigurationSettings kraftConfigurationSettings, ELoaderType pluginType, bool isIterator = false) where T : class
{
LoaderProperties loaderProperties = GetLoaderProperties(key, kraftConfigurationSettings, pluginType, isIterator);
return(dependencyInjectionContainer.Get(loaderProperties.InterfaceAsType, kraftConfigurationSettings.ModuleName + loaderProperties.ImplementationAsString) as T);
}
private static IUnityContainer RegisterTypes(IUnityContainer unityContainer, LoaderProperties loaderProps, Properties props)
{
if (props == null)
{
throw new ArgumentNullException(nameof(props));
}
unityContainer.RegisterType <DynamicResourceDictionaryContainer>();
unityContainer.RegisterType <ProcessRemoteValidationIf>();
unityContainer.AddNewExtension <LoaderConfigurationExtension>();
unityContainer.AddNewExtension <QPAutopublishContainerConfiguration>();
unityContainer.AddNewExtension <FormattersContainerConfiguration>();
unityContainer.AddNewExtension <APIContainerConfiguration>();
unityContainer.AddNewExtension <QPAPIContainerConfiguration>();
unityContainer.RegisterType <IConnectionProvider, CoreConnectionProvider>();
unityContainer.RegisterType <ICustomerProvider, CustomerProvider>();
unityContainer.RegisterType <IIdentityProvider, CoreIdentityProvider>();
if (props.UseAuthorization)
{
unityContainer.RegisterType <IUserProvider, IdentityUserProvider>();
}
else
{
unityContainer.RegisterType <IUserProvider, ConfigurableUserProvider>();
}
unityContainer.RegisterType <ISettingsService, SettingsFromContentCoreService>();
unityContainer.RegisterType <IRegionTagReplaceService, RegionTagService>();
unityContainer.RegisterType <IRegionService, RegionService>();
unityContainer.RegisterType <IXmlProductService, XmlProductService>();
unityContainer.RegisterType <IContentDefinitionService, ContentDefinitionService>();
unityContainer.RegisterType <INotesService, NotesFromContentService>();
unityContainer.RegisterType <IDocumentGenerator, DocumentGenerator>();
unityContainer.RegisterType <IContentProvider <NotificationChannel>, NotificationChannelProvider>();
unityContainer.RegisterType <StructureCacheTracker>();
unityContainer.RegisterType <IWarmUpProvider, ProductLoaderWarmUpProvider>();
unityContainer.RegisterSingleton <WarmUpRepeater>();
switch (loaderProps.SettingsSource)
{
case SettingsSource.Content:
unityContainer.RegisterType <ISettingsService, SettingsFromContentCoreService>();
break;
case SettingsSource.AppSettings:
unityContainer.RegisterType <ISettingsService, SettingsFromQpCoreService>();
break;
}
switch (loaderProps.DefaultSerializer)
{
case DefaultSerializer.Json:
unityContainer.RegisterType <IArticleFormatter, JsonProductFormatter>();
break;
case DefaultSerializer.Xml:
unityContainer.RegisterType <IArticleFormatter, XmlProductFormatter>();
break;
}
var connection = unityContainer.Resolve <IConnectionProvider>();
if (connection.QPMode)
{
unityContainer
.RegisterConsolidationCache(props.AutoRegisterConsolidationCache)
.As <IFactory>()
.With <FactoryWatcher>(props.WatcherInterval)
.Watch();
}
else
{
unityContainer.RegisterType <ICustomerProvider, SingleCustomerCoreProvider>();
unityContainer
.RegisterConsolidationCache(props.AutoRegisterConsolidationCache, SingleCustomerCoreProvider.Key)
.As <IFactory>()
.With <FactoryWatcher>()
.WithCallback((sender, e) => { unityContainer.Resolve <WarmUpRepeater>().Start(); })
.Watch();
}
if (connection.QPMode || connection.UseQPMonitoring)
{
unityContainer.RegisterQpMonitoring();
}
else
{
unityContainer.RegisterNonQpMonitoring();
}
return(unityContainer);
}
public static IUnityContainer RegisterTypes(IUnityContainer container, LoaderProperties loaderProps)
{
//fix Diagnostic extension
container.RegisterType <ILoggerFactory, LoggerFactory>(
new ContainerControlledLifetimeManager(), new InjectionConstructor(new ResolvedParameter <IEnumerable <ILoggerProvider> >())
);
container.AddExtension(new Diagnostic());
container.RegisterType <DynamicResourceDictionaryContainer>();
container.RegisterType <ProcessRemoteValidationIf>();
container.RegisterType <IConnectionProvider, CoreConnectionProvider>();
container.RegisterType <ICustomerProvider, CustomerProvider>();
container.RegisterType <IIdentityProvider, CoreIdentityProvider>();
container.AddNewExtension <ActionContainerConfiguration>();
container.AddNewExtension <LoaderConfigurationExtension>();
container.RegisterType <ITasksRunner, TasksRunner>();
container.RegisterType <IUserProvider, HttpContextUserProvider>();
container.RegisterType <IContentDefinitionService, ContentDefinitionService>();
container.RegisterFactory <Func <ITaskService> >(x => new Func <ITaskService>(() => x.Resolve <ITaskService>()));
container.RegisterFactory <Func <string, int, ITask> >(x => new Func <string, int, ITask>((key, userId) => GetTaskByKey(key, userId, x)));
container.RegisterType <ITaskService, TaskService>();
container.RegisterType <IQPNotificationService, QPNotificationService>();
container.RegisterType <IRegionTagReplaceService, RegionTagService>();
container.RegisterType <IRegionService, RegionService>();
container.RegisterType <IXmlProductService, XmlProductService>();
container.RegisterType <IProductRelevanceService, ProductRelevanceService>();
container.RegisterType <ISchedulerFactory, SchedulerFactory>();
container.RegisterSingleton <ActionsService>();
container.RegisterType <IContentProvider <NotificationChannel>, NotificationChannelProvider>();
container.AddNewExtension <FormattersContainerConfiguration>();
var autoRegister = false;
var watcherInterval = TimeSpan.FromMinutes(1);
var connection = container.Resolve <IConnectionProvider>();
if (connection.QPMode)
{
container.RegisterConsolidationCache(autoRegister).As <IFactory>().With <FactoryWatcher>(watcherInterval).As <IFactoryWatcher>();
}
else
{
container.RegisterType <ICustomerProvider, SingleCustomerCoreProvider>();
container.RegisterConsolidationCache(autoRegister, SingleCustomerCoreProvider.Key).As <IFactory>().With <FactoryWatcher>().As <IFactoryWatcher>();
}
if (connection.QPMode || connection.UseQPMonitoring)
{
container.RegisterQpMonitoring();
}
else
{
container.RegisterNonQpMonitoring();
}
switch (loaderProps.SettingsSource)
{
case SettingsSource.Content:
container.RegisterType <ISettingsService, SettingsFromContentCoreService>();
break;
case SettingsSource.AppSettings:
container.RegisterType <ISettingsService, SettingsFromQpCoreService>();
break;
}
switch (loaderProps.DefaultSerializer)
{
case DefaultSerializer.Json:
container.RegisterType <IArticleFormatter, JsonProductFormatter>();
break;
case DefaultSerializer.Xml:
container.RegisterType <IArticleFormatter, XmlProductFormatter>();
break;
}
return(container);
}
public static void Apply(IEnumerable <Type> types, TCompiler compiler, out string extensionName, string flavor = null, LoaderProperties props = null)
{
Create(types, out extensionName, flavor)
?.Invoke(compiler, props);
}
