private void RegisterProjections(TinyIoCContainer container)
        {
            var itemDetailRepository = new InMemoryItemDetailRepository();
            container.Register<IItemDetailRepository>(itemDetailRepository);
            var itemDetailViewWriter = new InMemoryViewWriter<Guid, ItemDetailViewModel>(itemDetailRepository);
            var itemDetails = new ItemDetailResultProjection(
                itemDetailViewWriter);

            var itemDetailSubscription = new GetEventStoreEventDispatcher(
                EventStoreConnection, serializerSettings, itemDetailViewWriter, bus);
            itemDetailSubscription.Subscribe<ItemTracked>(itemDetails.Handle);
            itemDetailSubscription.Subscribe<ItemPicked>(itemDetails.Handle);
            itemDetailSubscription.Subscribe<ItemLiquidated>(itemDetails.Handle);
            itemDetailSubscription.Subscribe<ItemReceived>(itemDetails.Handle);
            itemDetailSubscription.Subscribe<ItemQuantityAdjusted>(itemDetails.Handle);
            itemDetailSubscription.Subscribe<CycleCountStarted>(itemDetails.Handle);
            itemDetailSubscription.Subscribe<CycleCountCompleted>(itemDetails.Handle);

            itemDetailSubscription.StartDispatching();

            container.Register<IItemSearchRepository>(
                (c, n) => new RavenItemSearchRepository(c.Resolve<IDocumentSession>()));
            var itemSearchSessionObserver = new CatchUpDocumentSessionObserver<ItemSearchResultViewModel>(DocumentStore);
            bus.Register(itemSearchSessionObserver);
            var itemSearch = new ItemSearchResultProjection(
                new RavenDbViewWriter<Guid, ItemSearchResultViewModel>(
                    itemSearchSessionObserver));

            var itemSearchSubscription = new GetEventStoreEventDispatcher(
                EventStoreConnection, serializerSettings, itemSearchSessionObserver, bus);
            itemSearchSubscription.Subscribe<ItemTracked>(itemSearch.Handle);

            itemSearchSubscription.StartDispatching();
        }

        protected override void ConfigureApplicationContainer(TinyIoCContainer container)
        {
            Trace.TraceInformation("Bootstrapper.ConfigureApplicationContainer");
            base.ConfigureApplicationContainer(container);

            container.Register<IDocumentFolder>((c,p)=> new DocumentFolder(_rootDirectory));
        }

        public static void ConfigureContainer(TinyIoCContainer container)
        {
            var opts = container.Resolve<Options>();

            container.Register(typeof(ILogHandler), typeof(Logger.Log4NetLogger)).AsSingleton();
            container.Register<InMemorySessionManager>().AsSingleton();

            var sessionManager = container.Resolve<InMemorySessionManager>();
            container.Register<ISessionHandler, InMemorySessionManager>(sessionManager);

            container.RegisterMultiple<IMessageLifecycleCallbackHandler>(new List<Type>()
            {
                typeof (SessionMessageLifecycleCallback),
                typeof (SpamManager)
            }).AsSingleton();

            IPAddress ipAddress;

            if (IPAddress.TryParse(opts.IPAddress, out ipAddress) == false)
            {
                throw new ArgumentException("Failed to parse IP Address: " + opts.IPAddress);
            }

            container.Register(typeof(TorqueMasterServer),
                new TorqueMasterServer(container, new IPEndPoint(ipAddress, opts.Port)));
        }

 // Overriding this just to show how it works, not actually necessary as autoregister
 // takes care of it all.
 protected override void ConfigureApplicationContainer(TinyIoCContainer existingContainer)
 {
     // We don't call base because we don't want autoregister
     // we just register our one known dependency as an application level singleton
     existingContainer.Register<IApplicationDependency, ApplicationDependencyClass>().AsSingleton();
     existingContainer.Register<IRazorConfiguration, MyRazorConfiguration>().AsSingleton();
 }

        protected override void ApplicationStartup(TinyIoCContainer container, IPipelines pipelines)
        {
            base.ApplicationStartup(container, pipelines);

            ExceptionlessClient.Default.Configuration.UseTraceLogger();
            ExceptionlessClient.Default.RegisterNancy(pipelines);
        }

        private static TinyIoCContainer ConfigureContainer(IEnumerable<IDiagnosticsProvider> providers, IRootPathProvider rootPathProvider, IRequestTracing requestTracing, NancyInternalConfiguration configuration, INancyEnvironment diagnosticsEnvironment)
        {
            var diagContainer = new TinyIoCContainer();

            diagContainer.Register<IInteractiveDiagnostics, InteractiveDiagnostics>();
            diagContainer.Register<IRequestTracing>(requestTracing);
            diagContainer.Register<IRootPathProvider>(rootPathProvider);
            diagContainer.Register<NancyInternalConfiguration>(configuration);
            diagContainer.Register<IModelBinderLocator, DefaultModelBinderLocator>();
            diagContainer.Register<IBinder, DefaultBinder>();
            diagContainer.Register<IFieldNameConverter, DefaultFieldNameConverter>();
            diagContainer.Register<BindingDefaults, BindingDefaults>();
            diagContainer.Register<INancyEnvironment>(diagnosticsEnvironment);
            diagContainer.Register<ISerializer>(new DefaultJsonSerializer(diagnosticsEnvironment));

            foreach (var diagnosticsProvider in providers)
            {
                var key = string.Concat(
                    diagnosticsProvider.GetType().FullName,
                    "_",
                    diagnosticsProvider.DiagnosticObject.GetType().FullName);

                diagContainer.Register<IDiagnosticsProvider>(diagnosticsProvider, key);
            }

            foreach (var moduleType in AppDomainAssemblyTypeScanner.TypesOf<DiagnosticModule>().ToArray())
            {
                diagContainer.Register(typeof(INancyModule), moduleType, moduleType.FullName).AsMultiInstance();
            }

            return diagContainer;
        }

        protected override void ApplicationStartup(TinyIoCContainer container, IPipelines pipelines)
        {

            base.ApplicationStartup(container, pipelines);

            var configuration = new BasicAuthenticationConfiguration(container.Resolve<IUserValidator>(), "test-realm");
            BasicAuthentication.Enable(pipelines,configuration);

            var stateless = new StatelessAuthenticationConfiguration(c =>
            {
                const string key = "X-Auth-Token";
                string token = null;

                if (c.Request.Headers.Authorization == null || !c.Request.Headers.Authorization.Any())
                {
                    _log.ErrorFormat("No request headers are present in the request {0}", c);
                    return null;
                }

                if (c.Request.Headers.FirstOrDefault(f => f.Key == key).Value == null ||
                    string.IsNullOrEmpty(c.Request.Headers.FirstOrDefault(f => f.Key == key).Value.First()))
                {
                    _log.ErrorFormat("No Key present in the request headers");
                    return null;
                }

                token = c.Request.Headers.FirstOrDefault(f => f.Key == key).Value.First();
                _log.InfoFormat("Token used {0}", token);

                var user = container.Resolve<IUserApiMapper>();
                return user.GetUserFromToken(token);

            });
            StatelessAuthentication.Enable(pipelines, stateless);
        }

 protected override void ConfigureApplicationContainer(TinyIoCContainer container)
 {
     base.ConfigureApplicationContainer(container);
     container.Register(_solution);
     container.Register(_fileSystem);
     container.RegisterMultiple<IReferenceProcessor>(new []{typeof(AddProjectReferenceProcessor), typeof(AddFileReferenceProcessor), typeof(AddGacReferenceProcessor)});
 }

 protected override void ConfigureApplicationContainer(TinyIoCContainer container)
 {
     var dir = Path.Combine(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "data"));
     var store = new JsonStore<EventDescriptor>(dir, "store", "events");
     container.Register<IDataStore<EventDescriptor>, JsonStore<EventDescriptor>>(store);
     container.Register<IStore>(new Store(store, new JsonSerializer()));
 }

        protected override void ApplicationStartup(TinyIoCContainer container, Nancy.Bootstrapper.IPipelines pipelines)
        {
            base.ApplicationStartup(container, pipelines);
            var buildStepNames = ConfigurationManager.AppSettings["PipelineBuildSteps"].Split(',');

            container.Register(buildStepNames.Select(s => (IBuildStep) new BuildStep(s)).ToArray());
        }

        public ViewModelLocator()
        {
            _container = TinyIoCContainer.Current;
            _container.Register<ClockViewModel>().AsSingleton();
            _container.Register<AirportsViewModel>().AsSingleton();
            _container.Register<IGetAirports, AirportNamesService>().AsSingleton();
            _container.Register<IDispatchOnUIThread, DispatchAdapter>().AsSingleton();
            _container.Register<IStoreObjects, ObjectStore>().AsSingleton();

            #if DEBUG
            _container.Register<IGeolocation>(new PresetLocationService(63.433281, 10.419294, _container.Resolve<IDispatchOnUIThread>()));
            #else
            _container.Register<IGeolocation, MonoMobile.Extensions.Geolocation>();
            #endif
            _container.Register(new NearestAirportService(_container.Resolve<IGeolocation>(), _container.Resolve<ITinyMessengerHub>()));

            if (DesignerProperties.IsInDesignTool)
            {
                //_container.Register<IStoreObjects, DesignTimeObjectStore>().AsSingleton();
                _container.Register<IGetFlights, DesignTimeFlightsService>().AsSingleton();
                _container.Register<IFlightsViewModel, FlightsDesignTimeViewModel>().AsSingleton();
            }
            else
            {
                _container.Register<IGetFlights, FlightsService>().AsSingleton();
                _container.Register<IFlightsViewModel, FlightsViewModel>().AsSingleton();
            }
        }

        protected override void RequestStartup(TinyIoCContainer container, IPipelines pipelines, NancyContext context)
        {
            var formsAuthConfig = new FormsAuthenticationConfiguration
            {
                RedirectUrl = "~/login",
                UserMapper = container.Resolve<IUserMapper>()
            };

            FormsAuthentication.Enable(pipelines, formsAuthConfig);

            pipelines.AfterRequest += ctx =>
            {
                var dbContext = container.Resolve<SmartFlowContext>();
                dbContext.SaveChanges();
            };

            pipelines.OnError += (ctx, ex) =>
            {
                var logger = container.Resolve<TextFileLogger>();
                logger.Write("Error", Enums.LogLevel.ApplicationError, ex);
                return ErrorResponse.FromException(ex);
            };

            base.RequestStartup(container, pipelines, context);
        }

        protected override void ApplicationStartup(TinyIoCContainer container, IPipelines pipelines)
        {
            base.ApplicationStartup(container, pipelines);

            // Enable JavaScript Object Notation
            Jsonp.Enable(pipelines);
        }

        protected override void ConfigureRequestContainer(TinyIoCContainer container, NancyContext context)
        {
            base.ConfigureRequestContainer(container, context);

            container.Register<IUserMapper, FakeRepository>();
            container.Register<IRepository, FakeRepository>();
        }

        protected override void ApplicationStartup(TinyIoCContainer container, IPipelines pipelines)
        {
            base.ApplicationStartup(container, pipelines);

            JsonSettings.RetainCasing = true;
            JsonSettings.MaxJsonLength = int.MaxValue;
            StaticConfiguration.CaseSensitive = false;

            var sessionManager = new SessionManager(new MemorySessionProvider("Encore", int.Parse(ConfigurationManager.AppSettings["Session.Timeout"])));
            sessionManager.Run(pipelines);

            pipelines.OnError.AddItemToEndOfPipeline((ctx, ex) =>
            {
                log.Error("Unhandled error on request: " + ctx.Request.Url, ex);

                ctx.Items["error"] = new Error
                {
                    ErrorMessage = "An unhandled error occurred",
                    StatusCode = HttpStatusCode.InternalServerError
                };

                return null;
            });

            ConfigureAutoMapper();
        }

		/// <summary>
		/// Registers components in the React IoC container
		/// </summary>
		/// <param name="container">Container to register components in</param>
		public void Register(TinyIoCContainer container)
		{
			if (MSBuildUtils.IsInMSBuild())
			{
				RegisterForMSBuild(container);
			}
		}

        protected override void ApplicationStartup(TinyIoCContainer container, Nancy.Bootstrapper.IPipelines pipelines)
        {
            base.ApplicationStartup(container, pipelines);

            CookieBasedSessions.Enable(pipelines);

            Conventions.ViewLocationConventions.Add((viewName, model, context) => string.Concat("views/", viewName));

            Conventions.StaticContentsConventions.Add(
                StaticContentConventionBuilder.AddDirectory("assets", @"assets")
            );

            container.Register<IFlexUserStore, FlexMembershipUserStore<User, Role>>();
            container.Register(typeof(IDocumentStore), InitDocStore());
            container.Register(typeof(IDocumentSession), (c, overloads) =>
                c.Resolve<IDocumentStore>().OpenSession());

            var cryptographyConfiguration = new CryptographyConfiguration(
                new RijndaelEncryptionProvider(new PassphraseKeyGenerator(Configuration.EncryptionKey, new byte[] { 8, 2, 10, 4, 68, 120, 7, 14 })),
                new DefaultHmacProvider(new PassphraseKeyGenerator(Configuration.HmacKey, new byte[] { 1, 20, 73, 49, 25, 106, 78, 86 })));

            var authenticationConfiguration =
                new FormsAuthenticationConfiguration()
                {
                    CryptographyConfiguration = cryptographyConfiguration,
                    RedirectUrl = "/login",
                    UserMapper = container.Resolve<IUserMapper>(),
                };

            FormsAuthentication.Enable(pipelines, authenticationConfiguration);

            FlexMembershipProvider.RegisterClient(
                new GoogleOpenIdClient(),
                "Google", new Dictionary<string, object>());
        }

        /// <summary>
        /// Applications the startup.
        /// </summary>
        /// <param name="container">The container.</param>
        /// <param name="pipelines">The pipelines.</param>
        protected override void ApplicationStartup(TinyIoCContainer container, IPipelines pipelines)
        {
            base.ApplicationStartup(container, pipelines);

            pipelines.BeforeRequest += ctx =>
            {
                var identity = (WindowsIdentity)HttpContext.Current.User.Identity;
                if (identity.IsAuthenticated)
                {
                    // Resolve<UserManager>
                    // Get from DB/Cache
                    // Add user to ICurrentUSerProvider
                    // Get Claims

                    ctx.CurrentUser = new DemoUserIdentity
                    {
                        UserName = identity.Name,
                        Claims = new[] { "Basic", "Finance" }
                    };
                }

                return null;
            };

            pipelines.AfterRequest += ctx =>
            {
                // If status code comes back as Unauthorized then
                // forward the user to the unauthorised page
                //if (ctx.Response.StatusCode == HttpStatusCode.Unauthorized
                //    || ctx.Response.StatusCode == HttpStatusCode.Forbidden)
                //{
                //    ctx.Response = new RedirectResponse("/Unauthorised");
                //}
            };
        }

 // The bootstrapper enables you to reconfigure the composition of the framework,
 // by overriding the various methods and properties.
 // For more information https://github.com/NancyFx/Nancy/wiki/Bootstrapper
 protected override void ApplicationStartup(TinyIoCContainer container, IPipelines pipelines)
 {
     container.Register<IStorage, Storage>().AsSingleton();
     container.Register<CredentialsStorage>().AsSingleton();
     var serverScheduler = new ServerScheduler(container.Resolve<IStorage>());
     serverScheduler.Start();
 }

        protected override void ConfigureApplicationContainer(TinyIoCContainer container)
        {
            base.ConfigureApplicationContainer(container);

            container.Register<IArticleReader, ArticleReader>();
            container.Register<IArticleStorage, ArticleStorage>();
        }