public MefModuleManager(
IModuleInitializer moduleInitializer,
IModuleCatalog moduleCatalog,
ILoggerFacade loggerFacade)
: base(moduleInitializer, moduleCatalog, loggerFacade)
{
}
/// <summary>
/// Initializes the modules.
/// </summary>
/// <param name="catalog">The catalog.</param>
public void InitializeModules(IModuleCatalog catalog)
{
var moduleEvent = EventManager.GetEvent<ModuleEvent>();
// Iterate through each module for processing
foreach (var module in catalog.GetModuleList())
{
// If the module is already initialized then don't
// process - we only initialize once
if (module.IsInitialized)
continue;
module.Initialize();
module.IsInitialized = true;
// Raise an event for any subscribers
moduleEvent.Publish(new ModuleEventArgs
{
Module = module,
EventType = ModuleEventType.Initialized
});
}
// Publish all modules initialized event
moduleEvent.Publish(new ModuleEventArgs
{
EventType = ModuleEventType.AllModulesInitialized
});
}
public ZipPackageService(IModuleCatalog moduleCatalog, IModuleManifestProvider manifestProvider, string installedPackagesPath, string sourcePackagesPath)
{
_moduleCatalog = moduleCatalog;
_manifestProvider = manifestProvider;
_installedPackagesPath = installedPackagesPath;
_sourcePackagesPath = sourcePackagesPath;
}
public PlugInHomeViewModel(IRegionManager regionManager, IModuleCatalog moduleCatalog)
{
_regionManager = regionManager;
_moduleCatalog = moduleCatalog;
PlugInNames = new ObservableCollection<string>();
OpenSelectedPlugInCommand = new DelegateCommand(OpenSelectedPlugIn);
}
public ModulesController(IModuleCatalog moduleCatalog, IModuleInstaller moduleInstaller, IPushNotificationManager pushNotifier, IUserNameResolver userNameResolver, ISettingsManager settingsManager)
{
_moduleCatalog = moduleCatalog;
_moduleInstaller = moduleInstaller;
_pushNotifier = pushNotifier;
_userNameResolver = userNameResolver;
_settingsManager = settingsManager;
}
/// <summary>
/// Adds the catalog to the list of catalogs
/// </summary>
/// <param name="catalog">The catalog to add.</param>
public void AddCatalog(IModuleCatalog catalog)
{
if (catalog == null)
{
throw new ArgumentNullException("catalog");
}
this.catalogs.Add(catalog);
}
public MainModule(
IRegionManager regionManager,
IEventAggregator eventAggregator,
IUnityContainer unityContainer,
IModuleManager moduleManager,
IModuleCatalog moduleCatalog) :
base(regionManager, eventAggregator, unityContainer, moduleManager, moduleCatalog)
{
}
public SecurityService(Func<IPlatformRepository> platformRepository, Func<ApplicationUserManager> userManagerFactory, IApiAccountProvider apiAccountProvider,
IModuleCatalog moduleCatalog, IPermissionScopeService permissionScopeService, ICacheManager<object> cacheManager)
{
_platformRepository = platformRepository;
_userManagerFactory = userManagerFactory;
_apiAccountProvider = apiAccountProvider;
_cacheManager = cacheManager;
_moduleCatalog = moduleCatalog;
_permissionScopeService = permissionScopeService;
}
/// <summary>
/// Initializes an instance of the <see cref="ModuleManager"/> class.
/// </summary>
/// <param name="moduleInitializer">Service used for initialization of modules.</param>
/// <param name="moduleCatalog">Catalog that enumerates the modules to be loaded and initialized.</param>
/// <param name="loggerFacade">Logger used during the load and initialization of modules.</param>
public ModuleManager(IModuleInitializer moduleInitializer, IModuleCatalog moduleCatalog, ILoggerFacade loggerFacade)
{
if (moduleInitializer == null) throw new ArgumentNullException("moduleInitializer");
if (moduleCatalog == null) throw new ArgumentNullException("moduleCatalog");
if (loggerFacade == null) throw new ArgumentNullException("loggerFacade");
Contract.EndContractBlock();
this.moduleInitializer = moduleInitializer;
this.moduleCatalog = moduleCatalog;
this.loggerFacade = loggerFacade;
}
/// <summary>
/// Initializes an instance of the <see cref="ModuleManager"/> class.
/// </summary>
/// <param name="moduleInitializer">Service used for initialization of modules.</param>
/// <param name="moduleCatalog">Catalog that enumerates the modules to be loaded and initialized.</param>
public ModuleManager(IModuleInitializer moduleInitializer, IModuleCatalog moduleCatalog)
{
if (moduleInitializer == null)
throw new ArgumentNullException("moduleInitializer");
if (moduleCatalog == null)
throw new ArgumentNullException("moduleCatalog");
_moduleInitializer = moduleInitializer;
_moduleCatalog = moduleCatalog;
}
/// <summary>
/// Initializes an instance of the <see cref="ModuleManager"/> class.
/// </summary>
/// <param name="moduleInitializer">Service used for initialization of modules.</param>
/// <param name="moduleCatalog">Catalog that enumerates the modules to be loaded and initialized.</param>
/// <param name="loggerFacade">Logger used during the load and initialization of modules.</param>
public ModuleManager(IModuleInitializer moduleInitializer, IModuleCatalog moduleCatalog, ILoggerFacade loggerFacade)
{
if (moduleInitializer == null)
throw new ArgumentNullException(nameof(moduleInitializer));
if (moduleCatalog == null)
throw new ArgumentNullException(nameof(moduleCatalog));
if (loggerFacade == null)
throw new ArgumentNullException(nameof(loggerFacade));
this.moduleInitializer = moduleInitializer;
this.moduleCatalog = moduleCatalog;
this.loggerFacade = loggerFacade;
}
/// <summary>
/// Initializes an instance of the <see cref="ModuleManager"/> class.
/// </summary>
/// <param name="moduleInitializer">Service used for initialization of modules.</param>
/// <param name="moduleCatalog">Catalog that enumerates the modules to be loaded and initialized.</param>
/// <param name="loggerFacade">Logger used during the load and initialization of modules.</param>
public ModuleManager(IModuleInitializer moduleInitializer, IModuleCatalog moduleCatalog)
{
if (moduleInitializer == null)
{
throw new ArgumentNullException("moduleInitializer");
}
if (moduleCatalog == null)
{
throw new ArgumentNullException("moduleCatalog");
}
this.moduleInitializer = moduleInitializer;
this.moduleCatalog = moduleCatalog;
this.loggerFacade = ServiceLocator.GetInstance<ILogManager>().GetSystemLogger();
}
/// <summary>
/// Initializes a new instance of the <see cref="ModuleManagerViewModel" /> class.
/// </summary>
/// <exception cref="System.ArgumentNullException">The <paramref name="moduleCatalog"/> is <c>null</c>.</exception>
/// <exception cref="System.ArgumentNullException">The <paramref name="moduleManager"/> is <c>null</c>.</exception>
/// <exception cref="System.ArgumentNullException">The <paramref name="pleaseWaitService"/> is <c>null</c>.</exception>
public ModuleManagerViewModel(IModuleCatalog moduleCatalog, IModuleManager moduleManager, IPleaseWaitService pleaseWaitService)
{
Argument.IsNotNull(() => moduleManager);
Argument.IsNotNull(() => moduleCatalog);
Argument.IsNotNull(() => pleaseWaitService);
_moduleManager = moduleManager;
_pleaseWaitService = pleaseWaitService;
var modules = moduleCatalog.Modules;
var moduleTemplates = modules.Select(moduleInfo => new ModuleTemplate(moduleInfo)).OrderBy(template => template.ModuleName);
Modules = new ObservableCollection<ModuleTemplate>(moduleTemplates);
LoadModuleCommand = new Command<ModuleTemplate>(LoadModuleCommandExecute, LoadModuleCommandCanExecute);
}
protected RolodexModule(
IRegionManager regionManager,
IEventAggregator eventAggregator,
IUnityContainer unityContainer,
IModuleManager moduleManager,
IModuleCatalog moduleCatalog)
{
_regionManager = regionManager;
_eventAggregator = eventAggregator;
_unityContainer = unityContainer;
_moduleManager = moduleManager;
_moduleCatalog = moduleCatalog;
lock (Lock)
{
if (_serviceLoader == null)
{
_serviceLoader = UnityContainer.Resolve<IRolodexServiceLoader>();
}
}
}
/// <summary>
/// Initializes an instance of the <see cref="ModuleManager"/> class.
/// </summary>
/// <param name="moduleInitializer">Service used for initialization of modules.</param>
/// <param name="moduleCatalog">Catalog that enumerates the modules to be loaded and initialized.</param>
/// <param name="loggerFacade">Logger used during the load and initialization of modules.</param>
public ModuleManager(IModuleInitializer moduleInitializer, IModuleCatalog moduleCatalog, ILog loggerFacade)
{
if (moduleInitializer == null)
{
throw new ArgumentNullException("moduleInitializer");
}
if (moduleCatalog == null)
{
throw new ArgumentNullException("moduleCatalog");
}
if (loggerFacade == null)
{
throw new ArgumentNullException("loggerFacade");
}
this.moduleInitializer = moduleInitializer;
this.moduleCatalog = moduleCatalog;
this.loggerFacade = loggerFacade;
}
/// <summary>
/// Initializes a new instance of the <see cref="NuGetModuleTypeLoader" /> class.
/// </summary>
/// <param name="moduleCatalog">
/// </param>
/// <exception cref="System.ArgumentNullException">The <paramref name="moduleCatalog" /> is <c>null</c>.</exception>
/// <exception cref="System.ArgumentNullException">There are no available any NuGet based module catalog.</exception>
public NuGetModuleTypeLoader(IModuleCatalog moduleCatalog)
{
Argument.IsNotNull(() => moduleCatalog);
if (moduleCatalog is INuGetBasedModuleCatalog)
{
_moduleCatalogs = new List<INuGetBasedModuleCatalog> { moduleCatalog as INuGetBasedModuleCatalog }.AsReadOnly();
}
if (moduleCatalog is CompositeModuleCatalog)
{
var compositeModuleCatalog = moduleCatalog as CompositeModuleCatalog;
_moduleCatalogs = compositeModuleCatalog.LeafCatalogs.OfType<INuGetBasedModuleCatalog>().ToList().AsReadOnly();
}
if (_moduleCatalogs == null || _moduleCatalogs.Count == 0)
{
throw new InvalidOperationException("There are no available any NuGet based module catalog");
}
}
public AtomicModuleLoader(IModuleCatalog catalog, IModuleManager moduleManager)
{
this.moduleCatalog = catalog;
this.moduleManager = moduleManager;
}
/// <summary>
/// Adds the <see cref="IModule"/>
/// </summary>
/// <typeparam name="T">Type of <see cref="IModule"/></typeparam>
/// <param name="catalog">The <see cref="IModuleCatalog"/> to add the <see cref="IModule"/> to.</param>
/// <param name="name">The name of the <see cref="IModule"/></param>
/// <param name="dependsOn">The names of the <see cref="IModule"/>'s that should be loaded when this <see cref="IModule"/> is loaded.</param>
/// <returns>The <see cref="IModuleCatalog"/></returns>
public static IModuleCatalog AddModule <T>(this IModuleCatalog catalog, string name, params string[] dependsOn)
where T : IModule =>
catalog.AddModule <T>(name, InitializationMode.WhenAvailable, dependsOn);
protected override void ConfigureModuleCatalog(IModuleCatalog moduleCatalog)
{
// TODO: split desktop project on separate modules.
}
protected override void ConfigureModuleCatalog(IModuleCatalog moduleCatalog)
{
moduleCatalog.AddModule <ModuleForIActiveAwareCommands.ModuleForIActiveAwareCommandsModule>();
}
public static IModuleCatalog AddModule <T>(this IModuleCatalog catalog, string name)
where T : IModule =>
catalog.AddModule <T>(name, InitializationMode.WhenAvailable);
public PlatformExportImportManager(ISecurityService securityService, IRoleManagementService roleManagementService, ISettingsManager settingsManager, IDynamicPropertyService dynamicPropertyService, IModuleCatalog moduleCatalog, ICacheManager<object> cacheManager, INotificationTemplateService notificationTemplateService)
{
_dynamicPropertyService = dynamicPropertyService;
_securityService = securityService;
_roleManagementService = roleManagementService;
_settingsManager = settingsManager;
_moduleCatalog = moduleCatalog;
_cacheManager = cacheManager;
_notificationTemplateService = notificationTemplateService;
_manifestPartUri = PackUriHelper.CreatePartUri(new Uri("Manifest.json", UriKind.Relative));
_platformEntriesPartUri = PackUriHelper.CreatePartUri(new Uri("PlatformEntries.json", UriKind.Relative));
}
//protected override IModuleCatalog CreateModuleCatalog()
//{
// return new DirectoryModuleCatalog() { ModulePath = @".\Modules" };
//}
protected override void ConfigureModuleCatalog(IModuleCatalog moduleCatalog)
{
moduleCatalog.AddModule <SupplementsModule>();
}
protected override void ConfigureModuleCatalog(IModuleCatalog moduleCatalog)
{
moduleCatalog.AddModule <mteGuides.mteGuidesModule>();
moduleCatalog.AddModule <mteWayBills.mteWayBillsModule>();
}
public static IModuleCatalog AddTestDataInitializierModule(this IModuleCatalog moduleCatalog)
{
moduleCatalog.AddModule("TestDataInitializierModule", new TestDataInitializierModule());
return(moduleCatalog);
}
/// <summary>
/// Determines whether the specified module catalog is the catalog type. Also checks inner catalogs
/// when the catalog is a <see cref="CompositeModuleCatalog" />.
/// </summary>
/// <param name="moduleCatalog">The module catalog.</param>
/// <param name="typeToCheck">The type to check.</param>
/// <returns><c>true</c> if the module catalog is of the specified type; otherwise, <c>false</c>.</returns>
public static bool IsCatalogType(this IModuleCatalog moduleCatalog, Type typeToCheck)
{
Argument.IsNotNull(() => moduleCatalog);
Argument.IsNotNull(() => typeToCheck);
var moduleCatalogType = moduleCatalog.GetType();
if (typeToCheck.IsInterfaceEx())
{
var implementsInterface = (from iface in moduleCatalogType.GetInterfacesEx()
where string.Equals(iface.FullName, typeToCheck.FullName)
select iface).Any();
if (implementsInterface)
{
return(true);
}
}
else if (typeToCheck.IsAssignableFromEx(moduleCatalogType))
{
return(true);
}
var innerCatalogs = new List <IModuleCatalog>();
var compositeModuleCatalog = moduleCatalog as CompositeModuleCatalog;
if (compositeModuleCatalog != null)
{
innerCatalogs.AddRange(compositeModuleCatalog.LeafCatalogs);
}
else
{
if (moduleCatalogType.FullName.Contains("Composite"))
{
try
{
var leafCatalogs = PropertyHelper.GetPropertyValue(moduleCatalog, "LeafCatalogs", false);
foreach (var leafCatalog in (IEnumerable)leafCatalogs)
{
var finalLeafCatalog = leafCatalog as IModuleCatalog;
if (finalLeafCatalog != null)
{
innerCatalogs.Add(finalLeafCatalog);
}
}
}
catch (Exception ex)
{
Log.Warning(ex, "Failed to get LeafCatalogs from the (expected) composite catalog '{0}'", moduleCatalogType.GetSafeFullName());
}
}
}
foreach (var innerModuleCatalog in innerCatalogs)
{
if (innerModuleCatalog.IsCatalogType(typeToCheck))
{
return(true);
}
}
return(false);
}
protected override void ConfigureModuleCatalog(IModuleCatalog moduleCatalog)
{
base.ConfigureModuleCatalog(moduleCatalog);
moduleCatalog.AddModule <CommonDialogPackModule>();
}
/// <summary>
/// Determines whether the specified module catalog is the catalog type. Also checks inner catalogs
/// when the catalog is a <see cref="CompositeModuleCatalog"/>.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="moduleCatalog">The module catalog.</param>
/// <returns><c>true</c> if the module catalog is of the specified type; otherwise, <c>false</c>.</returns>
public static bool IsCatalogType <T>(this IModuleCatalog moduleCatalog)
{
return(IsCatalogType(moduleCatalog, typeof(T)));
}
protected override void ConfigureModuleCatalog(IModuleCatalog moduleCatalog)
{
moduleCatalog.AddModule <CommonServicesModule>();
moduleCatalog.AddModule <MainModule.MainModule>();
}
protected override void ConfigureModuleCatalog(IModuleCatalog moduleCatalog)
{
moduleCatalog.AddModule <GUIModule>();
base.ConfigureModuleCatalog(moduleCatalog);
}
public ModuleManagerModule(IModuleManagerService managerService, IModuleCatalog moduleCatalog)
{
ModuleManagerService = managerService;
ModuleCatalog = moduleCatalog;
}
protected override void ConfigureModuleCatalog(IModuleCatalog moduleCatalog)
{
base.ConfigureModuleCatalog(moduleCatalog);
moduleCatalog.AddModule(typeof(ProjectsModule));
}
public DynamicContentLoader(IModuleCatalog moduleCatalog,
IModuleManager moduleManager,
IServiceLocator serviceLocator)
: base(serviceLocator)
{
}
/// <summary>
/// Initializes an instance of the <see cref="ModuleManager"/> class.
/// </summary>
/// <param name="moduleInitializer">Service used for initialization of modules.</param>
/// <param name="moduleCatalog">Catalog that enumerates the modules to be loaded and initialized.</param>
public ModuleManager(IModuleInitializer moduleInitializer, IModuleCatalog moduleCatalog)
{
this.moduleInitializer = moduleInitializer ?? throw new ArgumentNullException(nameof(moduleInitializer));
ModuleCatalog = moduleCatalog ?? throw new ArgumentNullException(nameof(moduleCatalog));
}
void ListModules(IModuleCatalog service)
{
var modules = service.Modules.OfType<ManifestModuleInfo>().ToArray();
Debug.WriteLine("Modules count: {0}", modules.Length);
foreach (var module in modules)
{
WriteModuleLine(module);
}
}
protected override void ConfigureModuleCatalog(IModuleCatalog moduleCatalog)
{
moduleCatalog.AddModule <MailModule>();
moduleCatalog.AddModule <CalanderModule>();
moduleCatalog.AddModule <ContactsModule>();
}
protected override void ConfigureModuleCatalog(IModuleCatalog moduleCatalog)
{
moduleCatalog.AddModule <ModuleForNavigationCallback.ModuleForNavigationCallbackModule>();
}
protected override void ConfigureModuleCatalog(IModuleCatalog moduleCatalog)
{
moduleCatalog.AddModule <BxUiScreenModule>(InitializationMode.WhenAvailable);
moduleCatalog.AddModule <BxUiTabModule>(InitializationMode.WhenAvailable);
}
protected override void ConfigureModuleCatalog(IModuleCatalog moduleCatalog)
{
moduleCatalog.AddModule <ModuleAModule>();
}
public MainViewModel(IModuleManager moduleManager,
IModuleCatalog moduleCatalog,
IEventAggregator eventAggregator)
{
this.Actions = new Dictionary<string, Action>();
this.ModuleManager = moduleManager;
this.ModuleCatalog = moduleCatalog;
this.EventAggregator = eventAggregator;
this.WindowTitle = GlobalDataSingleton.Instance.SystemTitle;
//订阅加载模块事件
if (this.EventAggregator != null)
{
//注册加载模块事件
this.EventAggregator.GetEvent<ModulesManagerEvent>().Subscribe(moduleinfo =>
{
this.LoadModule(moduleinfo.ModuleName, moduleinfo.Action);
});
//注册更换cover图事件
this.EventAggregator.GetEvent<ChangeCoverEvent>().Subscribe(cover =>
{
//DownloadImage(cover);
});
//添加到跳转列表
this.EventAggregator.GetEvent<JumplistEvent<JumpListEventArgs>>().Subscribe(e =>
{
this.AddKeyToJumpList(e);
});
}
App.Current.Exit += (o, e) =>
{
this.Dispose();
};
//注册程序错误事件
AppDomain.CurrentDomain.UnhandledException += new UnhandledExceptionEventHandler((sender, e) =>
{
//MessageBox.Show(e.ExceptionObject.ToString());
Debug.WriteLine("**********************************************************************");
Debug.WriteLine("喜马拉雅出现错误：" + DateTime.Now.ToShortDateString());
Debug.WriteLine("喜马拉雅出现错误：" + e.ExceptionObject.ToString());
Debug.WriteLine("喜马拉雅出现错误：" + e.IsTerminating.ToString());
Debug.WriteLine("**********************************************************************");
//Process.GetCurrentProcess().Kill();
});
}
/// <summary>
/// Adds the module.
/// </summary>
/// <returns>The module.</returns>
/// <param name="catalog">Catalog.</param>
/// <param name="name">Name.</param>
/// <param name="mode"><see cref="IModule"/>.</param>
/// <typeparam name="T">The <see cref="IModule"/> type parameter.</typeparam>
public static IModuleCatalog AddModule <T>(this IModuleCatalog catalog, string name, InitializationMode mode)
where T : IModule =>
catalog.AddModule(new ModuleInfo(typeof(T), name, mode));
public ModuleInstaller(string modulesPath, IModuleCatalog moduleCatalog)
{
_modulesPath = modulesPath;
_moduleCatalog = moduleCatalog;
}
/// <summary>
/// Adds the <see cref="IModule"/>
/// </summary>
/// <typeparam name="T">Type of <see cref="IModule"/></typeparam>
/// <param name="catalog">The <see cref="IModuleCatalog"/> to add the <see cref="IModule"/> to.</param>
/// <param name="mode"></param>
/// <param name="dependsOn">The names of the <see cref="IModule"/>'s that should be loaded when this <see cref="IModule"/> is loaded.</param>
/// <returns>The <see cref="IModuleCatalog"/></returns>
public static IModuleCatalog AddModule <T>(this IModuleCatalog catalog, InitializationMode mode, params string[] dependsOn)
where T : IModule =>
catalog.AddModule <T>(typeof(T).Name, mode, dependsOn);
public MainViewModel(IModuleManager moduleManager,
IModuleCatalog moduleCatalog,
IEventAggregator eventAggregator)
{
var AccentColors = ThemeInfoManager.Instance.AccentColor;
this.Actions = new Dictionary<string, Action>();
this.ModuleManager = moduleManager;
this.ModuleCatalog = moduleCatalog;
this.EventAggregator = eventAggregator;
this.WindowTitle = @"喜马拉雅-听我想听";
this.InitialTray();
//订阅加载模块事件
if (this.EventAggregator != null)
{
this.EventAggregator.GetEvent<ModulesManagerEvent>().Subscribe(moduleinfo =>
{
this.LoadModule(moduleinfo.ModuleName, moduleinfo.Action);
});
}
}
public ValuesController(IModuleCatalog moduleCatalog, IMyService myService, ISettingsManager settingManager)
{
_moduleCatalog = moduleCatalog;
_myService = myService;
_settingManager = settingManager;
}
/// <summary>
/// Checks to see if the <see cref="IModule"/> exists in the <see cref="IModuleCatalog.Modules"/>
/// </summary>
/// <returns><c>true</c> if the Module exists.</returns>
/// <param name="catalog">Catalog.</param>
/// <typeparam name="T">The <see cref="IModule"/> to check for.</typeparam>
public static bool Exists <T>(this IModuleCatalog catalog)
where T : IModule =>
catalog.Modules.Any(mi => mi.ModuleType == typeof(T).AssemblyQualifiedName);
public static IModuleCatalog AddModule <T>(this IModuleCatalog catalog, InitializationMode mode = InitializationMode.WhenAvailable)
where T : IModule =>
catalog.AddModule <T>(typeof(T).Name, mode);
/// <summary> /// Exists the specified catalog and name. /// </summary> /// <returns><c>true</c> if the Module exists.</returns> /// <param name="catalog">Catalog.</param> /// <param name="name">Name.</param> public static bool Exists(this IModuleCatalog catalog, string name) => catalog.Modules.Any(module => module.ModuleName == name);
public LocalizationController(IModuleCatalog moduleCatalog)
{
_moduleCatalog = moduleCatalog;
}
/// <summary>
/// Checks to see if the <see cref="IModule"/> is already initialized.
/// </summary>
/// <returns><c>true</c>, if initialized, <c>false</c> otherwise.</returns>
/// <param name="catalog">Catalog.</param>
/// <typeparam name="T">The <see cref="IModule"/> to check.</typeparam>
public static bool IsInitialized <T>(this IModuleCatalog catalog)
where T : IModule =>
catalog.Modules.FirstOrDefault(mi => mi.ModuleType == typeof(T).AssemblyQualifiedName)?.State == ModuleState.Initialized;
private IModuleCatalog GetExternalModuleCatalog(IModuleCatalog local)
{
var logger = new ConsoleOutLogger("test", Common.Logging.LogLevel.All, true, true, true, "yyyy/MM/dd HH:mm:ss:fff");
var externalModuleCatalog = new ExternalManifestModuleCatalog(local.Modules, new[] { "https://raw.githubusercontent.com/VirtoCommerce/vc-modules/master/modules.json" }, logger);
return externalModuleCatalog;
}
/// <summary> /// Checks to see if the <see cref="IModule"/> is already initialized. /// </summary> /// <returns><c>true</c>, if initialized, <c>false</c> otherwise.</returns> /// <param name="catalog">Catalog.</param> /// <param name="name">Name.</param> public static bool IsInitialized(this IModuleCatalog catalog, string name) => catalog.Modules.FirstOrDefault(module => module.ModuleName == name)?.State == ModuleState.Initialized;
/// <summary>
/// Add a module catalog.
/// </summary>
/// <param name="moduleCatalog">
/// The module catalog.
/// </param>
/// <exception cref="System.ArgumentNullException">
/// The <paramref name="moduleCatalog"/> is <c>null</c>.
/// </exception>
public void Add(IModuleCatalog moduleCatalog)
{
Argument.IsNotNull("moduleCatalog", moduleCatalog);
Log.Debug("Adding a module catalog to a composition");
_synchronizationContext.Execute(() => _moduleCatalogs.Add(moduleCatalog));
EnsureCatalogValidated();
}
protected override void ConfigureModuleCatalog(IModuleCatalog moduleCatalog)
{
// base.ConfigureModuleCatalog(moduleCatalog);
moduleCatalog.AddModule <MainSubModule>();
}
/// <summary>
/// Initializes a new instance of the <see cref="NuGetModuleTypeLoader" /> class.
/// </summary>
/// <param name="moduleCatalog">
/// </param>
/// <exception cref="System.ArgumentNullException">The <paramref name="moduleCatalog" /> is <c>null</c>.</exception>
/// <exception cref="System.ArgumentNullException">There are no available any NuGet based module catalog.</exception>
public NuGetModuleTypeLoader(IModuleCatalog moduleCatalog)
{
Argument.IsNotNull(() => moduleCatalog);
_moduleCatalog = moduleCatalog;
AppDomain.CurrentDomain.AssemblyResolve += CurrentDomainOnAssemblyResolve;
}
public AtomicModuleLoadOperation(string moduleName, IModuleCatalog moduleCatalog, IModuleManager moduleManager)
{
this.ModuleName = moduleName;
this.moduleCatalog = moduleCatalog;
this.moduleManager = moduleManager;
}
protected override void ConfigureModuleCatalog(IModuleCatalog moduleCatalog)
{
ConfigureModuleCatalogCalled = true;
base.ConfigureModuleCatalog(moduleCatalog);
}
public PlatformExportImportManager(ISecurityService securityService, IRoleManagementService roleManagementService, ISettingsManager settingsManager, IDynamicPropertyService dynamicPropertyService, IModuleCatalog moduleCatalog, IMemoryCache memoryCache)
{
_dynamicPropertyService = dynamicPropertyService;
_securityService = securityService;
_roleManagementService = roleManagementService;
_settingsManager = settingsManager;
_moduleCatalog = moduleCatalog;
_memoryCache = memoryCache;
}
public LocalizationController(IModuleCatalog moduleCatalog)
{
_moduleCatalog = moduleCatalog;
}
public void OnNavigatedTo(NavigationContext navigationContext)
{
moduleManager = ServiceLocator.Current.GetInstance<IModuleManager>();
moduleCatalog = ServiceLocator.Current.GetInstance<IModuleCatalog>();
regionManager = ServiceLocator.Current.GetInstance<IRegionManager>();
container = ServiceLocator.Current.GetInstance<IUnityContainer>();
if (navigationJournal == null)
{
navigationJournal = navigationContext.NavigationService.Journal;
navigationJournalEntry = navigationJournal.CurrentEntry;
}
}
