public void When_a_navigation_button_is_clicked_the_associated_page_should_be_displayed()
        {
            this.testContainer = new UnityContainer();
            this.autoMocker = new AutoMoq.AutoMoqer(this.testContainer);

            var mockPageViewModel = new Mock<IPageViewModel>();
            mockPageViewModel.SetupGet(page => page.Title).Returns("Page1");
            IPageViewModel pageViewModel = mockPageViewModel.Object;

            var viewModelFactoryMock = new Mock<IViewModelFactory>();
            viewModelFactoryMock.Setup(f => f.Get<StartPageViewModel>()).Returns(() => new StartPageViewModel(new Mock<INavigationService>().Object));
            this.autoMocker.SetInstance(viewModelFactoryMock.Object);

            var navigationServiceMock = this.navigationServiceMock;
            navigationServiceMock.Setup(vm => vm.GetDefaultPagesByNames())
                                 .Returns(
                                     new Dictionary<string, Func<IPageViewModel>>
                                         {
                                             { "page1", () => pageViewModel },
                                             { "page2", () => null },
                                             { "page3", () => null },
                                             { "page4", () => null },
                                         });

            INavigationService navigationService = navigationServiceMock.Object;
            this.autoMocker.SetInstance(navigationService);

            var applicationViewModel = this.autoMocker.Resolve<ApplicationViewModel>();

            applicationViewModel.LeftNavigationButtonCollection.Single(btn => btn.DisplayText == "page1").ExecuteAsync(null);

            navigationServiceMock.VerifySet(ns => ns.CurrentPage = pageViewModel);
        }
 public static void InitContainer(IUnityContainer unityContainer)
 {
     if (_unityContainer == null)
     {
         _unityContainer = unityContainer;
     }
 }
Esempio n. 3
0
        protected override void ConfigureContainer(IUnityContainer container)
        {
			// register all your components with the container here
            // container
            //    .RegisterType<IService1, Service1>()
            //    .RegisterType<DataContext>(new HierarchicalLifetimeManager());
        }
Esempio n. 4
0
        public static void RegisterTypes(IUnityContainer container)
        {
            var hierarchy = (Hierarchy)LogManager.GetRepository();
            hierarchy.Root.RemoveAllAppenders();

            hierarchy.Root.Level = Level.Debug;
            hierarchy.RaiseConfigurationChanged(EventArgs.Empty);

            FileAppender fileAppender = new RollingFileAppender();
            fileAppender.AppendToFile = true;
            fileAppender.LockingModel = new FileAppender.MinimalLock();
            fileAppender.File = HttpContext.Current.Server.MapPath("~/TestHarness1.log.txt");
            var patternLayout = new PatternLayout { ConversionPattern = "%d [%2%t] %-5p [%-10c]   %m%n%n" };
            patternLayout.ActivateOptions();

            fileAppender.Layout = patternLayout;
            fileAppender.ActivateOptions();

            BasicConfigurator.Configure(fileAppender);

            var logger = LogManager.GetLogger(typeof(IServiceBus));

            container.RegisterInstance<ILog>(logger, new ContainerControlledLifetimeManager());

            var ftpClient = new FtpQueueClient();
            ftpClient.ConnectAsync(new Uri("ftp://ftp.jdibble.co.uk/site1/Personal/service-bus-ftp/queue"), new NetworkCredential("jdibble-001", "jli798ik")).Wait();

            container.RegisterInstance<IFtpQueueClient>(ftpClient, new ContainerControlledLifetimeManager());

            container.RegisterType<IQueueManager, FtpQueueManager>(new ContainerControlledLifetimeManager());

            container.RegisterType<SharedMessageHandler>();

            var messageDictionary = new MessageTypeDictionary
                                    {
                                        { ServiceBus.Messaging.MessageExtensions.MessageTypeSignature<SharedMessage>(), typeof(SharedMessage) },
                                        { ServiceBus.Messaging.MessageExtensions.MessageTypeSignature<NonSharedMessage>(), typeof(NonSharedMessage) },
                                        { ServiceBus.Messaging.MessageExtensions.MessageTypeSignature<SharedEvent>(), typeof(SharedEvent) }
                                    };

            container.RegisterInstance<IMessageSerialiser>(new JsonMessageSerialiser(messageDictionary), new ContainerControlledLifetimeManager());

            var serviceBus =
                ServiceBusBuilder.Configure()
                    .WithLogger(container.Resolve<ILog>())
                    .WithHostAddress(new Uri("http://servicebus-ftp.jdibble.co.uk"))
                    .WithHttpTransport(new JsonMessageSerialiser(messageDictionary))
                    .AsMvcServiceBus(RouteTable.Routes, container.Resolve<IQueueManager>())
                    .Build()
                        .WithMessageHandler(container.Resolve<SharedMessageHandler>())
                        .Subscribe(container.Resolve<SharedEventHandler>())
                        .WithPeerAsync(new Peer(new Uri("http://servicebus-ftp2.jdibble.co.uk"))).Result;

            serviceBus.WithPeerAsync(new Peer(new Uri("http://servicebus.jdibble.co.uk")));
            serviceBus.WithPeerAsync(new Peer(new Uri("http://servicebus2.jdibble.co.uk")));

            container.RegisterInstance(serviceBus, new ContainerControlledLifetimeManager());

            container.RegisterType<ServiceBusHub>(new ContainerControlledLifetimeManager());
        }
Esempio n. 5
0
        /// <summary>
        /// 起動処理
        /// </summary>
        /// <param name="container"></param>
        /// <param name="pipelines"></param>
        protected override void ApplicationStartup(IUnityContainer container, IPipelines pipelines)
        {
            // 認証設定
            EnableBasicAuth(container, pipelines);
            EnableFormAuth(container, pipelines);

            // DBの初期化処理
            container.Resolve<IDataBaseContextInitializer>().Initialize();

            // コントローラー群を起動
            //this.controllers = MakeControllers(container).ToArray();

            // todo debug admin追加
            var isNothingAdmin =
                from c in container.ToMaybe()
                from ev in c.Resolve<IDataBaseContext>().ToMaybe()
                let admin = ev.GetUser(u => u.Id == "admin").FirstOrNothing()
                where admin.IsNothing
                select ev;
            isNothingAdmin.On(ev => ev.AddUser(new User { Id = "admin", Name = "Admin", Password = "******", Role = UserRole.Admin }));

            Nancy.Json.JsonSettings.MaxJsonLength = int.MaxValue;

            base.ApplicationStartup(container, pipelines);
        }
Esempio n. 6
0
        public ShellViewModel(IUnityContainer container)
        {
            _container = container;

            InitCommands();
            LoadContacts();
        }
Esempio n. 7
0
        private static void RegisterTypes(IUnityContainer container)
        {
            container.RegisterType(
                typeof(Notificator),
                new PerUserCacheLifetimeManager(),
                new InjectionConstructor());
            container.RegisterType<IEntityService, EntityService>();
            container.RegisterType<IValidatingEntities, EntityValidator>();
            container.RegisterType<IValidatingFiles, FileValidator>();
            container.RegisterType<IConfigurationProvider, ConfigurationProvider>();
            container.RegisterType<IConfiguration, Core.Configuration>();
            container.RegisterType<IFetchingRecords, RecordsSource>();
            container.RegisterType<IFetchingRecordsHierarchy, RecordsHierarchySource>();
            container.RegisterType<IExecutingDbCommand, DbCommandExecutor>();
            container.RegisterType<ICreatingRecords, RecordsCreator>();
            container.RegisterType<IUpdatingRecords, RecordsUpdater>();
            container.RegisterType<IDeletingRecords, RecordsDeleter>();
            container.RegisterType<IComparingRecords, RecordsComparer>();
            container.RegisterType<IDescribingChanges, ChangesDescriber>();
            container.RegisterType<IProvidingUser, HttpContextUserProvider>();
            container.RegisterType<ICreatingNameFiles, FileNameCreator>();
            container.RegisterType<IDeletingFiles, FileDeleter>();
            container.RegisterType<IHandlingFiles, FileHandler>();
            container.RegisterType<IResizingImages, ImageResizer>();
            container.RegisterType<ISavingFiles, FileSaver>();
            container.RegisterType<IFilterFactory, FilterFactory>();
            container.RegisterType<IRecordsService, RecordsService>();

            container.RegisterType<IIlaroAdmin, IlaroAdmin>(new ContainerControlledLifetimeManager());
        }
Esempio n. 8
0
        /// <summary>Registers the type mappings with the Unity container.</summary>
        /// <param name="container">The unity container to configure.</param>
        /// <remarks>There is no need to register concrete types such as controllers or API controllers (unless you want to 
        /// change the defaults), as Unity allows resolving a concrete type even if it was not previously registered.</remarks>
        public static void RegisterTypes(IUnityContainer container)
        {
            // NOTE: To load from web.config uncomment the line below. Make sure to add a Microsoft.Practices.Unity.Configuration to the using statements.
            // container.LoadConfiguration();

            container.RegisterInstance<IMapper>(MapperBootstap.CreateMapper());
        }
Esempio n. 9
0
 private static void RegisterType()
 {
     container = new UnityContainer();
     container.RegisterType<IUserHelper, UserHelper>()
         .RegisterType<IAdminHelper,AdminHelper>()
         .RegisterType<IMemberHelper,MemberHelper>();
 }
 private void RegisterSerializers(IUnityContainer container) {
     container.RegisterType(typeof (ISolrDocumentSerializer<>), typeof (SolrDocumentSerializer<>));
     container.RegisterType(typeof (ISolrDocumentSerializer<Dictionary<string, object>>), typeof (SolrDictionarySerializer));
     container.RegisterType<ISolrFieldSerializer, DefaultFieldSerializer>();
     container.RegisterType<ISolrQuerySerializer, DefaultQuerySerializer>();
     container.RegisterType<ISolrFacetQuerySerializer, DefaultFacetQuerySerializer>();
 }
Esempio n. 11
0
        public ViewModelLocator()
        {
            _container = new UnityContainer();

            // ViewModels
            _container.RegisterType<CalculatorViewModel>();
        }
Esempio n. 12
0
        /// <summary>Registers the type mappings with the Unity container.</summary>
        /// <param name="container">The unity container to configure.</param>
        /// <remarks>There is no need to register concrete types such as controllers or API controllers (unless you want to 
        /// change the defaults), as Unity allows resolving a concrete type even if it was not previously registered.</remarks>
        public static void RegisterTypes(IUnityContainer container)
        {
            // NOTE: To load from web.config uncomment the line below. Make sure to add a Microsoft.Practices.Unity.Configuration to the using statements.
            // container.LoadConfiguration();
            container.RegisterType<ApplicationDbContext>();
            container.RegisterType<ApplicationUserManager>();
            container.RegisterType<ApplicationSignInManager>();
            container.RegisterType<IAuthenticationManager>(
                new InjectionFactory(c => HttpContext.Current.GetOwinContext().Authentication));
            container.RegisterType<IUserStore<ApplicationUser>, UserStore<ApplicationUser>>(
               new InjectionConstructor(typeof(ApplicationDbContext)));
            // GlobalConfiguration.Configuration.DependencyResolver = new Unity.WebApi.UnityDependencyResolver(container);
            container.RegisterType<IRoleStore<IdentityRole, string>, RoleStore<IdentityRole>>(
            new InjectionConstructor(typeof(ApplicationDbContext)));

            container.RegisterType<IDriverepo, DriveRepo>();

            container.RegisterType<AccountController>(
                new InjectionConstructor(
                    typeof(ApplicationUserManager),
                    typeof(ApplicationSignInManager),
                    typeof(IDriverepo)));
            // TODO: Register your types here
            // container.RegisterType<IProductRepository, ProductRepository>();
        }
Esempio n. 13
0
 protected virtual void RegisterUIShell(IUnityContainer container)
 {
     var uiShell = (IVsUIShell)GetService(typeof(SVsUIShell));
     PackageViewModel.IsWaitCursorEnabled.Subscribe(_ =>
     {
         ErrorHandler.ThrowOnFailure(uiShell.SetWaitCursor());
     });
     PackageViewModel.MessageBoxParameter.Subscribe(_ =>
     {
         var result = 0;
         ErrorHandler.ThrowOnFailure(uiShell.ShowMessageBox(MessageBoxParameter.ReservedUInt,
                                                            ref MessageBoxParameter.ReservedGuid,
                                                            _.Title,
                                                            _.Text,
                                                            MessageBoxParameter.EmptyHelpFile,
                                                            MessageBoxParameter.EmptyHelpContextId,
                                                            _.Button,
                                                            _.DefaultButton,
                                                            _.Icon,
                                                            MessageBoxParameter.NotSysAlert,
                                                            out result));
         _.Result = (VSConstants.MessageBoxResult)result;
     });
     container.RegisterInstance(uiShell);
 }
Esempio n. 14
0
 public ModuleInit(IRegionManager regionManager, IUnityContainer container, IEventAggregator eventAggregator, IModuleManager moduleManager)
 {
     this.regionManager = regionManager;
     this.container = container;
     this.eventAggregator = eventAggregator;
     this.moduleManager = moduleManager;
 }
Esempio n. 15
0
 /// <summary>
 /// Initializes a new instance of the <see cref="ExpensesViewModel"/> class.
 /// </summary>
 /// <param name="container">The container.</param>
 public ExpensesViewModel(IUnityContainer container)
     : base(container)
 {
     Edit = new DelegateCommand<object>(OnEdit);
     Create = new DelegateCommand<object>(OnCreate);
     LoadExpenses();
 }
        public static void MyClassInitialize(TestContext testContext)
        {
            container = TestManager.ConfigureUnityContainer("unity");

            productService = container.Resolve<IProductService>();

        }
        public UnityMvcDependencyResolver(IUnityContainer unityContainer)
        {
            if (unityContainer == null)
                throw new ArgumentNullException("unityContainer");

            this.unityContainer = unityContainer;
        }
        public override void Arrange()
        {
            ConfigurationProvider = new ConfigurationProvider(@".\Configuration");

            UnityContainerUnderTest = new UnityContainer();
            UnityContainerUnderTest.LoadUnityConfiguration(ConfigurationProvider);
        }
Esempio n. 19
0
 public static void RegisterTypes(IUnityContainer container)
 {
     //for Sql Server
     container.RegisterType(typeof(IRepository), typeof(EFRepository));
     //for xml file
     //container.RegisterType(typeof(IRepository), typeof(XmlRepository));
 }
Esempio n. 20
0
 public ModuleB(IUnityContainer container, IRegionManager regionManager)
 {
     Container = container;
     RegionManager = regionManager;
     
     RegisterViewsAndServices();
 }
Esempio n. 21
0
        public static void MyClassInitialize(TestContext testContext)
        {
            container = TestManager.ConfigureUnityContainer("unity");

            UserService = container.Resolve<IUserService>();
            GroupService = container.Resolve<IGroupService>();
        }
		public static FSharpAsync<Unit> Show(IUnityContainer container) {
			return container.StartViewActivity<Unit>(context => {
				var view = new AboutView(context);
				var presenter = container.Resolve<IViewPresenter>();
				presenter.ShowView(view);
			});
		}
		public static FSharpAsync<Result> Show(IUnityContainer container, Model model) {
			return container.StartViewActivity<Result>(context => {
				var view = new UserManagementView(model, context);
				var presenter = container.Resolve<IViewPresenter>();
				presenter.ShowView(view);
			});
		}
Esempio n. 24
0
        public ConnectionPresenter(IUnityContainer container, IConnectionView view,
             IShellPresenter regionManager)
        {
            View = view;
            this.container = container;
            this.service = new WMSServiceClient();
            View.Model = this.container.Resolve<ConnectionModel>();
            this.regionManager = regionManager;

            //Event Delegate
            View.New += new EventHandler<EventArgs>(this.OnNew);
            View.LoadData += new EventHandler<DataEventArgs<Connection>>(this.OnLoadData);
            View.LoadChilds += new EventHandler<DataEventArgs<ConnectionType>>(this.OnLoadChilds);
            View.Save += new EventHandler<EventArgs>(this.OnSave);
            View.Delete += new EventHandler<EventArgs>(this.OnDelete);
            View.TestConnection += new EventHandler<EventArgs>(this.OnTestConnection);

            View.Model.ListCnnType = service.GetConnectionType(new ConnectionType());

            if (View.Model.ListCnnType != null && View.Model.ListCnnType.Count == 1)
                LoadChilds(View.Model.ListCnnType[0]);

            View.Model.Record = null;
            View.DpChilds.Visibility = Visibility.Collapsed;

        }
Esempio n. 25
0
        public PartPresenter(PartPresenterView view, IUnityContainer container)
        {
            _container = container;
            View = view;
            View.DataContext = this;
            _regionManager = new RegionManager();
            RegionManager.SetRegionManager(View, _regionManager);

            _addPartCommand = new Lazy<DelegateCommand<object>>(() => new DelegateCommand<object>(AddPartExecuted));
            Action<int> add = (i) =>
            {
                var region = _regionManager.Regions["Page1Content" + i];
                if (region.Views.Count() == 0)
                {
                    var partView = _container.Resolve<PartView>();

                    region.Add(partView);
                    region.Activate(partView);

                }
            };

            add(1);
            add(2);
            add(3);
        }
Esempio n. 26
0
        public KZFlyoutDialog(IUnityContainer container)
        {
            KZHelper = container.Resolve<IKZHelper>();

            action = new FlyoutAction();
            CommandYes = new FlyoutCommand {Text = "យល់ព្រម", Result = DialogResult.Yes};
            CommandNo = new FlyoutCommand {Text = "មិនយល់ព្រម", Result = DialogResult.No};
            action.Commands.Add(CommandYes);
            action.Commands.Add(CommandNo);


            properties = new FlyoutProperties();
            //properties.Appearance.BackColor = Color.Blue;
            //properties.Appearance.Options.UseBackColor = true;

            properties.Appearance.Font = KZHelper.KZFonts.ContentFont;
            properties.Appearance.Options.UseFont = true;
            properties.AppearanceCaption.Font = KZHelper.KZFonts.HeaderFont;
            properties.AppearanceCaption.Options.UseFont = true;
            properties.AppearanceButtons.Font = KZHelper.KZFonts.ContentFont;
            properties.AppearanceButtons.Options.UseFont = true;
            properties.AppearanceDescription.Font = KZHelper.KZFonts.ContentFont;
            properties.AppearanceDescription.Options.UseFont = true;


            properties.ButtonSize = new Size(150, 40);
            properties.Style = FlyoutStyle.MessageBox;
        }
Esempio n. 27
0
 public AXAClaimSearchBase(ClaimPreviewControllerBase previewController, ISearchServiceHandler searchService, IUnityContainer container, AppModel appModel)
 {
     this._searchService = searchService;
     this._container = container;
     this._appModel = appModel;
     this._previewController = previewController;
 }
        public static void SetupContainer()
        {
            // Create User
            var user = new CurrentUser() { Username = "******", LabCode = "EUHAWE3" };

            // Create Logger
            var logger = new LoggerConfiguration()
              .Enrich.FromLogContext()
                .MinimumLevel.Warning()                 // Set MinimumLevel of Warning
                .WriteTo.Seq("http://localhost:5341")
              .CreateLogger();

            unityContainer = new UnityContainer();

            // Register User
            unityContainer.RegisterInstance<ICurrentUser>(user);

            // Add Interception Extension
            unityContainer.AddNewExtension<Microsoft.Practices.Unity.InterceptionExtension.Interception>();

            //Register Logger Instance
            unityContainer.RegisterInstance<ILogger>(logger);

            unityContainer.RegisterType<ISamRepository, SamRepository>()
                .Configure<Microsoft.Practices.Unity.InterceptionExtension.Interception>()
                .SetInterceptorFor<ISamRepository>(
                    new InterfaceInterceptor());
        }
        public void ConfigureOwin(IAppBuilder app, IUnityContainer container)
        {
            JobStorage.Current = CreateJobStorage(Stage.ConfigureOwin);

            // Configure Hangfire dashboard

            var securityService = container.Resolve<ISecurityService>();
            var moduleInitializerOptions = container.Resolve<IModuleInitializerOptions>();

            var appPath = "/" + moduleInitializerOptions.RoutePrefix;

            var authorizationFilters = new[]
            {
                    new PermissionBasedAuthorizationFilter(securityService)
                    {
                        Permission = PredefinedPermissions.BackgroundJobsManage
                    }
                };

            var dashboardOptions = new DashboardOptions
            {
                AppPath = appPath,
                AuthorizationFilters = authorizationFilters
            };

            app.UseHangfireDashboard(appPath + "hangfire", dashboardOptions);

            // Configure Hangfire server
            if (_options.StartServer)
            {
                app.UseHangfireServer(new BackgroundJobServerOptions { Activator = new UnityJobActivator(container) });
            }
        }
        /// <summary>
        ///     Configures the container.
        /// </summary>
        /// <param name="container">The container.</param>
        protected override void ConfigureContainer(IUnityContainer container)
        {
            if (Interceptor == null)
            {
                return;
            }

            var interceptorType = TypeResolver.ResolveType(Interceptor.TypeName);
            if (!typeof (IInstanceInterceptor).IsAssignableFrom(interceptorType))
            {
                throw new ConfigurationErrorsException(Resources.ExceptionOnlyInstanceInterceptorBeSupported);
            }

            var builderName = interceptorType.AssemblyQualifiedName;
            var source =
                Interceptor.Injection.SelectMany(
                    (InjectionMemberElement element) =>
                        element.GetInjectionMembers(container, typeof (IInstanceInterceptor), interceptorType,
                            builderName));
            container.RegisterType(typeof (IInstanceInterceptor), interceptorType, builderName,
                new ContainerControlledLifetimeManager(), source.ToArray());

            var buildKey = new NamedTypeBuildKey(typeof (IInstanceInterceptor), builderName);
            var instance =
                new ResolvedAutoInterceptorPolicy(
                    (NamedTypeBuildKey key) => container.Resolve<IInstanceInterceptor>(key.Name), buildKey);
            container.RegisterInstance(typeof (AutoInterceptorPolicy),
                typeof (AutoInterceptorPolicy).AssemblyQualifiedName, instance, new ContainerControlledLifetimeManager());
        }
Esempio n. 31
0
 /// <summary>
 /// Constructor with dependency injection
 /// </summary>
 /// <param name="container">unity container</param>
 /// <param name="regionManager">region manager</param>
 public MediaLibraryModule(IUnityContainer container, IRegionManager regionManager)
 {
     _container     = container;
     _regionManager = regionManager;
 }
Esempio n. 32
0
 public void Terminar()
 {
     container = null;
 }
 public UntiyValidatorFactory(IUnityContainer unityContainer)
 {
     this.unityContainer = unityContainer;
 }
Esempio n. 34
0
 public void RegisterTypes(IUnityContainer container)
 {
     container.RegisterType <IiBeaconEventTriggerService, iBeaconEventTriggerService>(new ContainerControlledLifetimeManager());
 }
Esempio n. 35
0
 public void RegisterTypes(IUnityContainer container)
 {
 }
 public static void ConfigureContainer()
 {
     Container = BuildUnityContainer();
     DependencyResolver.SetResolver(new UnityDependencyResolver(Container));
 }
Esempio n. 37
0
 public static void Register(IUnityContainer container)
 {
 }
Esempio n. 38
0
 /// <summary>
 /// Initializes a new instance of the <see cref="ReceiverModule"/> class.
 /// </summary>
 /// <param name="container">The container.</param>
 public ReceiverModule(IUnityContainer container, IEventAggregator eventAggregator, IRegionViewRegistry regionRegistry)
 {
     _container       = container;
     _eventAggregator = eventAggregator;
     _regionRegistry  = regionRegistry;
 }
Esempio n. 39
0
 public void InitializeContainer(IUnityContainer unityContainer)
 {
     InitializeViewModelsByReflection(unityContainer);
     InitializeHandlers(unityContainer);
 }
Esempio n. 40
0
 public void Inicializar()
 {
     container = new UnityContainer();
     //container.RegisterType<IRepositorio<Clientes>, ClientesRepository>();
     container.LoadConfiguration();
 }
Esempio n. 41
0
 /// <summary>
 /// Returns whether a specified type has a type mapping registered in the container.
 /// </summary>
 /// <param name="container">The <see cref="IUnityContainer"/> to check for the type mapping.</param>
 /// <param name="type">The type to check if there is a type mapping for.</param>
 /// <returns><see langword="true"/> if there is a type mapping registered for <paramref name="type"/>.</returns>
 /// <remarks>In order to use this extension method, you first need to add the
 /// <see cref="IUnityContainer"/> extension to the <see cref="UnityBootstrapperExtension"/>.
 /// </remarks>
 public static bool IsTypeRegistered(this IUnityContainer container, Type type)
 {
     return(UnityBootstrapperExtension.IsTypeRegistered(container, type));
 }
Esempio n. 42
0
 public Module(IUnityContainer container, IAppBuilder appBuilder)
 {
     _container  = container;
     _appBuilder = appBuilder;
 }
 public override ICallHandler CreateHandler(IUnityContainer ignored)
 {
     return(new GlobalCountCallHandler(this.handlerName));
 }
 public CommandBusDependencyRegister(IUnityContainer unityContainer, params Assembly[] assemblies) : this(unityContainer, null, assemblies)
 {
     _commandBusTypeProviderThunk = () => new DefaultCommandBusTypeProvider();
 }
 public HorizonConfigurationsViewModel(IUnityContainer unityContainer)
 {
     _repo = unityContainer.Resolve <IPATRepository>();
     _displayComputationModel = unityContainer.Resolve <IDisplayComputationalViewModel>();
     HorizonConfirgurations   = _repo.GetHorizonConfigurations();
 }
Esempio n. 46
0
 public PrismModule1Module(IUnityContainer container, RegionManager regionManager)
 {
     _container     = container;
     _regionManager = regionManager;
 }
Esempio n. 47
0
 public LogViewerModule(IUnityContainer container)
 {
     _container = container;
 }
Esempio n. 48
0
 public ModuleBModule(IUnityContainer container, IRegionManager regionManager)
 {
     this.RegionManager = regionManager;
 }
Esempio n. 49
0
 private static void RegisterPresenters(IUnityContainer container)
 {
     container.RegisterType <IUploadPresenter, UploadPresenter>(new HierarchicalLifetimeManager());
     container.RegisterType <IProfilePresenter, ProfilePresenter>(new HierarchicalLifetimeManager());
 }
Esempio n. 50
0
 public static void RegisterTypes(IUnityContainer container)
 {
     container.RegisterType <IAzureKeyVaultClient, AzureKeyVaultClient>();
     //container.RegisterType<IAzureKeyVaultConfiguration, AzureKeyVaultConfiguration>();
     container.RegisterInstance(AzureKeyVaultConfiguration.Instance.Value);
 }
Esempio n. 51
0
 public UnityServiceScopeFactory(IUnityContainer container)
 {
     this.container = container;
 }
Esempio n. 52
0
 protected TransferredBaseViewModel(IUnityContainer container) : base(container)
 {
 }
Esempio n. 53
0
 public void RegisterTypes(IUnityContainer container)
 {
     UnityContainerExtensions.RegisterType <IDatabaseConnectionService, DatabaseConnectionService>(container, new ContainerControlledLifetimeManager());
 }
Esempio n. 54
0
 public IoCContainer(IUnityContainer container)
     : base(container)
 {
 }
Esempio n. 55
0
 public UnityResolver(IUnityContainer container)
 {
     this.container = container ?? throw new ArgumentNullException("container");
 }
Esempio n. 56
0
 public Module(IUnityContainer container)
 {
     _container = container;
 }
Esempio n. 57
0
 public override ICallHandler CreateHandler(IUnityContainer container)
 {
     return(new CacheAttributeHandler(this.KeyPrefix));
 }
Esempio n. 58
0
 public override ICallHandler CreateHandler(IUnityContainer container)
 {
     return(Handler);
 }
Esempio n. 59
0
 /// <summary>
 /// Initializes a new instance of the <see cref="UnityInstanceProvider"/> class with the <see cref="Type"/>
 /// to create and the name of the container to use.
 /// </summary>
 /// <param name="type">The <see cref="Type"/> to create.</param>
 /// <param name="containerName">The name of the container to use.</param>
 /// <remarks>
 /// If <paramref name="containerName"/> is null then the default configuration is used. If the Unity configuration section
 /// is not found, the container will just try and resolve the type.
 /// </remarks>
 public UnityInstanceProvider(Type type, string containerName)
 {
     this.type          = type;
     this.containerName = containerName;
     this.container     = UnityInstanceProvider.CreateUnityContainer(this.containerName);
 }
Esempio n. 60
0
        private static void InitializePlatform(IUnityContainer container, string connectionStringName)
        {
            #region Setup database

            using (var db = new SecurityDbContext(connectionStringName))
            {
                new IdentityDatabaseInitializer().InitializeDatabase(db);
            }

            using (var context = new PlatformRepository(connectionStringName, new AuditableInterceptor(), new EntityPrimaryKeyGeneratorInterceptor()))
            {
                new PlatformDatabaseInitializer().InitializeDatabase(context);
            }

            // Create Hangfire tables
            new SqlServerStorage(connectionStringName);

            #endregion

            Func <IPlatformRepository> platformRepositoryFactory = () => new PlatformRepository(connectionStringName, new AuditableInterceptor(), new EntityPrimaryKeyGeneratorInterceptor());
            container.RegisterType <IPlatformRepository>(new InjectionFactory(c => platformRepositoryFactory()));
            container.RegisterInstance <Func <IPlatformRepository> >(platformRepositoryFactory);
            var moduleCatalog    = container.Resolve <IModuleCatalog>();
            var manifestProvider = container.Resolve <IModuleManifestProvider>();

            #region Caching

            var cacheProvider = new HttpCacheProvider();
            var cacheSettings = new[]
            {
                new CacheSettings(CacheGroups.Settings, TimeSpan.FromDays(1)),
                new CacheSettings(CacheGroups.Security, TimeSpan.FromMinutes(1)),
            };

            var cacheManager = new CacheManager(cacheProvider, cacheSettings);
            container.RegisterInstance <CacheManager>(cacheManager);

            #endregion

            #region Settings

            var platformSettings = new[]
            {
                new ModuleManifest
                {
                    Settings = new[]
                    {
                        new ModuleSettingsGroup
                        {
                            Name     = "Platform|Notifications|SendGrid",
                            Settings = new []
                            {
                                new ModuleSetting
                                {
                                    Name        = "VirtoCommerce.Platform.Notifications.SendGrid.UserName",
                                    ValueType   = ModuleSetting.TypeString,
                                    Title       = "SendGrid UserName",
                                    Description = "Your SendGrid account username"
                                },
                                new ModuleSetting
                                {
                                    Name        = "VirtoCommerce.Platform.Notifications.SendGrid.Secret",
                                    ValueType   = ModuleSetting.TypeString,
                                    Title       = "SendGrid Password",
                                    Description = "Your SendGrid account password"
                                }
                            }
                        },

                        new ModuleSettingsGroup
                        {
                            Name     = "Platform|Notifications|SendingJob",
                            Settings = new []
                            {
                                new ModuleSetting
                                {
                                    Name        = "VirtoCommerce.Platform.Notifications.SendingJob.TakeCount",
                                    ValueType   = ModuleSetting.TypeInteger,
                                    Title       = "Job Take Count",
                                    Description = "Take count for sending job"
                                }
                            }
                        }
                    }
                }
            };

            var settingsManager = new SettingsManager(manifestProvider, platformRepositoryFactory, cacheManager, platformSettings);
            container.RegisterInstance <ISettingsManager>(settingsManager);

            #endregion

            #region Dynamic Properties

            container.RegisterType <IDynamicPropertyService, DynamicPropertyService>();

            #endregion

            #region Notifications

            var hubSignalR = GlobalHost.ConnectionManager.GetHubContext <ClientPushHub>();
            var notifier   = new InMemoryNotifierImpl(hubSignalR);
            container.RegisterInstance <INotifier>(notifier);

            var resolver = new LiquidNotificationTemplateResolver();
            var notificationTemplateService = new NotificationTemplateServiceImpl(platformRepositoryFactory);
            var notificationManager         = new NotificationManager(resolver, platformRepositoryFactory, notificationTemplateService);

            var emailNotificationSendingGateway = new DefaultEmailNotificationSendingGateway(settingsManager);

            var defaultSmsNotificationSendingGateway = new DefaultSmsNotificationSendingGateway();

            container.RegisterInstance <INotificationTemplateService>(notificationTemplateService);
            container.RegisterInstance <INotificationManager>(notificationManager);
            container.RegisterInstance <INotificationTemplateResolver>(resolver);
            container.RegisterInstance <IEmailNotificationSendingGateway>(emailNotificationSendingGateway);
            container.RegisterInstance <ISmsNotificationSendingGateway>(defaultSmsNotificationSendingGateway);

            //notificationManager.RegisterNotificationType(
            //	() => new RegistrationSmsNotification(defaultSmsNotificationSendingGateway)
            //	{
            //		DisplayName = "Registration notification",
            //		Description = "This notification sends by sms to client when he finish registration",
            //		ObjectId = "Platform",
            //		NotificationTemplate = new NotificationTemplate
            //		{
            //			Body = @"Dear {{ context.first_name }} {{ context.last_name }}, you has registered on our site. Your login  - {{ context.login }} Your login - {{ context.password }}",
            //			Subject = @"",
            //			NotificationTypeId = "RegistrationSmsNotification",
            //			ObjectId = "Platform"
            //		}
            //	}
            //);

            #endregion

            #region Assets

            var assetsConnection = ConfigurationManager.ConnectionStrings["AssetsConnectionString"];

            if (assetsConnection != null)
            {
                var properties             = assetsConnection.ConnectionString.ToDictionary(";", "=");
                var provider               = properties["provider"];
                var assetsConnectionString = properties.ToString(";", "=", "provider");

                if (string.Equals(provider, FileSystemBlobProvider.ProviderName, StringComparison.OrdinalIgnoreCase))
                {
                    var fileSystemBlobProvider = new FileSystemBlobProvider(assetsConnectionString);

                    container.RegisterInstance <IBlobStorageProvider>(fileSystemBlobProvider);
                    container.RegisterInstance <IBlobUrlResolver>(fileSystemBlobProvider);
                }
                else if (string.Equals(provider, AzureBlobProvider.ProviderName, StringComparison.OrdinalIgnoreCase))
                {
                    var azureBlobProvider = new AzureBlobProvider(assetsConnectionString);

                    container.RegisterInstance <IBlobStorageProvider>(azureBlobProvider);
                    container.RegisterInstance <IBlobUrlResolver>(azureBlobProvider);
                }
            }

            #endregion

            #region Packaging

            var sourcePath   = HostingEnvironment.MapPath("~/App_Data/SourcePackages");
            var packagesPath = HostingEnvironment.MapPath("~/App_Data/InstalledPackages");

            var packageService = new ZipPackageService(moduleCatalog, manifestProvider, packagesPath, sourcePath);
            container.RegisterInstance <IPackageService>(packageService);
            container.RegisterType <ModulesController>(new InjectionConstructor(packageService, sourcePath));

            #endregion

            #region ChangeLogging

            var changeLogService = new ChangeLogService(platformRepositoryFactory);
            container.RegisterInstance <IChangeLogService>(changeLogService);

            #endregion

            #region Security

            var permissionService = new PermissionService(platformRepositoryFactory, manifestProvider, cacheManager);
            container.RegisterInstance <IPermissionService>(permissionService);

            container.RegisterType <IRoleManagementService, RoleManagementService>(new ContainerControlledLifetimeManager());

            var apiAccountProvider = new ApiAccountProvider(platformRepositoryFactory, cacheManager);
            container.RegisterInstance <IApiAccountProvider>(apiAccountProvider);

            container.RegisterType <IClaimsIdentityProvider, ApplicationClaimsIdentityProvider>(new ContainerControlledLifetimeManager());

            container.RegisterType <ApplicationSignInManager>(new InjectionFactory(c => HttpContext.Current.GetOwinContext().Get <ApplicationSignInManager>()));
            container.RegisterType <ApplicationUserManager>(new InjectionFactory(c => HttpContext.Current.GetOwinContext().GetUserManager <ApplicationUserManager>()));
            container.RegisterType <IAuthenticationManager>(new InjectionFactory(c => HttpContext.Current.GetOwinContext().Authentication));

            var nonEditableUsers = GetAppSettingsValue("VirtoCommerce:NonEditableUsers", string.Empty);
            container.RegisterInstance <ISecurityOptions>(new SecurityOptions(nonEditableUsers));

            container.RegisterType <ISecurityService, SecurityService>();

            #endregion

            #region ExportImport
            container.RegisterType <IPlatformExportImportManager, PlatformExportImportManager>();
            #endregion
        }