/// <summary>Parameterized constructor.
 /// </summary>
 /// <param name="waitingCommandService"></param>
 /// <param name="aggregateRootTypeCodeProvider"></param>
 /// <param name="aggregateRootFactory"></param>
 /// <param name="eventStreamConvertService"></param>
 /// <param name="eventSourcingService"></param>
 /// <param name="memoryCache"></param>
 /// <param name="aggregateStorage"></param>
 /// <param name="retryCommandService"></param>
 /// <param name="eventStore"></param>
 /// <param name="eventPublisher"></param>
 /// <param name="actionExecutionService"></param>
 /// <param name="eventSynchronizerProvider"></param>
 /// <param name="loggerFactory"></param>
 public DefaultCommitEventService(
     IWaitingCommandService waitingCommandService,
     IAggregateRootTypeCodeProvider aggregateRootTypeCodeProvider,
     IAggregateRootFactory aggregateRootFactory,
     IEventStreamConvertService eventStreamConvertService,
     IEventSourcingService eventSourcingService,
     IMemoryCache memoryCache,
     IAggregateStorage aggregateStorage,
     IRetryCommandService retryCommandService,
     IEventStore eventStore,
     IEventPublisher eventPublisher,
     IActionExecutionService actionExecutionService,
     IEventSynchronizerProvider eventSynchronizerProvider,
     ILoggerFactory loggerFactory)
 {
     _waitingCommandService = waitingCommandService;
     _aggregateRootTypeCodeProvider = aggregateRootTypeCodeProvider;
     _aggregateRootFactory = aggregateRootFactory;
     _eventStreamConvertService = eventStreamConvertService;
     _eventSourcingService = eventSourcingService;
     _memoryCache = memoryCache;
     _aggregateStorage = aggregateStorage;
     _retryCommandService = retryCommandService;
     _eventStore = eventStore;
     _eventPublisher = eventPublisher;
     _actionExecutionService = actionExecutionService;
     _eventSynchronizerProvider = eventSynchronizerProvider;
     _logger = loggerFactory.Create(GetType().Name);
 }

        protected override global::Ninject.IKernel CreateKernel()
        {
            Store = Bootstrapper.Instance.Get<IEventStore>();
            DataCache = Bootstrapper.Instance.Get<IRepositoryCache>();

            return Bootstrapper.Instance.Kernel;
        }

        public DefaultCommandExecutor(
            IProcessingCommandCache processingCommandCache,
            ICommandAsyncResultManager commandAsyncResultManager,
            ICommandHandlerProvider commandHandlerProvider,
            IAggregateRootTypeProvider aggregateRootTypeProvider,
            IMemoryCache memoryCache,
            IRepository repository,
            IRetryCommandService retryCommandService,
            IEventStore eventStore,
            IEventPublisher eventPublisher,
            IEventPersistenceSynchronizerProvider eventPersistenceSynchronizerProvider,
            ICommandContext commandContext,
            ILoggerFactory loggerFactory)
        {
            _processingCommandCache = processingCommandCache;
            _commandAsyncResultManager = commandAsyncResultManager;
            _commandHandlerProvider = commandHandlerProvider;
            _aggregateRootTypeProvider = aggregateRootTypeProvider;
            _memoryCache = memoryCache;
            _repository = repository;
            _retryCommandService = retryCommandService;
            _eventStore = eventStore;
            _eventPublisher = eventPublisher;
            _eventPersistenceSynchronizerProvider = eventPersistenceSynchronizerProvider;
            _commandContext = commandContext;
            _trackingContext = commandContext as ITrackingContext;
            _logger = loggerFactory.Create(GetType().Name);

            if (_trackingContext == null)
            {
                throw new Exception("command context must also implement ITrackingContext interface.");
            }
        }

 public void Initialize(IEventStore eventStore, bool purgeExistingViews = false)
 {
     foreach (var batch in eventStore.Stream().Batch(1000))
     {
         Dispatch(eventStore, batch.Select(e => _domainEventSerializer.Deserialize(e)));
     }
 }

 public EventApplier(IEventStore eventstore, HandlerRegistry handlerregistry, IHandlerInstanceResolver resolver,IParameterResolver parameterresolver)
 {
     this.eventstore = eventstore;
     this.handlerregistry = handlerregistry;
     this.resolver = resolver;
     this.parameterresolver = parameterresolver;
 }

 public CollectionService(
     IEventStore eventStore, 
     IPublishEvents eventsPublisher)
 {
     this.eventStore = eventStore;
     this.eventsPublisher = eventsPublisher;
 }

 public CommandBus(IEventStore eventstore, HandlerRegistry handlerregistry, IHandlerInstanceResolver resolver,IParameterResolver ParameterResolver)
 {
     this.eventstore = eventstore;
     this.handlerregistry = handlerregistry;
     this.resolver = resolver;
     this.ParameterResolver = ParameterResolver;
 }

        public MagistrateRegistry(IEventStore store)
        {
            Scan(a =>
            {
                a.TheCallingAssembly();
                a.WithDefaultConventions();

                a.AddAllTypesOf(typeof(IRequestHandler<,>));
                a.AddAllTypesOf(typeof(INotificationHandler<>));
                a.AddAllTypesOf(typeof(IController));
            });

            For<SingleInstanceFactory>().Use<SingleInstanceFactory>(ctx => t => ctx.GetInstance(t));
            For<MultiInstanceFactory>().Use<MultiInstanceFactory>(ctx => t => ctx.GetAllInstances(t));
            For<IMediator>().Use<Mediator>();

            Policies.Add<ServicePolicy>();
            Policies.Add<ReadModelPolicy>();

            For<Projectionist>().Singleton();
            For<IEventStore>()
                .Use(context => new ProjectionStore(store, context.GetInstance<Projectionist>().Apply));
            For<AggregateStore<Guid>>().Use(ctx => new AggregateStore<Guid>(ctx.GetInstance<IEventStore>()));

            For<JsonSerializerSettings>().Use(new JsonSerializerSettings
            {
                ContractResolver = new CamelCasePropertyNamesContractResolver()
            });
        }

 public UserStoryService(
     IEventStore eventStore,
     IPublishEvents eventsPublisher)
 {
     this.eventsPublisher = eventsPublisher;
     this.eventStore = eventStore;
 }

 public void Arrange()
 {
     // Arrange.
     eventStore = MockRepository.GenerateMock<IEventStore>();
     repository = new Repository<SchedulerJob>(eventStore);
     schedulerJobCommandHandlers = new SchedulerJobCommandHandlers(repository);
 }

 public void Dispatch(IEventStore eventStore, IEnumerable<DomainEvent> events)
 {
     foreach (var e in events)
     {
         Console.WriteLine(e);
     }
 }

 public ErrorQueueLoader(ITransactor transactor, IEventStore eventStore, IEventErrorStoreRepository eventErrorStoreRepository, IHandlerSequenceRespository handlerSequenceRepRespository)
 {
     _transactor = transactor;
     _eventStore = eventStore;
     _eventErrorStoreRepository = eventErrorStoreRepository;
     _handlerSequenceRepRespository = handlerSequenceRepRespository;
 }

 public RegistrationApplicationService( IEventStore eventStore,IDomainIdentityService ids, IUserIndexService uniqueness,  PasswordGenerator generator)
 {
     _eventStore = eventStore;
     _ids = ids;
     _uniqueness = uniqueness;
     _generator = generator;
 }

 public DefaultEventService(
     IJsonSerializer jsonSerializer,
     IScheduleService scheduleService,
     ITypeNameProvider typeNameProvider,
     IMemoryCache memoryCache,
     IAggregateRootFactory aggregateRootFactory,
     IAggregateStorage aggregateStorage,
     IEventStore eventStore,
     IMessagePublisher<DomainEventStreamMessage> domainEventPublisher,
     IOHelper ioHelper,
     ILoggerFactory loggerFactory)
 {
     _eventMailboxDict = new ConcurrentDictionary<string, EventMailBox>();
     _ioHelper = ioHelper;
     _jsonSerializer = jsonSerializer;
     _scheduleService = scheduleService;
     _typeNameProvider = typeNameProvider;
     _memoryCache = memoryCache;
     _aggregateRootFactory = aggregateRootFactory;
     _aggregateStorage = aggregateStorage;
     _eventStore = eventStore;
     _domainEventPublisher = domainEventPublisher;
     _logger = loggerFactory.Create(GetType().FullName);
     _batchSize = ENodeConfiguration.Instance.Setting.EventMailBoxPersistenceMaxBatchSize;
 }

        public MindReader(IEventStore store, StreamName streamName,  EmoEngine engine)
        {
            this.engine = engine;
            this.store = store;
            this.streamName = streamName;

            RegisterHandlers();
        }

 public void NotifyChanges(IEventStore eventStore, EventStream streamOfEvents)
 {
     foreach( var notifierType in _notifiers ) 
     {
         var notifier = _container.Get(notifierType) as IEventStoreChangeNotifier;
         notifier.Notify(eventStore, streamOfEvents);
     }  
 }

 public SequencedEventSelector(ITransactor transactor,
                               IEventStore eventStore,
                               IHandlerSequenceRespository handlerSequenceRespository)
 {
     _transactor = transactor;
     _eventStore = eventStore;
     _handlerSequenceRespository = handlerSequenceRespository;
 }

 public ResetAllEventsForAllSubscriptionsTask(
         IEventSubscriptionManager eventSubcriptionManager,
         IEventStore eventStore
     )
 {
     _eventSubscriptionManager = eventSubcriptionManager;
     _eventStore = eventStore;
 }

        public FactoryBasedAggregateRootRepository(IEventStore eventStore, IDomainEventSerializer domainEventSerializer, IDomainTypeNameMapper domainTypeNameMapper, Func<Type, AggregateRoot> aggregateRootFactoryMethod)
            : base(eventStore, domainEventSerializer, domainTypeNameMapper)
        {
            if (aggregateRootFactoryMethod == null)
                throw new ArgumentNullException("aggregateRootFactoryMethod");

            _aggregateRootFactoryMethod = aggregateRootFactoryMethod;
        }

        public static IEnumerable<object> BuildApplicationServices(IEventStore eventStore, IDocumentStore projectionStore)
        {
            var loginIndexService = new LoginIndexLookupService(projectionStore);

            yield return new Security.SecurityApplicationService(eventStore);
            yield return new Profile.ProfileApplicationService(eventStore);
            yield return new Registration.RegistrationApplicationService(eventStore, loginIndexService);
            yield break;
        }