/// <summary> /// Configure the repository manager to use InMemory repositories /// </summary> /// <param name="builder">Application builder</param> /// <param name="filesLocation">The direction that the files are stored in.</param> /// <param name="repositoriesAssembly">The name of the assembly containing the repositories /// <remarks>The assembly name should not contain the extension.</remarks></param> /// <param name="config">The configuration object to be passed to the repositories</param> /// <returns>Application builder</returns> public static T UseFileRepositories <T>(this T builder, string filesLocation, string repositoriesAssembly, RepositoryConfigurations config = null) where T : IApplicationBuilder { builder.BuildActionsCoordinator.AddAction(DefaultBuildActions.InMemoryRepositoryBuildAction((container) => { if (!container.IsRegistered <IRepositoryManager>()) { throw new ApplicationBuildException("RepositoryManager is not registered. call UseSingletonRepositoryManager or UseTransientRepositoryManager to configuration the repository manager."); } var repositoryManager = container.Resolve <IRepositoryManager>(); repositoryManager.AddRepositoryInitializer(new FileRepositoryInitializer(filesLocation, container.Resolve <IObjectMapper>(), config)); repositoryManager.RegisterRepositories(repositoriesAssembly); var logger = container.Resolve <ILogger>(); container.RegisterInstance <IRepositoryManager>(repositoryManager); foreach (var repository in repositoryManager.GetRepositories()) { logger.Log(EventsSource, $"Registering repository of type {repository.GetType().Name}", LogRecordTypes.Debug); container.RegisterInstance(repository.ImplementedInterface, repository); } })); return(builder); }
/// <summary> /// Initialize <see cref="ILocalizationManager"/> service. /// </summary> /// <param name="builder"></param> /// <param name="resourceManagerFullPath">Resource files location <remarks>example "HR.Clients.WPF.Properties.Resources"</remarks></param> /// <param name="resourceManagerAssembly">The name of the assembly containing the resources <remarks>Example "HR.Clients.WPF.exe"</remarks></param> /// <param name="supportedCultures">The available cultures in the resource files <remarks>Example new[] {"ar-SY", "en-US"}</remarks></param> /// <param name="defaultCluture">The default culture used in the application <remarks>Example "en-US"</remarks></param> /// <returns></returns> public static IApplicationBuilder UseLocalization( this IApplicationBuilder builder, string resourceManagerFullPath, string resourceManagerAssembly, string[] supportedCultures, string defaultCluture = "en-US") { builder.BuildActionsCoordinator.AddAction(DefaultBuildActions.LocalizationBuildAction((container) => { var localizationManager = container.Resolve <ILocalizationManager>(); localizationManager.SetCulture(defaultCluture); var values = new Dictionary <string, Dictionary <string, string> >(); var res = new ResourceManager(resourceManagerFullPath, Assembly.LoadFrom(Path.Combine(AppDomain.CurrentDomain .BaseDirectory, resourceManagerAssembly))); foreach (var culture in supportedCultures) { foreach (DictionaryEntry val in res.GetResourceSet(new CultureInfo(culture), true, true)) { if (!values.ContainsKey(val.Key.ToString())) { values[val.Key.ToString()] = new Dictionary <string, string>(); } values[val.Key.ToString()][culture] = val.Value.ToString(); } } localizationManager.AddValues(values); })); return(builder); }
/// <summary> /// Sets a default shell for the WPF application /// </summary> /// <returns></returns> public static IApplicationBuilder UseNavigation( this IApplicationBuilder builder, params INavigationItem[] navigationItems) { builder.BuildActionsCoordinator.AddAction(DefaultBuildActions.NavigationBuildAction((container) => { var navs = new List <INavigationItem>(); var nav = container.Resolve <INavigationService>(); var gud = container.Resolve <IGlobalVariablesService>().GetVariable <UsingDefaultShellGlobalVariable>(); if (gud.IsValueSet && gud.GetValue()) { var homeNav = new NavigationItem(container.Resolve <IDefaultShellViewModel>().GetMainContent(), "Home", "M10,20V14H14V20H19V12H22L12,3L2,12H5V20H10Z"); DefaultNavigations.Home = homeNav; navs.Add(homeNav); navs.AddRange(navigationItems); nav.Initialize(DefaultRegions.NavbarRegion, DefaultRegions.ApplicationMainRegion, navs); } else { navs.AddRange(navigationItems); nav.Initialize(DefaultRegions.NavbarRegion, DefaultRegions.ApplicationMainRegion, navs); } })); return(builder); }
/// <summary> /// Adds MogonRepositories to the repository manager /// </summary> /// <param name="builder"></param> /// <param name="connection">The database connection string</param> /// <param name="databaseName">The database name</param> /// <param name="repositoriesAssembly">The assembly that contains the repositories</param> /// <param name="registerTheRepositoresInContainer">If set to true the repositories will be registered in the dependency container.</param> /// <returns></returns> public static IApplicationBuilder UseMongoDBRepositories( this IApplicationBuilder builder, string connection, string databaseName, string repositoriesAssembly, bool registerTheRepositoresInContainer) { builder.BuildActionsCoordinator.AddAction(DefaultBuildActions.MongoRepositoryBuildAction((container) => { if (!container.IsRegistered <IRepositoryManager>()) { throw new ApplicationBuildException("RepositoryManager is not registered. call UseSingletonRepositoryManager or UseTransientRepositoryManager to configuration the repository manager."); } var repositoryManager = container.Resolve <IRepositoryManager>(); repositoryManager.AddRepositoryInitializer(new MongoRepositoryInitializer(new MongoDBManager(connection, databaseName), container.Resolve <IObjectMapper>())); repositoryManager.RegisterRepositories(repositoriesAssembly); var logger = container.Resolve <ILogger>(); container.RegisterInstance <IRepositoryManager>(repositoryManager); if (registerTheRepositoresInContainer) { foreach (var repository in repositoryManager.GetRepositories()) { logger.Log(EventsSource, $"Registering repository of type {repository.GetType().Name}", LogRecordTypes.Debug); container.RegisterInstance(repository.ImplementedInterface, repository); } } })); return(builder); }
/// <summary> /// Set the default global variables values. /// </summary> protected void ConfigureGlobalVariables() { BuildActionsCoordinator.AddAction(DefaultBuildActions.ConfigureGlobalVariablesBuildAction(container => { _container.Resolve <IGlobalVariablesService>().GetVariable <ApplicationNameGlobalVariable>().SetValue(_app.ApplicationName); })); }
/// <summary> /// Use the IL object mapper /// </summary> public static IApplicationBuilder UseILMapper(this IApplicationBuilder builder) { builder.BuildActionsCoordinator.AddAction(DefaultBuildActions.MapperBuildAction((container) => { container.RegisterInstance <IObjectMapper, ILObjectsMapper>(); })); return(builder); }
/// <summary> /// Sets the application theme colors /// </summary> /// <returns></returns> public static IApplicationBuilder UseTheme(this IApplicationBuilder builder, ApplicationColors colors) { builder.BuildActionsCoordinator.AddAction(DefaultBuildActions.ApplicationThemeAction((container) => { ApplicationTheme.SetTheme(colors); })); return(builder); }
/// <summary> /// Set the application entry point /// </summary> /// <param name="builder"></param> /// <typeparam name="T">The class containing the entry point</typeparam> /// <returns></returns> public static IApplicationBuilder UseMain <T>(this IApplicationBuilder builder) where T : IEntryPointClass { builder.BuildActionsCoordinator.AddAction(DefaultBuildActions.ConsoleMainBuildAction((container) => { container.Resolve <T>().Start(container); })); return(builder); }
/// <summary> /// Use the basic object mapper /// </summary> public static TBuilder UseBasicMapper <TBuilder>(this TBuilder builder) where TBuilder : IApplicationBuilder { builder.BuildActionsCoordinator.AddAction(DefaultBuildActions.MapperBuildAction((container) => { container.RegisterInstance <IObjectMapper, BasicObjectMapper>(); })); return(builder); }
/// <summary> /// Configure the application to use a <see cref="TransientRepositoryManager"/> that returns the a new repository instance on each call. /// </summary> public static T UseTransientRepositoryManager <T>(this T builder) where T : IApplicationBuilder { builder.BuildActionsCoordinator.AddAction(DefaultBuildActions.RepositoryManagerBuildAction((container) => { container.RegisterInstance <IRepositoryManager, TransientRepositoryManager>(); })); return(builder); }
/// <summary> /// Sets the minimum log level to show to the user /// </summary> /// <returns></returns> public static IApplicationBuilder UseLogger(this IApplicationBuilder builder, LoggerOptions options) { builder.BuildActionsCoordinator.AddAction(DefaultBuildActions.LoggerBuildAction((container) => { BuilderHelper.RegisterLoggers(options, container); })); return(builder); }
/// <summary> /// Initialize the configuration manager /// </summary> public static IApplicationBuilder UseConfigurationFile( this IApplicationBuilder builder, string fileLocation) { builder.BuildActionsCoordinator.AddAction(DefaultBuildActions.ConfigFileBuildAction((container) => { var config = container.Resolve <IConfigurationManager>(); config.Initialize(fileLocation, new ConfigurationFile("config", Path.Combine(fileLocation, "config.cfg"))); })); return(builder); }
/// <summary> /// Use Dialog service /// </summary> /// <returns></returns> public static IApplicationBuilder UseDialogs(this IApplicationBuilder builder, Region dialogRegion) { builder.BuildActionsCoordinator.AddAction(DefaultBuildActions.DialogServiceBuildAction( (container) => { container.Resolve <IDialogService>().Initialize(dialogRegion); container.Resolve <IDialogExplorer>().Initialize(); })); return(builder); }
/// <summary> /// Configure the <see cref="ILocalizationManager"/> service. /// </summary> /// <param name="builder"></param> /// <param name="defaultCluture"></param> /// <returns></returns> public static IApplicationBuilder UseLocalization( this IApplicationBuilder builder, string defaultCluture = "en-US") { builder.BuildActionsCoordinator.AddAction(DefaultBuildActions.LocalizationBuildAction((container) => { var localizationManager = container.Resolve <ILocalizationManager>(); localizationManager.SetCulture(defaultCluture); })); return(builder); }
/// <summary> /// Initialize the configuration manager /// </summary> /// <param name="builder">the application builder.</param> /// <param name="fileLocation"></param> /// <param name="defaultFile">The default configurations file.</param> public static IApplicationBuilder UseConfigurationFile( this IApplicationBuilder builder, string fileLocation, IConfigurationFile defaultFile = null) { builder.BuildActionsCoordinator.AddAction(DefaultBuildActions.ConfigFileBuildAction((container) => { var config = container.Resolve <IConfigurationManager>(); config.Initialize(fileLocation, defaultFile); })); return(builder); }
/// <summary> /// Sets the application MainNavigationPage /// </summary> public static IXamarinApplicationBuilder UseNavigationMainPage <TMain>( this IXamarinApplicationBuilder builder) where TMain : IPresentableViewModel { builder.BuildActionsCoordinator.AddAction(DefaultBuildActions.MainPageAction((container) => { var app = Application.Current; var main = container.Resolve <TMain>(); app.MainPage = new NavigationPage((Page)main.GetView()); main.Initialize(); })); return(builder); }
/// <summary> /// Sets a custom shell for the WPF application /// </summary> /// <returns></returns> public static IApplicationBuilder UseCustomShellWithLogin <TShellViewModel, TLogin>(this IApplicationBuilder builder, Action <Window> config = null) where TShellViewModel : IShellViewModel where TLogin : ILoginViewModel { builder.BuildActionsCoordinator.AddAction(DefaultBuildActions.ShellBuildAction((container) => { var wpfApplication = container.Resolve <WPFApplication>(); var shellViewModel = BuildCustomShell <TShellViewModel>(config, container); var loginViewModel = container.Resolve <TLogin>(); BuildLogin(container, wpfApplication, shellViewModel, loginViewModel); })); return(builder); }
/// <summary> /// Sets a custom shell for the WPF application /// </summary> /// <typeparam name="TShellViewModel"></typeparam> /// <returns></returns> public static IApplicationBuilder UseCustomShell <TShellViewModel>(this IApplicationBuilder builder, Action <Window> config = null) where TShellViewModel : IShellViewModel { builder.BuildActionsCoordinator.AddAction(DefaultBuildActions.ShellBuildAction((container) => { var wpfApplication = container.Resolve <WPFApplication>(); var shellViewModel = BuildCustomShell <TShellViewModel>(config, container); shellViewModel.Initialize().ContinueWith((t) => { container.Resolve <IEventDispatcher>().GetEvent <ApplicationStartedEvent>().Raise(wpfApplication); }); wpfApplication.ShowWindow(); })); return(builder); }
/// <summary> /// Sets a default shell for the WPF application /// </summary> /// <typeparam name="TContent">The main content type to be shown on startup</typeparam> /// <typeparam name="TLogin"></typeparam> /// <returns></returns> public static IApplicationBuilder UseDefaultShellWithLogin <TContent, TLogin>( this IApplicationBuilder builder, WindowState state = WindowState.Maximized, Action <Window> config = null) where TContent : IPresentable where TLogin : ILoginViewModel { builder.BuildActionsCoordinator.AddAction(DefaultBuildActions.ShellBuildAction((container) => { var wpfApplication = container.Resolve <WPFApplication>(); var shellViewModel = BuildDefaultShell <TContent>(builder, state, config, container); var loginViewModel = container.Resolve <TLogin>(); BuildLogin(container, wpfApplication, shellViewModel, loginViewModel); })); return(builder); }
/// <summary> /// Register LinQ repositories and adds a <see cref="LinqRepositoryInitializer"/> to the <see cref="IRepositoryManager"/> /// </summary> public static IApplicationBuilder UseLinqRepositories <TDBManager>( this IApplicationBuilder builder, LinqInitializerConfig config) where TDBManager : ILinqDBManager, new() { builder.BuildActionsCoordinator.AddAction(DefaultBuildActions.LinqRepositoryBuildAction((container) => { var connectionString = config.DatabaseConnection(container); if (string.IsNullOrEmpty(connectionString)) { config.ConnectionStringNotFound?.Invoke(); return; } CreateRepositoryManager <TDBManager>(container, connectionString, config.RepositoriesAssembly, config.RepositoryConfigurations); })); return(builder); }
/// <summary> /// Add additional modules to the application. /// </summary> /// <param name="buillder"></param> /// <param name="modulesAssemblies">The names of the assemblies containing the modules.</param> /// <returns></returns> public static IApplicationBuilder UseModules(this IApplicationBuilder buillder, string assemblyLocation, params string[] modulesAssemblies) { buillder.BuildActionsCoordinator.AddAction(DefaultBuildActions.DiscoverModulesBuildAction( container => { var _modulesManager = container.Resolve <IWindowsApplicationModulesManager>(); if (modulesAssemblies != null) { foreach (var assembly in modulesAssemblies) { _modulesManager.RegisterModule(_modulesManager.DescoverModulesFromAssambles(assemblyLocation, assembly).ToArray()); } } _modulesManager.InitializeAutoModules().GetAwaiter().GetResult(); })); return(buillder); }
/// <summary> /// Sets a default shell for the WPF application /// </summary> /// <typeparam name="TContent">The main content type to be shown on startup</typeparam> /// <returns></returns> public static IApplicationBuilder UseDefaultShell <TContent>( this IApplicationBuilder builder, WindowState state = WindowState.Maximized, Action <Window> config = null) where TContent : IPresentable { builder.BuildActionsCoordinator.AddAction(DefaultBuildActions.ShellBuildAction((container) => { var wpfApplication = container.Resolve <WPFApplication>(); var shellViewModel = BuildDefaultShell <TContent>(builder, state, config, container); shellViewModel.Initialize().ContinueWith((t) => { container.Resolve <IEventDispatcher>().GetEvent <ApplicationStartedEvent>().Raise(wpfApplication); }); wpfApplication.ShowWindow(); })); return(builder); }
/// <summary> /// Add a console to the application /// </summary> /// <param name="builder"></param> /// <param name="toggleCondition">A function that is executed on the shell KeyDown event show return true to toggle the console</param> /// <returns></returns> public static IApplicationBuilder UseCoddeeDebugTool(this IApplicationBuilder builder, Func <KeyEventArgs, bool> toggleCondition) { builder.BuildActionsCoordinator.AddAction(DefaultBuildActions.DebugToolBuildAction(async(container) => { var shell = container.Resolve <IShell>(); if (shell == null) { throw new ApplicationBuildException("The method must be called after the UseShell method"); } var debugTool = container.Resolve <IDebugTool>(); await debugTool.Initialize(); debugTool.SetToggleCondition(toggleCondition); })); return(builder); }
/// <summary> /// Register REST repositories and adds a <see cref="RESTRepositoryInitializer"/> to the <see cref="IRepositoryManager"/> /// </summary> public static TBuilder UseRESTRepositories <TBuilder>( this TBuilder builder, Func <IContainer, RESTInitializerConfig> config) where TBuilder : IApplicationBuilder { builder.BuildActionsCoordinator.AddAction(DefaultBuildActions.RESTRepositoryBuildAction((container) => { if (!container.IsRegistered <IRepositoryManager>()) { throw new ApplicationBuildException("RepositoryManager is not registered. call UseSingletonRepositoryManager or UseTransientRepositoryManager to configuration the repository manager."); } var repositoryManager = container.Resolve <IRepositoryManager>(); var configRes = config(container); repositoryManager.AddRepositoryInitializer(new RESTRepositoryInitializer(configRes.ApiUrl, configRes.UnauthorizedRequestHandler, container.Resolve <IObjectMapper>())); if (!string.IsNullOrEmpty(configRes.RepositoriesAssembly)) { repositoryManager.RegisterRepositories(configRes.RepositoriesAssembly); } if (configRes.RepositoriesTypes != null) { repositoryManager.RegisterRepositories(configRes.RepositoriesTypes); } var logger = container.Resolve <ILogger>(); container.RegisterInstance <IRepositoryManager>(repositoryManager); if (configRes.RegisterTheRepositoresInContainer) { foreach (var repository in repositoryManager.GetRepositories()) { logger.Log(EventsSource, $"Registering repository of type {repository.GetType().Name}", LogRecordTypes.Debug); container.RegisterInstance(repository.ImplementedInterface, repository); } } })); return(builder); }
/// <summary> /// set the default application build steps. /// </summary> protected virtual void SetupDefaultBuildActions() { Log($"Setting up default build actions."); BuildActionsCoordinator.AddAction(DefaultBuildActions.RegisterDefaultModulesBuildAction(container => { IApplicationModulesManager applicationModulesManager = CreateApplicationModuleManager(container); applicationModulesManager.RegisterModule(GetDefaultModules()); applicationModulesManager.InitializeAutoModules().GetAwaiter().GetResult(); })); if (!BuildActionsCoordinator.BuildActionExists(BuildActionsKeys.ConfigureGlobalVariabls)) { ConfigureGlobalVariables(); } BuildActionsCoordinator.AddAction(DefaultBuildActions.SetupViewModelBaseBuildAction(container => { SetupViewModelBase(); })); }
/// <summary> /// Add a console to the application /// </summary> /// <param name="builder"></param> /// <param name="toggleCondition">A function that is executed on the shell KeyDown event show return true to toggle the console</param> /// <returns></returns> public static IApplicationBuilder UseApplicationConsole(this IApplicationBuilder builder, Func <KeyEventArgs, bool> toggleCondition) { builder.BuildActionsCoordinator.AddAction(DefaultBuildActions.AppConsoleBuildAction((container) => { var shell = (ContentControl)container.Resolve <IShell>(); if (shell == null) { throw new ApplicationBuildException("The method must be called after the UseShell method"); } var applicationConsole = container.Resolve <IApplicationConsole>(); var logger = (LogAggregator)container.Resolve <ILogger>(); applicationConsole.Initialize(shell, logger.MinimumLevel); //Add the console logger to loggers collection logger.AddLogger(applicationConsole.GetLogger(), LoggerTypes.ApplicationConsole); //Sets the Shell KeyDown event handler to toggle the console visibility applicationConsole.SetToggleCondition(toggleCondition); })); return(builder); }
/// <summary> /// Set the application entry point /// </summary> /// <param name="builder"></param> /// <param name="entryPoint">Application main method</param> /// <returns></returns> public static IApplicationBuilder UseMain(this IApplicationBuilder builder, Action <IContainer> entryPoint) { builder.BuildActionsCoordinator.AddAction(DefaultBuildActions.ConsoleMainBuildAction(entryPoint)); return(builder); }
/// <summary> /// Set the application entry point /// </summary> /// <param name="builder"></param> /// <param name="entryPoint">The class containing the entry point.</param> /// <returns></returns> public static IApplicationBuilder UseMain(this IApplicationBuilder builder, IEntryPointClass entryPoint) { builder.BuildActionsCoordinator.AddAction(DefaultBuildActions.ConsoleMainBuildAction(entryPoint.Start)); return(builder); }